使用GetLogicalProcessorInformation获取逻辑处理器的详细信息（NUMA节点数、物理CPU数、CPU核心数、逻辑CPU数、各级Cache）...

最新推荐文章于 2023-11-29 00:36:25 发布
最新推荐文章于 2023-11-29 00:36:25 发布
阅读量369 收藏
点赞数

　　现在多核处理器已经很普及了，市场主流是双核处理器，还有4核、8核等高端产品。而且Intel推广了超线程技术（Hyper-Threading Technology, HTT），可以将一个物理核心模拟为两个逻辑处理器。这一切使得“CPU数量”这一概念变得复杂起来，对于软件开发人员来说，希望能获得物理CPU数、CPU核心数、逻辑CPU数等详细信息。
　　在Windows平台，可以调用GetLogicalProcessorInformation函数来获取它们的详细信息。


一、背景知识

　　先来明确一下名词——
physical processor packages：物理处理器封装个数，即俗称的“物理CPU数”。例如一块“Intel Core i3-2310M”只有1个“物理处理器封装个数”。若对于有多个处理器插槽的服务器，“物理处理器封装个数”很可能会大于1。
processor cores：处理器核心数，即俗称的“CPU核心数”。例如“Intel Core i3-2310M”是双核处理器，它有2个“处理器核心数”。
logical processors：逻辑处理器数，即俗称的“逻辑CPU数”。例如“Intel Core i3-2310M”支持超线程，一个物理核心能模拟为两个逻辑处理器，即一块“Intel Core i3-2310M”有4个“逻辑处理器数”。

　　再来看看2个大家可能不太熟悉的名词——
SMP：Symmetrical Multi-Processing，对称多处理机。
NUMA：Non Uniform Memory Access，非均匀访存模型。http://msdn.microsoft.com/en-us/library/aa363804(v=vs.85).aspx

　　这个两个名词牵涉到很多专业知识，这里不做详细介绍，感兴趣的同学可以自行翻阅相关资料。
　　老版本的Windows系统（例如Windows XP）采用的是SMP模型。但后来因多核处理器及异构计算的发展，从Windows Server 2003开始使用NUMA模型，系统中支持多个NUMA节点。对于开发人员来说，当只有1个NUMA节点时，与SMP模型是差不多的。
　　对于 Windows XP，在打上SP3补丁后，也可以利用GetLogicalProcessorInformation函数获得NUMA等信息。


二、GetLogicalProcessorInformation函数的使用心得

　　在MSDN上我们可以查到GetLogicalProcessorInformation函数的帮助——
http://msdn.microsoft.com/en-us/library/ms683194(v=vs.85).aspx
GetLogicalProcessorInformation function

　　GetLogicalProcessorInformation函数还牵涉到一些结构体和枚举——
http://msdn.microsoft.com/en-us/library/ms686694(v=vs.85).aspx
SYSTEM_LOGICAL_PROCESSOR_INFORMATION structure

http://msdn.microsoft.com/en-us/library/ms684197(v=vs.85).aspx
LOGICAL_PROCESSOR_RELATIONSHIP enumeration

http://msdn.microsoft.com/en-us/library/ms681979(v=vs.85).aspx
CACHE_DESCRIPTOR structure

http://msdn.microsoft.com/en-us/library/ms684844(v=vs.85).aspx
PROCESSOR_CACHE_TYPE enumeration

　　GetLogicalProcessorInformation函数用起来是有一定复杂性的。因为它返回的是SYSTEM_LOGICAL_PROCESSOR_INFORMATION数组，数组中的每一项分别描述了不同的信息，学习曲线较陡峭。
　　虽然MSDN上有该函数的范例代码，但是它屏蔽了很多细节，对我们的帮助有限。于是我将该范例程序作了改进，显示了SYSTEM_LOGICAL_PROCESSOR_INFORMATION数组中每一项的详细信息。

