macos - para - Detectar la velocidad actual del reloj de la CPU programáticamente en OS X?

turbo boost macbook air 2018

Question

Acabo de comprar un ingenioso MBA 13 "Core i7. Me han dicho que la velocidad de la CPU varía automáticamente, y bastante a la ligera. También me gustaría poder monitorear esto con una aplicación simple.

¿Hay alguna llamada de Cocoa o C para encontrar la velocidad actual del reloj, sin afectarla realmente?

Edición: estoy bien con respuestas usando llamadas de Terminal, así como programáticas.

¡Gracias!

Answer 1

Esto parece funcionar correctamente en OSX. Sin embargo, no funciona en Linux, donde sysctl está en desuso y KERN_CLOCKRATE no está definido.

#include <sys/sysctl.h>
#include <sys/time.h>
int mib[2];
size_t len;
mib[0] = CTL_KERN;
mib[1] = KERN_CLOCKRATE;
struct clockinfo clockinfo;
len = sizeof(clockinfo);
int result = sysctl(mib, 2, &clockinfo, &len, NULL, 0);
assert(result != -1);
log_trace("clockinfo.hz: %d/n", clockinfo.hz);
log_trace("clockinfo.tick: %d/n", clockinfo.tick);

Answer 2

Hay una extensión del kernel escrita por "flAked" que registra el estado de la CPU en el registro del kernel. http://www.insanelymac.com/forum/index.php?showtopic=258612

Tal vez podrías contactarlo para el código.

Answer 3

Pruebe esta herramienta llamada "Intel Power Gadget". Muestra la frecuencia IA y la potencia IA en tiempo real.

http://software.intel.com/sites/default/files/article/184535/intel-power-gadget-2.zip

Answer 4

Puede consultar la velocidad de la CPU fácilmente a través de sysctl , ya sea por línea de comandos:

sysctl hw.cpufrequency

O a través de C:

#include <stdio.h>
#include <sys/types.h>
#include <sys/sysctl.h>
int main() {
int mib[2];
unsigned int freq;
size_t len;
mib[0] = CTL_HW;
mib[1] = HW_CPU_FREQ;
len = sizeof(freq);
sysctl(mib, 2, &freq, &len, NULL, 0);
printf("%u/n", freq);
return 0;
}

Answer 5

Ya que es un procesador Intel, siempre puedes usar RDTSC. Esa es una instrucción de ensamblador que devuelve el contador del ciclo actual, un contador de 64 bits que se incrementa en cada ciclo. Sería un poco aproximado pero por ejemplo

#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
uint64_t rdtsc(void)
{
uint32_t ret0[2];
__asm__ __volatile__("rdtsc" : "=a"(ret0[0]), "=d"(ret0[1]));
return ((uint64_t)ret0[1] << 32) | ret0[0];
}
int main(int argc, const char * argv[])
{
uint64_t startCount = rdtsc();
sleep(1);
uint64_t endCount = rdtsc();
printf("Clocks per second: %llu", endCount - startCount);
return 0;
}

Salida ''Relojes por segundo: 2002120630'' en mi MacBook Pro de 2GHz.