GetProcessInfos() [2/3]

static ProcessInfo[] System.Diagnostics.NtProcessManager.GetProcessInfos ( PerformanceCounterLib library, int processIndex, int threadIndex, ReadOnlySpan< byte > data )

inlinestaticprivate

Definition at line 215 of file NtProcessManager.cs.

    {
        Dictionary<int, ProcessInfo> dictionary = new Dictionary<int, ProcessInfo>();
        List<ThreadInfo> list = new List<ThreadInfo>();
        ref readonly global::Interop.Advapi32.PERF_DATA_BLOCK reference = ref MemoryMarshal.AsRef<global::Interop.Advapi32.PERF_DATA_BLOCK>(data);
        int num = reference.HeaderLength;
        for (int i = 0; i < reference.NumObjectTypes; i++)
        {
            ref readonly global::Interop.Advapi32.PERF_OBJECT_TYPE reference2 = ref MemoryMarshal.AsRef<global::Interop.Advapi32.PERF_OBJECT_TYPE>(data.Slice(num));
            global::Interop.Advapi32.PERF_COUNTER_DEFINITION[] array = new global::Interop.Advapi32.PERF_COUNTER_DEFINITION[reference2.NumCounters];
            int num2 = num + reference2.HeaderLength;
            for (int j = 0; j < reference2.NumCounters; j++)
            {
                ref readonly global::Interop.Advapi32.PERF_COUNTER_DEFINITION reference3 = ref MemoryMarshal.AsRef<global::Interop.Advapi32.PERF_COUNTER_DEFINITION>(data.Slice(num2));
                string counterName = library.GetCounterName(reference3.CounterNameTitleIndex);
                array[j] = reference3;
                if (reference2.ObjectNameTitleIndex == processIndex)
                {
                    array[j].CounterNameTitlePtr = (int)GetValueId(counterName);
                }
                else if (reference2.ObjectNameTitleIndex == threadIndex)
                {
                    array[j].CounterNameTitlePtr = (int)GetValueId(counterName);
                }
                num2 += reference3.ByteLength;
            }
            int num3 = num + reference2.DefinitionLength;
            for (int k = 0; k < reference2.NumInstances; k++)
            {
                ref readonly global::Interop.Advapi32.PERF_INSTANCE_DEFINITION reference4 = ref MemoryMarshal.AsRef<global::Interop.Advapi32.PERF_INSTANCE_DEFINITION>(data.Slice(num3));
                ReadOnlySpan<char> span = global::Interop.Advapi32.PERF_INSTANCE_DEFINITION.GetName(in reference4, data.Slice(num3));
                if (!MemoryExtensions.Equals(span, "_Total", StringComparison.Ordinal))
                {
                    if (reference2.ObjectNameTitleIndex == processIndex)
                    {
                        ProcessInfo processInfo = GetProcessInfo(data.Slice(num3 + reference4.ByteLength), array);
                        if ((processInfo.ProcessId != 0 || MemoryExtensions.Equals(span, "Idle", StringComparison.OrdinalIgnoreCase)) && !dictionary.ContainsKey(processInfo.ProcessId))
                        {
                            if (span.Length == 15)
                            {
                                if (span.EndsWith(".", StringComparison.Ordinal))
                                {
                                    span = span.Slice(0, 14);
                                }
                                else if (span.EndsWith(".e", StringComparison.Ordinal))
                                {
                                    span = span.Slice(0, 13);
                                }
                                else if (span.EndsWith(".ex", StringComparison.Ordinal))
                                {
                                    span = span.Slice(0, 12);
                                }
                            }
                            processInfo.ProcessName = span.ToString();
                            dictionary.Add(processInfo.ProcessId, processInfo);
                        }
                    }
                    else if (reference2.ObjectNameTitleIndex == threadIndex)
                    {
                        ThreadInfo threadInfo = GetThreadInfo(data.Slice(num3 + reference4.ByteLength), array);
                        if (threadInfo._threadId != 0L)
                        {
                            list.Add(threadInfo);
                        }
                    }
                }
                num3 += reference4.ByteLength;
                num3 += MemoryMarshal.AsRef<global::Interop.Advapi32.PERF_COUNTER_BLOCK>(data.Slice(num3)).ByteLength;
            }
            num += reference2.TotalByteLength;
        }
        for (int l = 0; l < list.Count; l++)
        {
            ThreadInfo threadInfo2 = list[l];
            if (dictionary.TryGetValue(threadInfo2._processId, out var value))
            {
                value._threadInfoList.Add(threadInfo2);
            }
        }
        ProcessInfo[] array2 = new ProcessInfo[dictionary.Values.Count];
        dictionary.Values.CopyTo(array2, 0);
        return array2;
    }

References System.Collections.Generic.Dictionary< TKey, TValue >.Add(), System.array, System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.dictionary, System.MemoryExtensions.Equals(), System.Diagnostics.NtProcessManager.GetProcessInfo(), System.Diagnostics.NtProcessManager.GetThreadInfo(), System.Diagnostics.NtProcessManager.GetValueId(), System.L, System.list, and System.value.