　　心得——
1.SYSTEM_LOGICAL_PROCESSOR_INFORMATION结构ProcessorMask是ULONG_PTR类型的。在32位系统上是32位，64位系统上是64位。为了简化代码，建议强制转型为UINT64类型，调用printf等输出函数时使用“I64”格式码。
2.ProcessorMask是处理器掩码，每一位代表一个逻辑处理器。所以一般来说，32位系统最多支持32个逻辑处理器，64位系统最多支持64个逻辑处理器。
3.对于Windows 7和Windows Server 2008 R2来说，能突破64个逻辑处理器限制，最高支持256个逻辑处理器。新加了 处理器组（Processor Groups）概念，详见：http://msdn.microsoft.com/en-us/library/dd405503(v=vs.85).aspx。


三、全部代码

　　全部代码——

#include <windows.h>
#include <malloc.h>    
#include <stdio.h>
#include <tchar.h>

#if (_WIN32_WINNT < 0x0600)    // [zyl910] 低版本的Windows SDK没有定义 RelationProcessorPackage 等常量
#define RelationProcessorPackage    3
#define RelationGroup    4
#endif
// [zyl910] LOGICAL_PROCESSOR_RELATIONSHIP枚举的名称
const LPTSTR Names_LOGICAL_PROCESSOR_RELATIONSHIP[] = {
    _T("RelationProcessorCore")
    ,_T("RelationNumaNode")
    ,_T("RelationCache")
    ,_T("RelationProcessorPackage")
    ,_T("RelationGroup")
};
// [zyl910] PROCESSOR_CACHE_TYPE枚举的名称
const LPTSTR Names_PROCESSOR_CACHE_TYPE[] = {
    _T("CacheUnified")
    ,_T("CacheInstruction")
    ,_T("CacheData")
    ,_T("CacheTrace")
};

typedef BOOL (WINAPI *LPFN_GLPI)(
    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, 
    PDWORD);


// Helper function to count set bits in the processor mask.
DWORD CountSetBits(ULONG_PTR bitMask)
{
    DWORD LSHIFT = sizeof(ULONG_PTR)*8 - 1;
    DWORD bitSetCount = 0;
    ULONG_PTR bitTest = (ULONG_PTR)1 << LSHIFT;    
    DWORD i;
    
    for (i = 0; i <= LSHIFT; ++i)
    {
        bitSetCount += ((bitMask & bitTest)?1:0);
        bitTest/=2;
    }

    return bitSetCount;
}

