Existe uma maneira de determinar quantos núcleos uma máquina possui do C / C ++ de maneira independente da plataforma? Se isso não existe, que tal determiná-lo por plataforma (Windows / * nix / Mac)?

C ++ 11

#include <thread>

//may return 0 when not able to detect
const auto processor_count = std::thread::hardware_concurrency();

Referência: std :: thread :: hardware_concurrency

No C ++ anterior ao C ++ 11, não há maneira portátil. Em vez disso, você precisará usar um ou mais dos seguintes métodos (protegidos pelas #ifdeflinhas apropriadas ):

• Win32

  SYSTEM_INFO sysinfo;
  GetSystemInfo(&sysinfo);
  int numCPU = sysinfo.dwNumberOfProcessors;
  

• Linux, Solaris, AIX e Mac OS X> = 10.4 (ou seja, Tiger em diante)

  int numCPU = sysconf(_SC_NPROCESSORS_ONLN);

• FreeBSD, MacOS X, NetBSD, OpenBSD, etc.

  int mib[4];
  int numCPU;
  std::size_t len = sizeof(numCPU); 
  
  /* set the mib for hw.ncpu */
  mib[0] = CTL_HW;
  mib[1] = HW_AVAILCPU;  // alternatively, try HW_NCPU;
  
  /* get the number of CPUs from the system */
  sysctl(mib, 2, &numCPU, &len, NULL, 0);
  
  if (numCPU < 1) 
  {
      mib[1] = HW_NCPU;
      sysctl(mib, 2, &numCPU, &len, NULL, 0);
      if (numCPU < 1)
          numCPU = 1;
  }
  

• HPUX

  int numCPU = mpctl(MPC_GETNUMSPUS, NULL, NULL);

• IRIX

  int numCPU = sysconf(_SC_NPROC_ONLN);

• Objective-C (Mac OS X> = 10.5 ou iOS)

  NSUInteger a = [[NSProcessInfo processInfo] processorCount];
  NSUInteger b = [[NSProcessInfo processInfo] activeProcessorCount];
  

Essa funcionalidade faz parte do padrão C ++ 11.

#include <thread>

unsigned int nthreads = std::thread::hardware_concurrency();

Para compiladores mais antigos, você pode usar a biblioteca Boost.Thread .

#include <boost/thread.hpp>

unsigned int nthreads = boost::thread::hardware_concurrency();

Nos dois casos, hardware_concurrency()retorna o número de threads que o hardware é capaz de executar simultaneamente, com base no número de núcleos da CPU e unidades de hyperthreading.

O OpenMP é suportado em muitas plataformas (incluindo o Visual Studio 2005) e oferece um

int omp_get_num_procs();

função que retorna o número de processadores / núcleos disponíveis no momento da chamada.

Se você tiver acesso à linguagem assembly, poderá usar a instrução CPUID para obter todos os tipos de informações sobre a CPU. É portátil entre sistemas operacionais, embora você precise usar informações específicas do fabricante para determinar como encontrar o número de núcleos. Aqui está um documento que descreve como fazê-lo em chips Intel , e a página 11 deste descreve a especificação da AMD.

Função (quase) independente de plataforma no código c

#ifdef _WIN32
#include <windows.h>
#elif MACOS
#include <sys/param.h>
#include <sys/sysctl.h>
#else
#include <unistd.h>
#endif

int getNumCores() {
#ifdef WIN32
    SYSTEM_INFO sysinfo;
    GetSystemInfo(&sysinfo);
    return sysinfo.dwNumberOfProcessors;
#elif MACOS
    int nm[2];
    size_t len = 4;
    uint32_t count;

    nm[0] = CTL_HW; nm[1] = HW_AVAILCPU;
    sysctl(nm, 2, &count, &len, NULL, 0);

    if(count < 1) {
        nm[1] = HW_NCPU;
        sysctl(nm, 2, &count, &len, NULL, 0);
        if(count < 1) { count = 1; }
    }
    return count;
#else
    return sysconf(_SC_NPROCESSORS_ONLN);
#endif
}

No Linux, você pode ler o arquivo / proc / cpuinfo e contar os núcleos.

Observe que "número de núcleos" pode não ser um número particularmente útil; talvez seja necessário qualificá-lo um pouco mais. Como você deseja contar com CPUs multithread, como Intel HT, IBM Power5 e Power6, e mais famoso, Niagara / UltraSparc T1 e T2 da Sun? Ou ainda mais interessante, o MIPS 1004k com seus dois níveis de encadeamento de hardware (supervisor E nível de usuário) ... Sem mencionar o que acontece quando você se muda para sistemas suportados por hipervisor, nos quais o hardware pode ter dezenas de CPUs, mas seu SO específico só vê alguns.

O melhor que você pode esperar é informar o número de unidades de processamento lógico que você possui na partição do sistema operacional local. Esqueça de ver a máquina verdadeira, a menos que você seja um hipervisor. Hoje, a única exceção a essa regra está no terreno x86, mas o fim das máquinas não virtuais está chegando rapidamente ...

Mais uma receita do Windows: use a variável de ambiente de todo o sistema NUMBER_OF_PROCESSORS:

printf("%d\n", atoi(getenv("NUMBER_OF_PROCESSORS")));

Você provavelmente não conseguirá obtê-lo de maneira independente da plataforma. Windows você obtém número de processadores.

Informações do sistema Win32

Windows (x64 e Win32) e C ++ 11

O número de grupos de processadores lógicos que compartilham um único núcleo de processador. (Usando GetLogicalProcessorInformationEx , consulte GetLogicalProcessorInformation também)

size_t NumberOfPhysicalCores() noexcept {

    DWORD length = 0;
    const BOOL result_first = GetLogicalProcessorInformationEx(RelationProcessorCore, nullptr, &length);
    assert(GetLastError() == ERROR_INSUFFICIENT_BUFFER);

    std::unique_ptr< uint8_t[] > buffer(new uint8_t[length]);
    const PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX info = 
            reinterpret_cast< PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX >(buffer.get());

    const BOOL result_second = GetLogicalProcessorInformationEx(RelationProcessorCore, info, &length);
    assert(result_second != FALSE);

    size_t nb_physical_cores = 0;
    size_t offset = 0;
    do {
        const PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX current_info =
            reinterpret_cast< PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX >(buffer.get() + offset);
        offset += current_info->Size;
        ++nb_physical_cores;
    } while (offset < length);

    return nb_physical_cores;
}

Observe que a implementação do NumberOfPhysicalCoresIMHO está longe de ser trivial (ou seja, "use GetLogicalProcessorInformationor GetLogicalProcessorInformationEx"). Em vez disso, é bastante sutil se alguém ler a documentação (explicitamente presente para GetLogicalProcessorInformatione implicitamente presente para GetLogicalProcessorInformationEx) no MSDN.

O número de processadores lógicos. (Usando GetSystemInfo )

size_t NumberOfSystemCores() noexcept {
    SYSTEM_INFO system_info;
    ZeroMemory(&system_info, sizeof(system_info));

    GetSystemInfo(&system_info);

    return static_cast< size_t >(system_info.dwNumberOfProcessors);
}

Observe que ambos os métodos podem ser facilmente convertidos em C / C ++ 98 / C ++ 03.

Mais informações sobre o OS X: sysconf(_SC_NPROCESSORS_ONLN)está disponível apenas nas versões> = 10.5, não 10.4.

Uma alternativa é o HW_AVAILCPU/sysctl()código BSD que está disponível nas versões> = 10.2.

O Windows Server 2003 e versões posteriores permitem que você aproveite a função GetLogicalProcessorInformation

http://msdn.microsoft.com/en-us/library/ms683194.aspx

Não relacionado ao C ++, mas no Linux eu costumo fazer:

grep processor /proc/cpuinfo | wc -l

Útil para linguagens de script como bash / perl / python / ruby.

vale a pena ver o hwloc (http://www.open-mpi.org/projects/hwloc/). Embora exija outra integração de biblioteca em seu código, ele pode fornecer todas as informações sobre seu processador (número de núcleos, topologia etc.)

No linux, a melhor maneira programática, até onde eu sei, é usar

sysconf(_SC_NPROCESSORS_CONF)

ou

sysconf(_SC_NPROCESSORS_ONLN)

Estes não são padrão, mas estão na minha página de manual do Linux.

No Linux, pode não ser seguro usá- _SC_NPROCESSORS_ONLNlo, pois não faz parte do padrão POSIX e o manual sysconf afirma o mesmo. Portanto, há uma possibilidade que _SC_NPROCESSORS_ONLNpode não estar presente:

 These values also exist, but may not be standard.

     [...]     

     - _SC_NPROCESSORS_CONF
              The number of processors configured.   
     - _SC_NPROCESSORS_ONLN
              The number of processors currently online (available).

Uma abordagem simples seria ler /proc/statou /proc/cpuinfocontá-los:

#include<unistd.h>
#include<stdio.h>

int main(void)
{
char str[256];
int procCount = -1; // to offset for the first entry
FILE *fp;

if( (fp = fopen("/proc/stat", "r")) )
{
  while(fgets(str, sizeof str, fp))
  if( !memcmp(str, "cpu", 3) ) procCount++;
}

if ( procCount == -1) 
{ 
printf("Unable to get proc count. Defaulting to 2");
procCount=2;
}

printf("Proc Count:%d\n", procCount);
return 0;
}

Usando /proc/cpuinfo:

#include<unistd.h>
#include<stdio.h>

int main(void)
{
char str[256];
int procCount = 0;
FILE *fp;

if( (fp = fopen("/proc/cpuinfo", "r")) )
{
  while(fgets(str, sizeof str, fp))
  if( !memcmp(str, "processor", 9) ) procCount++;
}

if ( !procCount ) 
{ 
printf("Unable to get proc count. Defaulting to 2");
procCount=2;
}

printf("Proc Count:%d\n", procCount);
return 0;
}

A mesma abordagem no shell usando grep:

grep -c ^processor /proc/cpuinfo

Ou

grep -c ^cpu /proc/stat # subtract 1 from the result

Alternativa para OS X: a solução descrita anteriormente com base em [[NSProcessInfo processInfo] processorCount] está disponível apenas no OS X 10.5.0, de acordo com a documentação. Para versões anteriores do OS X, use a função Carbon MPProcessors ().

Se você é um programador de cacau, não se assuste com o fato de ser carbono. Você só precisa adicionar a estrutura Carbon ao seu projeto Xcode e o MPProcessors () estará disponível.

Para Win32:

Enquanto GetSystemInfo () obtém o número de processadores lógicos , use GetLogicalProcessorInformationEx () para obter o número de processadores físicos .

você também pode usar o WMI no .net, mas depende do serviço wmi em execução etc. Às vezes, funciona localmente, mas falha quando o mesmo código é executado nos servidores. Acredito que seja um problema de espaço para nome, relacionado aos "nomes" cujos valores você está lendo.

No Linux, você pode verificar o dmesg e filtrar as linhas onde a ACPI inicializa as CPUs, algo como:

dmesg | grep 'ACPI: Processor"

Outra possibilidade é usar o dmidecode para filtrar as informações do processador.