Funzione GetLogicalProcessorInformation (sysinfoapi.h)

  • Articolo

Recupera informazioni sui processori logici e sull'hardware correlato.

Per recuperare informazioni sui processori logici e sull'hardware correlato, inclusi i gruppi di processori, usare la funzione GetLogicalProcessorInformationEx .

Sintassi

BOOL GetLogicalProcessorInformation(
  [out]     PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer,
  [in, out] PDWORD                                ReturnedLength
);

Parametri

[out] Buffer

Puntatore a un buffer che riceve una matrice di strutture SYSTEM_LOGICAL_PROCESSOR_INFORMATION . Se la funzione ha esito negativo, il contenuto di questo buffer non è definito.

[in, out] ReturnedLength

In input specifica la lunghezza del buffer a cui punta il buffer in byte. Se il buffer è abbastanza grande per contenere tutti i dati, questa funzione ha esito positivo e ReturnLength viene impostata sul numero di byte restituiti. Se il buffer non è sufficiente per contenere tutti i dati, la funzione ha esito negativo, GetLastError restituisce ERROR_INSUFFICIENT_BUFFER e ReturnLength è impostata sulla lunghezza del buffer necessaria per contenere tutti i dati. Se la funzione ha esito negativo con un errore diverso da ERROR_INSUFFICIENT_BUFFER, il valore di ReturnLength non è definito.

Valore restituito

Se la funzione ha esito positivo, il valore restituito è TRUE e almeno una struttura SYSTEM_LOGICAL_PROCESSOR_INFORMATION viene scritta nel buffer di output.

Se la funzione ha esito negativo, il valore restituito è FALSE. Per informazioni dettagliate sull'errore, chiamare GetLastError.

Commenti

GetLogicalProcessorInformation può essere usato per ottenere informazioni sulla relazione tra processori logici nel sistema, tra cui:

  • Processori logici che fanno parte di un nodo NUMA .
  • Processori logici che condividono le risorse. Un esempio di questo tipo di condivisione delle risorse sarebbe uno scenario di iperthreading.
L'applicazione può usare queste informazioni quando si affinizzano i thread e i processi per sfruttare al meglio le proprietà hardware della piattaforma o per determinare il numero di processori logici e fisici a scopo di licenza.

Ognuna delle strutture SYSTEM_LOGICAL_PROCESSOR_INFORMATION restituite nel buffer contiene quanto segue:

  • Maschera di affinità del processore logico, che indica i processori logici a cui si applicano le informazioni nella struttura.
  • Maschera del processore logico di tipo LOGICAL_PROCESSOR_RELATIONSHIP, che indica la relazione tra i processori logici nella maschera. Le applicazioni che chiamano questa funzione devono essere preparate per gestire valori di indicatore aggiuntivi in futuro.
Si noti che l'ordine in cui vengono restituite le strutture nel buffer può cambiare tra le chiamate a questa funzione.

Le dimensioni della struttura SYSTEM_LOGICAL_PROCESSOR_INFORMATION variano tra architetture del processore e versioni di Windows. Per questo motivo, le applicazioni devono prima chiamare questa funzione per ottenere le dimensioni del buffer necessarie, quindi allocare dinamicamente la memoria per il buffer.

Nei sistemi con più di 64 processori logici, la funzione GetLogicalProcessorInformation recupera le informazioni sul processore nel gruppo di processori a cui è attualmente assegnato il thread chiamante. Usare la funzione GetLogicalProcessorInformationEx per recuperare informazioni sui processori in tutti i gruppi di processori nel sistema.

Nota

A partire da TBD Release Iron, il comportamento di questa e altre funzioni NUMA sono state modificate per supportare meglio i sistemi con nodi contenenti più di 64 processori. Per altre informazioni su questa modifica, incluse informazioni sull'abilitazione del comportamento precedente di questa API, vedere Supporto NUMA.

Comportamento a partire da TBD Release Iron

Le strutture di relazione per RelationNumaNode contengono la maschera di affinità per l'affinità del nodo all'interno del gruppo del thread chiamante.

Esempio

Nell'esempio C++ seguente viene usata la funzione GetLogicalProcessorInformation per visualizzare informazioni sui processori nel sistema corrente. Poiché GetLogicalProcessorInformation non è presente in tutti i sistemi, questo esempio usa la funzione GetProcAddress anziché chiamare direttamente GetLogicalProcessorInformation .

In questo esempio viene segnalato il numero di core del processore attivo. Questo esempio segnala anche il numero di nodi NUMA, pacchetti fisici e cache nei sistemi che supportano queste informazioni. Per altre informazioni, vedere la descrizione del membro Relazione della struttura SYSTEM_LOGICAL_PROCESSOR_INFORMATION . Windows Server 2003, Windows XP Professional x64 Edition e Windows XP con SP3: In questo esempio viene segnalato il numero di processori fisici anziché il numero di core del processore attivo.


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

Requisiti

Requisito Valore
Client minimo supportato Windows Vista, Windows XP Professional x64 Edition, Windows XP con SP3 [app desktop | App UWP]
Server minimo supportato Windows Server 2003 [app desktop | App UWP]
Piattaforma di destinazione Windows
Intestazione sysinfoapi.h
Libreria Kernel32.lib
DLL Kernel32.dll

Vedere anche

GetLogicalProcessorInformationEx

LOGICAL_PROCESSOR_RELATIONSHIP

Funzioni di processi e thread

SYSTEM_LOGICAL_PROCESSOR_INFORMATION