int _cdecl _tmain ()
{
    LPFN_GLPI glpi;
    BOOL done = FALSE;
    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer = NULL;
    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = NULL;
    DWORD returnLength = 0;
    DWORD logicalProcessorCount = 0;
    DWORD numaNodeCount = 0;
    DWORD processorCoreCount = 0;
    DWORD processorL1CacheCount = 0;
    DWORD processorL2CacheCount = 0;
    DWORD processorL3CacheCount = 0;
    DWORD processorPackageCount = 0;
    DWORD byteOffset = 0;
    PCACHE_DESCRIPTOR Cache;

    glpi = (LPFN_GLPI) GetProcAddress(
                            GetModuleHandle(TEXT("kernel32")),
                            "GetLogicalProcessorInformation");
    if (NULL == glpi) 
    {
        _tprintf(TEXT("\nGetLogicalProcessorInformation is not supported.\n"));
        return (1);
    }

    while (!done)
    {
        DWORD rc = glpi(buffer, &returnLength);

        if (FALSE == rc) 
        {
            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) 
            {
                if (buffer) 
                    free(buffer);

                buffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(
                        returnLength);

                if (NULL == buffer) 
                {
                    _tprintf(TEXT("\nError: Allocation failure\n"));
                    return (2);
                }
            } 
            else 
            {
                _tprintf(TEXT("\nError %d\n"), GetLastError());
                return (3);
            }
        } 
        else
        {
            done = TRUE;
        }
    }

    ptr = buffer;

    if (true)    // [zyl910] 显示SYSTEM_LOGICAL_PROCESSOR_INFORMATION结构体的详细信息
    {
        DWORD cnt = returnLength / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);    // 计算SYSTEM_LOGICAL_PROCESSOR_INFORMATION结构体的数目
        for(DWORD i=0; i<cnt; ++i)
        {
            _tprintf(TEXT("SYSTEM_LOGICAL_PROCESSOR_INFORMATION[%d]\n"), i);
            _tprintf(TEXT("\t.ProcessorMask:\t0x%.16I64X\t//%I64d\n"), (UINT64)ptr[i].ProcessorMask, (UINT64)ptr[i].ProcessorMask);
            _tprintf(TEXT("\t.Relationship:\t%d\t//%s\n"), ptr[i].Relationship, Names_LOGICAL_PROCESSOR_RELATIONSHIP[max(0,min(ptr[i].Relationship, RelationGroup))]);
            for(int j=0; j<2; ++j)    _tprintf(TEXT("\t.Reserved[%d]:\t//0x%.16I64X\t%I64d\n"), j, (UINT64)ptr[i].Reserved[j], (UINT64)ptr[i].Reserved[j]);
            if (RelationCache==ptr[i].Relationship)
            {
                _tprintf(TEXT("\t.Cache.Level:\t%u\n"), ptr[i].Cache.Level);
                _tprintf(TEXT("\t.Cache.Associativity:\t0x%.2X\t//%u\n"), ptr[i].Cache.Associativity, ptr[i].Cache.Associativity);
                _tprintf(TEXT("\t.Cache.LineSize:\t0x%.4X\t//%u\n"), ptr[i].Cache.LineSize, ptr[i].Cache.LineSize);
                _tprintf(TEXT("\t.Cache.Size:\t0x%.8X\t//%u\n"), ptr[i].Cache.Size, ptr[i].Cache.Size);
                _tprintf(TEXT("\t.Cache.Type:\t%d\t//%s\n"), ptr[i].Cache.Type, Names_PROCESSOR_CACHE_TYPE[max(0,min(ptr[i].Cache.Type, CacheTrace))]);
            }
        }
    }

    while (byteOffset + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) <= returnLength) 
    {
        switch (ptr->Relationship) 
        {
        case RelationNumaNode:
            // Non-NUMA systems report a single record of this type.
            numaNodeCount++;
            break;

        case RelationProcessorCore:
            processorCoreCount++;

            // A hyperthreaded core supplies more than one logical processor.
            logicalProcessorCount += CountSetBits(ptr->ProcessorMask);
            break;

        case RelationCache:
            // Cache data is in ptr->Cache, one CACHE_DESCRIPTOR structure for each cache. 
            Cache = &ptr->Cache;
            if (Cache->Level == 1)
            {
                processorL1CacheCount++;
            }
            else if (Cache->Level == 2)
            {
                processorL2CacheCount++;
            }
            else if (Cache->Level == 3)
            {
                processorL3CacheCount++;
            }
            break;

        case RelationProcessorPackage:
            // Logical processors share a physical package.
            processorPackageCount++;
            break;

        default:
            _tprintf(TEXT("\nError: Unsupported LOGICAL_PROCESSOR_RELATIONSHIP value.\n"));
            break;
        }
        byteOffset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
        ptr++;
    }

    _tprintf(TEXT("\nGetLogicalProcessorInformation results:\n"));
    _tprintf(TEXT("Number of NUMA nodes: %d\n"), 
             numaNodeCount);
    _tprintf(TEXT("Number of physical processor packages: %d\n"), 
             processorPackageCount);
    _tprintf(TEXT("Number of processor cores: %d\n"), 
             processorCoreCount);
    _tprintf(TEXT("Number of logical processors: %d\n"), 
             logicalProcessorCount);
    _tprintf(TEXT("Number of processor L1/L2/L3 caches: %d/%d/%d\n"), 
             processorL1CacheCount,
             processorL2CacheCount,
             processorL3CacheCount);
    
    free(buffer);

    return 0;
}

 

 

四、输出信息


　　例如我的处理器是“Intel Core i3-2310M”，该程序的输出信息为——

