Averiguar la frecuencia de reloj de la CPU (por núcleo, por procesador)

Una de las formas más simples de hacerlo es usando RDTSC, pero viendo que esto es para mecanismos anti-trampas, lo pondría como un controlador del núcleo o una pieza de código residente de hyper-visor.

Es probable que también tenga que rodar su propio código de tiempo**, que de nuevo se puede hacer con RDTSC (QPC como se utiliza en el ejemplo a continuación utiliza RDTSC, y es de hecho muy simple de ingeniería inversa y utilizar una copia local de, lo que significa que para manipular con él, controlador).

void GetProcessorSpeed()
{
    CPUInfo* pInfo = this;
    LARGE_INTEGER qwWait, qwStart, qwCurrent;
    QueryPerformanceCounter(&qwStart);
    QueryPerformanceFrequency(&qwWait);
    qwWait.QuadPart >>= 5;
    unsigned __int64 Start = __rdtsc();
    do
    {
        QueryPerformanceCounter(&qwCurrent);
    }while(qwCurrent.QuadPart - qwStart.QuadPart < qwWait.QuadPart);
    pInfo->dCPUSpeedMHz = ((__rdtsc() - Start) << 5) / 1000000.0;
}

** Yo esto sería por seguridad como @Mystical mencionó, pero como nunca he sentido la necesidad de subvertir los mecanismos de sincronización del sistema de bajo nivel, podría haber más involucrados, sería bueno si Mystical pudiera agregar algo sobre eso:)

He publicado anteriormente sobre este tema (junto con un algoritmo básico): aquí. Que yo sepa, el algoritmo (ver la discusión) es muy preciso. Por ejemplo, Windows 7 reporta mi reloj de CPU como 2.00 GHz, CPU-Z como 1994-1996 MHz y mi algoritmo como 1995025-1995075 kHz.

El algoritmo realiza muchos bucles para hacer esto, lo que hace que la frecuencia de la CPU aumente al máximo (como también lo hará durante los puntos de referencia), por lo que el software de aceleración de velocidad no entrará en jugar.

Información Adicional aquí y aquí.

Sobre la cuestión de la aceleración de la velocidad realmente no lo veo como un problema a menos que una aplicación utilice los valores de velocidad para determinar los tiempos transcurridos y que los tiempos en sí son extremadamente importantes. Por ejemplo, si una división requiere x ciclos de reloj para completar, no importa si la CPU se ejecuta a 3 GHz o 300 MHz: todavía necesitará x ciclos de reloj y la única diferencia es que completará la división en una décima parte del tiempo a @ 3 GHz.

Me doy cuenta de que esto ya ha sido contestado. También me doy cuenta de que esto es básicamente un arte negro, así que por favor tómelo o déjelo, u ofrezca comentarios.

En una búsqueda para encontrar la velocidad de reloj en hosts HyperV (gracias microsft,hp y dell) (contador de perf no confiable) e invitados HyperV (solo pueden obtener velocidad de CPU de stock, no actual), he logrado, a través de error de prueba y fluke, crear un bucle que se repite exactamente una vez por reloj.

Code as follows-C # 5.0, SharpDev, 32bit, Target 3.5, Optimizar en (crucial), no debuger activo (crucial)

        long frequency, start, stop;
        double multiplier = 1000 * 1000 * 1000;//nano
        if (Win32.QueryPerformanceFrequency(out frequency) == false)
            throw new Win32Exception();

        Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
        const int gigahertz= 1000*1000*1000;
        const int known_instructions_per_loop = 1; 

        int iterations = int.MaxValue;
        int g = 0;

        Win32.QueryPerformanceCounter(out start);
        for( i = 0; i < iterations; i++)
        {
            g++;
            g++;
            g++;
            g++;
        }
        Win32.QueryPerformanceCounter(out stop);

        //normal ticks differs from the WMI data, i.e 3125, when WMI 3201, and CPUZ 3199
        var normal_ticks_per_second = frequency * 1000;
        var ticks = (double)(stop - start);
        var time = (ticks * multiplier) /frequency;
        var loops_per_sec = iterations / (time/multiplier);
        var instructions_per_loop = normal_ticks_per_second  / loops_per_sec;

        var ratio = (instructions_per_loop / known_instructions_per_loop);
        var actual_freq = normal_ticks_per_second / ratio;

        Console.WriteLine( String.Format("Perf counhter freq: {0:n}", normal_ticks_per_second));
        Console.WriteLine( String.Format("Loops per sec:      {0:n}", loops_per_sec));
        Console.WriteLine( String.Format("Perf counter freq div loops per sec: {0:n}", instructions_per_loop));
        Console.WriteLine( String.Format("Presumed freq: {0:n}", actual_freq));
        Console.WriteLine( String.Format("ratio: {0:n}", ratio));

Notas

• 25 instrucciones por bucle si el depurador está activo
• Considere ejecutar un bucle de 2 o 3 segundos antes de la mano para activar el procesador (o al menos intentar activar, sabiendo cuán fuertemente los servidores están limitados en estos días)
• Probado en un Core2 de 64 bits y Haswell Pentium y comparado con CPU-Z

Uno debe consultar este documento técnico: Tecnología Intel® Turbo Boost en Procesadores basados en Microarquitectura Intel® Coretm (Nehalem) . Básicamente, producir varias lecturas del contador de rendimiento fijo UCC durante un período de muestra T.

Relative.Freq = Delta(UCC)  / T

Where:
   Delta() = UCC @ period T
                 - UCC @ period T-1

A partir de la arquitectura Nehalem, UCC aumenta y disminuye el número de clics relativamente al estado sin interrupción del núcleo.

Cuando se activan SpeedStep o Turbo Boost, la frecuencia estimada usando UCC será medido en consecuencia; mientras que TSC permanece constante. Por ejemplo, Turbo Boost en acción revela que Delta(UCC) es mayor o igual a Delta (TSC)

Ejemplo en function Core_Cyclefunction at Cyring | CoreFreq GitHub.

Necesita usar CallNtPowerInformation. Aquí hay un ejemplo de código del proyecto putil. Con esto puede obtener la frecuencia de CPU actual y máxima. Por lo que sé no es posible obtener la frecuencia por CPU.