c++ - how - Encontrar programáticamente el número de núcleos en una máquina.
how can c++ code call ac function (20)
C ++ 11
//may return 0 when not able to detect
unsigned concurentThreadsSupported = std::thread::hardware_concurrency();
Referencia: std::thread::hardware_concurrency
En C ++ antes de C ++ 11, no hay forma portátil. En su lugar, deberá usar uno o más de los siguientes métodos (protegidos por las líneas #ifdef apropiadas):
Win32
SYSTEM_INFO sysinfo; GetSystemInfo(&sysinfo); int numCPU = sysinfo.dwNumberOfProcessors;Linux, Solaris, AIX y Mac OS X> = 10.4 (es decir, Tiger en adelante)
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 o iOS)
NSUInteger a = [[NSProcessInfo processInfo] processorCount]; NSUInteger b = [[NSProcessInfo processInfo] activeProcessorCount];
¿Hay una manera de determinar cuántos núcleos tiene una máquina de C / C ++ de forma independiente de la plataforma? Si no existe tal cosa, ¿qué hay de determinarlo por plataforma (Windows / * nix / Mac)?
Windows (x64 y Win32) y C ++ 11
La cantidad de grupos de procesadores lógicos que comparten un solo núcleo de procesador. (Utilizando GetLogicalProcessorInformationEx , vea también GetLogicalProcessorInformation )
size_t NumberOfPhysicalCores() noexcept {
DWORD length = 0;
const BOOL result_first = GetLogicalProcessorInformationEx(RelationProcessorCore, nullptr, &length);
Assert(result_first == FALSE);
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 == TRUE);
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;
}
Tenga en cuenta que la implementación de NumberOfPhysicalCores es IMHO lejos de trivial (es decir, "use GetLogicalProcessorInformation o GetLogicalProcessorInformationEx "). En cambio, es bastante sutil si uno lee la documentación (explícitamente presente para GetLogicalProcessorInformation e implícitamente presente para GetLogicalProcessorInformationEx ) en MSDN.
El número de procesadores lógicos. (Utilizando 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);
}
Tenga en cuenta que ambos métodos se pueden convertir fácilmente a C / C ++ 98 / C ++ 03.
Alternativa de OS X: la solución descrita anteriormente basada en [[NSProcessInfo processInfo] processorCount] solo está disponible en OS X 10.5.0, de acuerdo con la documentación. Para versiones anteriores de OS X, use la función Carbon MPProcessors ().
Si eres un programador de Cocoa, no te asustes por el hecho de que esto es Carbon. Solo necesita agregar el marco de Carbon a su proyecto Xcode y MPProcessors () estará disponible.
En Linux, la mejor manera programática que yo sepa es usar
sysconf(_SC_NPROCESSORS_CONF)
o
sysconf(_SC_NPROCESSORS_ONLN)
Estos no son estándar, pero están en mi página de manual para Linux.
En Linux, puede descargar dmesg y filtrar las líneas donde ACPI inicializa las CPU, algo como:
dmesg | grep ''ACPI: Processor dmesg | grep ''ACPI: Processor ''
Otra posibilidad es usar dmidecode para filtrar la información del procesador.
En Linux, puede leer el archivo / proc / cpuinfo y contar los núcleos.
En Linux, puede que no sea seguro usar _SC_NPROCESSORS_ONLN ya que no es parte del estándar POSIX y el manual de sysconf dice mucho. Entonces, existe la posibilidad de que _SC_NPROCESSORS_ONLN no esté 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).
Un enfoque simple sería leer /proc/stat o /proc/cpuinfo y contarlos:
#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;
}
El mismo enfoque en shell usando grep:
grep -c ^processor /proc/cpuinfo
O
grep -c ^cpu /proc/stat # subtract 1 from the result
Esta funcionalidad es parte del estándar C ++ 11.
#include <thread>
unsigned int nthreads = std::thread::hardware_concurrency();
Para compiladores más antiguos, puede usar la biblioteca Boost.Thread .
#include <boost/thread.hpp>
unsigned int nthreads = boost::thread::hardware_concurrency();
En cualquier caso, hardware_concurrency() devuelve el número de subprocesos que el hardware es capaz de ejecutar de forma concurrente en función del número de núcleos de CPU y unidades de subprocesamiento.
Función (casi) independiente de la plataforma en c-code
#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
}
Más información sobre OS X: sysconf(_SC_NPROCESSORS_ONLN) está disponible solo en versiones> = 10.5, no en 10.4.
Una alternativa es el código BSD HW_AVAILCPU/sysctl() que está disponible en las versiones> = 10.2.
No relacionado con C ++, pero en Linux normalmente lo hago:
grep processor /proc/cpuinfo | wc -l
Práctico para lenguajes de scripting como bash / perl / python / ruby.
Para Win32:
Mientras que GetSystemInfo () obtiene el número de procesadores lógicos , use GetLogicalProcessorInformationEx para obtener el número de procesadores físicos .
Probablemente no podrás obtenerlo de una manera independiente de la plataforma. Windows obtiene número de procesadores.
Si tiene acceso en lenguaje ensamblador, puede usar la instrucción CPUID para obtener todo tipo de información sobre la CPU. Es portátil entre sistemas operativos, aunque necesitará usar información específica del fabricante para determinar cómo encontrar el número de núcleos. Aquí hay un documento que describe cómo hacerlo en chips Intel , y la página 11 de este describe la especificación de AMD.
Tenga en cuenta que "número de núcleos" puede no ser un número particularmente útil, puede que tenga que calificarlo un poco más. ¿Cómo desea contar las CPU de subprocesos múltiples, como Intel HT, IBM Power5 y Power6, y la más famosa, Sun Niagara / UltraSparc T1 y T2? O incluso más interesante, el MIPS 1004k con sus dos niveles de subprocesos de hardware (supervisor y nivel de usuario) ... Sin mencionar lo que sucede cuando se muda a sistemas compatibles con hipervisores donde el hardware puede tener decenas de CPU pero su sistema operativo en particular Solo ve unos pocos.
Lo mejor que puede esperar es indicar la cantidad de unidades de procesamiento lógicas que tiene en la partición de su sistema operativo local. Olvídate de ver la verdadera máquina a menos que seas un hipervisor. La única excepción a esta regla hoy en día está en el terreno x86, pero el fin de las máquinas no virtuales está llegando rápidamente ...
Una receta de Windows más: use la variable de entorno de todo el sistema NUMBER_OF_PROCESSORS :
printf("%d/n", atoi(getenv("NUMBER_OF_PROCESSORS")));
Vale la pena ver hwloc (http://www.open-mpi.org/projects/hwloc/). Aunque requiere otra integración de biblioteca en su código, pero puede proporcionar toda la información sobre su procesador (número de núcleos, topología, etc.)
Windows Server 2003 y versiones posteriores le permiten aprovechar la función GetLogicalProcessorInformation
también puede usar WMI en .net, pero luego depende del servicio wmi que se ejecuta, etc. A veces funciona de forma local, pero luego falla cuando se ejecuta el mismo código en los servidores. Creo que es un problema de espacio de nombres, relacionado con los "nombres" cuyos valores estás leyendo.
OpenMP es compatible con muchas plataformas (incluido Visual Studio 2005) y ofrece una
int omp_get_num_procs();
Función que devuelve el número de procesadores / núcleos disponibles en el momento de la llamada.