SYSTEM_LOGICAL_PROCESSOR_INFORMATION[0]
    .ProcessorMask:    0x0000000000000005    //5
    .Relationship:    0    //RelationProcessorCore
    .Reserved[0]:    //0x0000000000000001    1
    .Reserved[1]:    //0x0000000000000000    0
SYSTEM_LOGICAL_PROCESSOR_INFORMATION[1]
    .ProcessorMask:    0x0000000000000005    //5
    .Relationship:    2    //RelationCache
    .Reserved[0]:    //0x0000800000400801    140737492551681
    .Reserved[1]:    //0x0000000000000002    2
    .Cache.Level:    1
    .Cache.Associativity:    0x08    //8
    .Cache.LineSize:    0x0040    //64
    .Cache.Size:    0x00008000    //32768
    .Cache.Type:    2    //CacheData
SYSTEM_LOGICAL_PROCESSOR_INFORMATION[2]
    .ProcessorMask:    0x0000000000000005    //5
    .Relationship:    2    //RelationCache
    .Reserved[0]:    //0x0000800000400801    140737492551681
    .Reserved[1]:    //0x0000000000000001    1
    .Cache.Level:    1
    .Cache.Associativity:    0x08    //8
    .Cache.LineSize:    0x0040    //64
    .Cache.Size:    0x00008000    //32768
    .Cache.Type:    1    //CacheInstruction
SYSTEM_LOGICAL_PROCESSOR_INFORMATION[3]
    .ProcessorMask:    0x0000000000000005    //5
    .Relationship:    2    //RelationCache
    .Reserved[0]:    //0x0004000000400802    1125899911038978
    .Reserved[1]:    //0x0000000000000000    0
    .Cache.Level:    2
    .Cache.Associativity:    0x08    //8
    .Cache.LineSize:    0x0040    //64
    .Cache.Size:    0x00040000    //262144
    .Cache.Type:    0    //CacheUnified
SYSTEM_LOGICAL_PROCESSOR_INFORMATION[4]
    .ProcessorMask:    0x000000000000000F    //15
    .Relationship:    3    //RelationProcessorPackage
    .Reserved[0]:    //0x0000000000000000    0
    .Reserved[1]:    //0x0000000000000000    0
SYSTEM_LOGICAL_PROCESSOR_INFORMATION[5]
    .ProcessorMask:    0x000000000000000A    //10
    .Relationship:    0    //RelationProcessorCore
    .Reserved[0]:    //0x0000000000000001    1
    .Reserved[1]:    //0x0000000000000000    0
SYSTEM_LOGICAL_PROCESSOR_INFORMATION[6]
    .ProcessorMask:    0x000000000000000A    //10
    .Relationship:    2    //RelationCache
    .Reserved[0]:    //0x0000800000400801    140737492551681
    .Reserved[1]:    //0x0000000000000002    2
    .Cache.Level:    1
    .Cache.Associativity:    0x08    //8
    .Cache.LineSize:    0x0040    //64
    .Cache.Size:    0x00008000    //32768
    .Cache.Type:    2    //CacheData
SYSTEM_LOGICAL_PROCESSOR_INFORMATION[7]
    .ProcessorMask:    0x000000000000000A    //10
    .Relationship:    2    //RelationCache
    .Reserved[0]:    //0x0000800000400801    140737492551681
    .Reserved[1]:    //0x0000000000000001    1
    .Cache.Level:    1
    .Cache.Associativity:    0x08    //8
    .Cache.LineSize:    0x0040    //64
    .Cache.Size:    0x00008000    //32768
    .Cache.Type:    1    //CacheInstruction
SYSTEM_LOGICAL_PROCESSOR_INFORMATION[8]
    .ProcessorMask:    0x000000000000000A    //10
    .Relationship:    2    //RelationCache
    .Reserved[0]:    //0x0004000000400802    1125899911038978
    .Reserved[1]:    //0x0000000000000000    0
    .Cache.Level:    2
    .Cache.Associativity:    0x08    //8
    .Cache.LineSize:    0x0040    //64
    .Cache.Size:    0x00040000    //262144
    .Cache.Type:    0    //CacheUnified
