Esempio n. 1
0
        private void InitializeActorMethodInfo(DiagnosticsEventManager diagnosticsEventManager)
        {
            this.actorMethodCounterInstanceData = new Dictionary <long, CounterInstanceData>();
            var methodInfoList = new List <KeyValuePair <long, MethodInfo> >();

            foreach (var actorInterfaceType in this.actorTypeInformation.InterfaceTypes)
            {
                int interfaceId;
                MethodDescription[] actorInterfaceMethodDescriptions;
                diagnosticsEventManager.ActorMethodFriendlyNameBuilder.GetActorInterfaceMethodDescriptions(actorInterfaceType, out interfaceId, out actorInterfaceMethodDescriptions);
                foreach (var actorInterfaceMethodDescription in actorInterfaceMethodDescriptions)
                {
                    var kvp = new KeyValuePair <long, MethodInfo>(
                        DiagnosticsEventManager.GetInterfaceMethodKey((uint)interfaceId, (uint)actorInterfaceMethodDescription.Id),
                        actorInterfaceMethodDescription.MethodInfo);
                    methodInfoList.Add(kvp);
                }
            }

            // Compute the counter instance names for all the actor methods
            var percCounterInstanceNameBuilder = new PerformanceCounterInstanceNameBuilder(this.partitionId, this.counterInstanceDifferentiator);
            var counterInstanceNames           = percCounterInstanceNameBuilder.GetActorMethodCounterInstanceNames(methodInfoList);

            foreach (var kvp in counterInstanceNames)
            {
                this.actorMethodCounterInstanceData[kvp.Key] = new CounterInstanceData {
                    InstanceName = kvp.Value
                };
            }
        }
Esempio n. 2
0
        internal Dictionary <long, CounterInstanceData> CreateActorMethodCounterInstanceData(
            List <KeyValuePair <long, MethodInfo> > methodInfoList,
            PerformanceCounterInstanceNameBuilder percCounterInstanceNameBuilder)
        {
            var actorMethodCounterInstanceData = new Dictionary <long, CounterInstanceData>();


            // Compute the counter instance names for all the actor methods
            var counterInstanceNames = percCounterInstanceNameBuilder.GetMethodCounterInstanceNames(methodInfoList);
            FabricPerformanceCounterSet actorMethodCounterSet;

            if (!AvaiableFabricCounterSet.TryGetValue(ActorPerformanceCounters.ActorMethodCategoryName,
                                                      out actorMethodCounterSet))
            {
                ActorTrace.Source.WriteWarning(
                    TraceType,
                    "PerformanceCounterSet not generated yet for category {0}",
                    ActorPerformanceCounters.ActorMethodCategoryName);
                return(null);
            }

            foreach (var kvp in counterInstanceNames)
            {
                var data = new CounterInstanceData {
                    InstanceName = kvp.Value
                };
                data.CounterWriters = this.CreateCounterWriters(data, actorMethodCounterSet);
                actorMethodCounterInstanceData[kvp.Key] = data;
            }
            return
                (actorMethodCounterInstanceData);
        }
Esempio n. 3
0
        internal virtual void InitializeActorMethodInfo(DiagnosticsEventManager diagnosticsEventManager)
        {
            this.actorMethodCounterInstanceData = new Dictionary <long, CounterInstanceData>();
            var methodInfoList = new List <KeyValuePair <long, MethodInfo> >();

            foreach (var actorInterfaceType in this.actorTypeInformation.InterfaceTypes)
            {
                int interfaceId;
                MethodDescription[] actorInterfaceMethodDescriptions;
                diagnosticsEventManager.ActorMethodFriendlyNameBuilder.GetActorInterfaceMethodDescriptions(
                    actorInterfaceType, out interfaceId, out actorInterfaceMethodDescriptions);
                methodInfoList.AddRange(this.GetMethodInfo(actorInterfaceMethodDescriptions, interfaceId));
            }

            // Compute the counter instance names for all the actor methods
            var percCounterInstanceNameBuilder =
                new PerformanceCounterInstanceNameBuilder(this.partitionId, this.counterInstanceDifferentiator);

            this.actorMethodCounterInstanceData =
                this.CreateActorMethodCounterInstanceData(methodInfoList, percCounterInstanceNameBuilder);
        }
        internal override void InitializeActorMethodInfo(DiagnosticsEventManager diagnosticsEventManager)
        {
            base.InitializeActorMethodInfo(diagnosticsEventManager);

            this.actorMethodCounterInstanceDataV2 = new Dictionary <long, CounterInstanceData>();

            var methodInfoListV2 = new List <KeyValuePair <long, MethodInfo> >();

            foreach (var actorInterfaceType in this.actorTypeInformation.InterfaceTypes)
            {
                int interfaceIdV2;
                MethodDescription[] actorInterfaceMethodDescriptions;
                diagnosticsEventManager.ActorMethodFriendlyNameBuilder.GetActorInterfaceMethodDescriptionsV2(actorInterfaceType,
                                                                                                             out interfaceIdV2,
                                                                                                             out actorInterfaceMethodDescriptions);
                methodInfoListV2.AddRange(this.GetMethodInfo(actorInterfaceMethodDescriptions, interfaceIdV2));
            }
            var percCounterInstanceNameBuilderV2 =
                new PerformanceCounterInstanceNameBuilder(this.partitionId, this.counterInstanceDifferentiatorV2, PerformanceCounterInstanceNameBuilder.DefaultMaxInstanceNameVariablePartsLen - 3);

            this.actorMethodCounterInstanceDataV2 = this.CreateActorMethodCounterInstanceData(methodInfoListV2, percCounterInstanceNameBuilderV2);
        }