コード例 #1
0
 internal CacheDescriptor(CacheLevel level, CacheAssociativity associativity, Int16 lineSize, Int32 size, ProcessorCacheType type)
 {
     m_level         = level;
     m_associativity = associativity;
     m_lineSize      = lineSize;
     m_size          = size;
     m_type          = type;
 }
コード例 #2
0
        public static unsafe LogicalProcessorInformation[] GetLogicalProcessorInformation()
        {
            // Get the required buffer size
            Int32 length = 0;

            NativeMethods.GetLogicalProcessorInformation(null, ref length);
            Contract.Assume(length > 0);

            // Allocate the buffer & query the data
            Byte[] bytes = new Byte[length];
            fixed(Byte *pb = &bytes[0])
            {
                Boolean ok = NativeMethods.GetLogicalProcessorInformation(pb, ref length);

                if (!ok)
                {
                    throw new Win32Exception();
                }
            }

            List <LogicalProcessorInformation> list = new List <LogicalProcessorInformation>();

            for (Int32 elementIndex = 0; elementIndex < length; elementIndex += (2 * IntPtr.Size) + 16)
            {
                Int32 index = elementIndex;
                Int64 processorMask;
                if (IntPtr.Size == 4)
                {
                    processorMask = (Int64)BitConverter.ToInt32(bytes, index);
                }
                else
                {
                    processorMask = BitConverter.ToInt64(bytes, index);
                }
                index += IntPtr.Size;

                LogicalProcessorRelationship lpr;
                if (IntPtr.Size == 4)
                {
                    lpr = (LogicalProcessorRelationship)BitConverter.ToInt32(bytes, index);
                }
                else
                {
                    lpr = (LogicalProcessorRelationship)BitConverter.ToInt64(bytes, index);
                }
                index += IntPtr.Size;

                LogicalProcessorInformation lpi = null;
                switch (lpr)
                {
                case LogicalProcessorRelationship.Cache:
                    CacheLevel         level         = (CacheLevel)bytes[index++];
                    CacheAssociativity associativity = (CacheAssociativity)bytes[index++];
                    Int16 lineSize          = BitConverter.ToInt16(bytes, index); index += 2;
                    Int32 size              = BitConverter.ToInt32(bytes, index); index += 4;
                    ProcessorCacheType type = (ProcessorCacheType)BitConverter.ToInt32(bytes, index);
                    lpi = new LogicalProcessorInformation(processorMask, lpr, new CacheDescriptor(level, associativity, lineSize, size, type));
                    break;

                case LogicalProcessorRelationship.NumaNode:
                    lpi = new LogicalProcessorInformation(processorMask, lpr, BitConverter.ToInt32(bytes, index));
                    break;

                case LogicalProcessorRelationship.ProcessorCore:
                    lpi = new LogicalProcessorInformation(processorMask, lpr, bytes[index]);
                    break;

                case LogicalProcessorRelationship.ProcessorPackage:
                    lpi = new LogicalProcessorInformation(processorMask, lpr);
                    break;
                }
                list.Add(lpi);
            }
            return(list.ToArray());
        }