SYSTEM_LOGICAL_PROCESSOR_INFORMATION[9]
    .ProcessorMask:    0x000000000000000F    //15
    .Relationship:    2    //RelationCache
    .Reserved[0]:    //0x0030000000400C03    13510798886308867
    .Reserved[1]:    //0x0000000000000000    0
    .Cache.Level:    3
    .Cache.Associativity:    0x0C    //12
    .Cache.LineSize:    0x0040    //64
    .Cache.Size:    0x00300000    //3145728
    .Cache.Type:    0    //CacheUnified
SYSTEM_LOGICAL_PROCESSOR_INFORMATION[10]
    .ProcessorMask:    0x000000000000000F    //15
    .Relationship:    1    //RelationNumaNode
    .Reserved[0]:    //0x0000000000000000    0
    .Reserved[1]:    //0x0000000000000000    0

GetLogicalProcessorInformation results:
Number of NUMA nodes: 1
Number of physical processor packages: 1
Number of processor cores: 2
Number of logical processors: 4
Number of processor L1/L2/L3 caches: 4/2/1

 

 

源码下载——

http://files.cnblogs.com/zyl910/showGetLogicalProcessorInformation.rar

weixin_33704591
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
msvcr120_path_winxp_sp2
12-24
winXP SP2下运行程序报GetLogicalProcessorInformation 错误，解决方法。
无法定位程序输入点 GetLogicalProcessorInformation 与动态库 KERNEL32.DLL 上
热门推荐
HiZhanYue的博客
12-24 1万+
起因： 在XP SP2上运行程序，程序报错误。 原因： GetLogicalProcessorInformation 从XP SP3开始加入，以前的系统不支持。 在VS2013中搜索代码，并没有使用这个API，也使用XP兼容模式编译。 原因C++ 11中的线程类中使用了这个API 解决方法： http://forums.euw.leagu...
使用GetLogicalProcessorInformation获取逻辑处理器的详细信息
08-08
使用GetLogicalProcessorInformation获取逻辑处理器的详细信息（NUMA节点数、物理CPU数、CPU核心数、逻辑CPU数、各级Cache） 使用GetLogicalProcessorInformation获取逻辑处理器的详细信息（NUMA节点数、物理CPU数、CPU核心数、逻辑CPU数、各级Cache） 文章地址：http://blog.csdn.net/flyingleo1981/article/details/7842038
获取CPU处理器信息（GetLogicalProcessorInformation）
萧戈的专栏
11-28 2728
 Retrieves information about logical processors and related hardware. To retrieve information about logical processors and related hardware, including processor groups, use the GetLogicalProces
