GetLogicalProcessorInformation

原文链接 -> 传送门

函数功能：

GetLogicalProcessorInformation 函数用于获取逻辑处理器和相关硬件的有关信息。

若想获取包括处理器集群的逻辑处理器和相关硬件的有关信息，请使用 GetLogicalProcessorInformationEx 函数。


API 函数原型：

注释：_Out_ 说明该参数是输出的，_Inout_ 说明该参数既是输入又是输出的。

BOOL WINAPI GetLogicalProcessorInformation(
  _Out_   PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer,
  _Inout_ PDWORD                                ReturnLength
);

参数解析：
 

返回值：

1. 如果函数调用成功，则返回值为 TRUE，并且至少有一个 SYSTEM_LOGICAL_PROCESSOR_INFORMATION 结构被写入到输出缓冲区；

2. 如果函数调用失败，则返回值为 FALSE。

获取有关错误的更多信息，请调用 GetLastError 函数。


备注：

1. GetLogicalProcessorInformation 函数可以被用来获取有关系统中逻辑处理器之间的关系的信息，包括：
 

·         逻辑处理器是一个 NUMA 节点的一部分

·         逻辑处理器能共享资源。超线程技术方案便是这种类型的资源共享的例子

2. 你的应用程序可以使用这些信息来使线程和进程能够最大化利用平台硬件性能，或者因许可原因用来决定使用的逻辑和物理处理器的数目。

3. 每一个返回到缓冲区的 SYSTEM_LOGICAL_PROCESSOR_INFORMATION 结构都包括下列：
 

·         一个逻辑处理器亲和力掩码，该掩码表示结构体中信息适用的逻辑处理器

·         一个 LOGICAL_PROCESSOR_RELATIONSHIP 类型的逻辑处理器掩码，该掩码表示在掩码中逻辑处理器之间的关系

4. 注意缓冲区中返回的结构体的顺序可能在该函数的调用间改变。

5. SYSTEM_LOGICAL_PROCESSOR_INFORMATION 结构的大小因处理器架构和 Windows 系统版本而不同。因为这个原因，应用程序应该首先调用该函数来获取所需的缓冲区大小，然后动态地为缓冲区分配内存。

6. 在有超过 64 个逻辑处理器的系统上，GetLogicalProcessorInformation 函数获取调用线程当前分配的处理器集群中逻辑处理器的有关信息。使用 GetLogicalProcessorInformationEx 函数来获取系统中所有处理器集群中的处理器信息。


例子：

下面的 C++ 例子使用 GetLogicalProcessorInformation 函数来显示当前系统中处理器的有关信息。因为 GetLogicalProcessorInformation 函数并不是在所有系统中都存在，该例子使用了 GetProcAddress 函数而不是直接调用 GetLogicalProcessorInformation 函数。

该例子显示活动的处理器核心数。也显示了 NUMA 节点，物理包的数目以及支持该信息的系统上的缓存。更多信息，请参见 SYSTEM_LOGICAL_PROCESSOR_INFORMATION 结构 Relationship 成员的描述。

Windows Server 2003, Windows XP Professional x64 Edition and Windows XP with SP3：该例子显示物理处理器的数目而不是活动的处理器核心数。
 

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

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;

    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;
}

需求：