C++ 11 thread静态链接getlogicalprocessorinformation导致错误
文洲的专栏
10-15 1612
Windows中C++ 11 thread类静态链接getlogicalprocessorinformation导致在XP SP2之前报找不到定位点的错误，本文详细描述了定位这一问题的过程。
完美获取 CPU 的 NUMA节点数、CPU插槽个数 、 核心数 、 逻辑处理器数(线程数)、名字、制造商、指令集、主频、等等
04-17
完美获取 CPU 的 NUMA节点数、CPU插槽个数 、 核心数 、 逻辑处理器数(线程数)、名字、制造商、指令集、主频、等等
memAccess.tar_处理器_NUMA_memoryaccess_
10-03
针对NUMA架构的多核处理器，进行各个内存节点以及对应cache的访存验证。
MySQL性能全面优化方法参考,从CPU,文件系统选择到mysql.cnf参数优化
01-19
在服务器的BIOS设置中，可调整下面的几个配置，目的是发挥CPU最大性能，或者避免经典的NUMA问题： 1、选择Performance Per Watt Optimized(DAPC)模式，发挥CPU最大性能，跑DB这种通常需要高运算量的服务就不要考虑...
01-what-every-programmer-should-know about-memory.pdf
10-09
这是Ulrich Drepper的经典文章的英文原版，Ulrich Drepper是著名的德国工程师，是Glibc的第一代大当家（由于独断专行现在已经被褫夺了...RAM/DRAM的硬件原理、CPU的多级缓存机制、DMA原理等，是理解CPU基础机制的宝典。
获取内存NUMA信息
RichardYSteven的专栏
03-08 4219
linux内核获取NUMA信息
获取主机的物理CPU个数、虚拟化逻辑CPU总核数和物理CPU总核数
Entity_G的博客
08-11 811
在shell中可以使用expr命令实现乘法，比如expr 2 * 3 就是2乘以3到的6。
使用Coreinfo工具查看电脑CPU相关信息（cache，NUMA node，socket ）
DayDayUp
07-19 2547
CoreInfo是一个命令行实用程序，它向您介绍逻辑处理器和物理处理器，NUMA节点和它们所在的套接字之间的映射，以及分配给每个逻辑处理器的缓存。 它使用Windows中GetLogicalProcessorInformation函数来获取此信息并将其打印到屏幕，表示与具有星号的逻辑处理器的映..
linux 查看numa信息,Linux Shell脚本查看NUMA信息
weixin_31199791的博客
05-12 188
#!/bin/bashfunction get_nr_processor(){grep '^processor' /proc/cpuinfo | wc -l}function get_nr_socket(){grep 'physical id' /proc/cpuinfo | awk -F: '{print $2 | "sort -un"}' | wc -l}function get_nr_sib...
NUMA详解
zyqash的博客
04-26 6423
Numa（Non-Uniform Memory Access）是一种计算机架构，它允许多个处理器通过共享内存来访问系统的物理内存，但是不同的内存区域可能由不同的处理器处理，这种内存访问方式被称为“非一致性内存访问”。在这种架构中，每个处理器都有自己的本地内存，但它们可以访问其他处理器的内存。这种架构可以提高多处理器系统的性能，并使系统更具可扩展性。在Numa系统中，每个处理器有一个本地内存子系统，每个本地内存子系统都连接到一个全局内存交换网络。
numa查看和命令
sinat_41904636的博客
08-28 1327
7、 测试（访问不同节点的内存的IO）（参考linux NUMA技术_未央君x的博客-CSDN博客）num_foregin是打算在其他节点分配内存，最后却从这个节点分配的次数;numa_hit是打算在该节点上分配内存，最后从这个节点分配的次数;num_miss是打算在该节点分配内存，最后却从其他节点分配的次数;local_node该节点上的进程在该节点上分配的次数。other_node是其他节点进程在该节点上分配的次数。明显访问同一节点的内存速度比访问不同节点内存的速度快。结论和write 相同。
MFC实现获取电脑CPU核心数、显卡型号和内存大小等硬件信息的功能
最新发布
希望我的博客，能帮上你解决学习中工作中所遇到的问题
11-29 409
MFC实现获取电脑CPU核心数、显卡型号和内存大小等硬件信息的功能
如何知道SQL Server机器上有多少个NUMA节点
dingshen2767的博客
05-26 179
如何知道SQL Server机器上有多少个NUMA节点 文章出处： How can you tell how many NUMA nodes your SQL Server has? http://itknowledgeexchange.techtarget.com/sql-server/can-tell-many-numa-nodes-sql-server/?agedby=16 ...
如果一个软件需要使用8个线程，该申请多少节点和cpu数？
weixin_42588555的博客
01-09 159
如果一个软件需要使用 8 个线程，那么它就需要申请 8 个 CPU。如果您想要在单个节点上运行该软件，则您需要申请一个节点，其中包含至少 8 个 CPU。如果您想在多个节点上运行该软件，则需要申请足够的节点和 CPU，以便满足线程数的要求。 ...
获取cpu numa 数目
09-08
4. 在“NUMA信息”部分中，检查“NUMA 节点数”这一项，即可获得NUMA数目的结果。 方法三：使用系统信息工具 1. 打开“系统信息”工具，可以在开始菜单中搜索； 2. 在“系统摘要”部分，找到“处理器”一项，点击...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值