Come posso trovare a livello di codice la frequenza della CPU con C

Come posso trovare a livello di codice la frequenza della CPU con C

Per completezza, esiste già una soluzione in modalità utente semplice, veloce, precisa con un enorme inconveniente:funziona solo su processori Intel Skylake, Kabylake e più recenti. Il requisito esatto è il supporto 16h di livello CPUID. Secondo il manuale Intel Software Developer's 325462 versione 59, pagina 770:

  • CPUID.16h.EAX =Frequenza di base del processore (in MHz);

  • CPUID.16h.EBX =Frequenza massima (in MHz);

  • CPUID.16h.ECX =Frequenza bus (riferimento) (in MHz).

Codice di esempio di Visual Studio 2015:

#include <stdio.h>
#include <intrin.h>

int main(void) {
    int cpuInfo[4] = { 0, 0, 0, 0 };
    __cpuid(cpuInfo, 0);
    if (cpuInfo[0] >= 0x16) {
        __cpuid(cpuInfo, 0x16);

        //Example 1
        //Intel Core i7-6700K Skylake-H/S Family 6 model 94 (506E3)
        //cpuInfo[0] = 0x00000FA0; //= 4000 MHz
        //cpuInfo[1] = 0x00001068; //= 4200 MHz
        //cpuInfo[2] = 0x00000064; //=  100 MHz

        //Example 2
        //Intel Core m3-6Y30 Skylake-U/Y Family 6 model 78 (406E3)
        //cpuInfo[0] = 0x000005DC; //= 1500 MHz
        //cpuInfo[1] = 0x00000898; //= 2200 MHz
        //cpuInfo[2] = 0x00000064; //=  100 MHz

        //Example 3
        //Intel Core i5-7200 Kabylake-U/Y Family 6 model 142 (806E9)
        //cpuInfo[0] = 0x00000A8C; //= 2700 MHz
        //cpuInfo[1] = 0x00000C1C; //= 3100 MHz
        //cpuInfo[2] = 0x00000064; //=  100 MHz

        printf("EAX: 0x%08x EBX: 0x%08x ECX: %08x\r\n", cpuInfo[0], cpuInfo[1], cpuInfo[2]);
        printf("Processor Base Frequency:  %04d MHz\r\n", cpuInfo[0]);
        printf("Maximum Frequency:         %04d MHz\r\n", cpuInfo[1]);
        printf("Bus (Reference) Frequency: %04d MHz\r\n", cpuInfo[2]);
    } else {
        printf("CPUID level 16h unsupported\r\n");
    }
    return 0;
}

È possibile trovare una soluzione generale che ottenga correttamente la frequenza operativa per uno o più thread. Ciò non richiede privilegi di amministratore/root o accesso a registri specifici del modello. L'ho testato su Linux e Windows su processori Intel inclusi Nahalem, Ivy Bridge e Haswell con un socket fino a quattro socket (40 thread). Tutti i risultati deviano meno dello 0,5% dalle risposte corrette. Prima di mostrarti come fare, lascia che ti mostri i risultati (da GCC 4.9 e MSVC2013):

Linux:    E5-1620 (Ivy Bridge) @ 3.60GHz    
1 thread: 3.789, 4 threads: 3.689 GHz:  (3.8-3.789)/3.8 = 0.3%, 3.7-3.689)/3.7 = 0.3%

Windows:  E5-1620 (Ivy Bridge) @ 3.60GHz
1 thread: 3.792, 4 threads: 3.692 GHz: (3.8-3.789)/3.8 = 0.2%, (3.7-3.689)/3.7 = 0.2%

Linux:  4xE7-4850 (Nahalem) @ 2.00GHz
1 thread: 2.390, 40 threads: 2.125 GHz:, (2.4-2.390)/2.4 = 0.4%, (2.133-2.125)/2.133 = 0.4%

Linux:    i5-4250U (Haswell) CPU @ 1.30GHz
1 thread: within 0.5% of 2.6 GHz, 2 threads wthin 0.5% of 2.3 GHz

Windows: 2xE5-2667 v2 (Ivy Bridge) @ 3.3 GHz
1 thread: 4.000 GHz, 16 threads: 3.601 GHz: (4.0-4.0)/4.0 = 0.0%, (3.6-3.601)/3.6 = 0.0%

L'idea mi è venuta da questo link http://randomacii.wordpress.com/2013/08/06/defective-heat-sinks-causing-garbage-gaming/

Per fare questo devi prima fare quello che fai da 20 anni fa. Scrivi del codice con un ciclo in cui conosci la latenza e il tempo. Ecco cosa ho usato:

static int inline SpinALot(int spinCount)
{
    __m128 x = _mm_setzero_ps();
    for(int i=0; i<spinCount; i++) {
        x = _mm_add_ps(x,_mm_set1_ps(1.0f));
    }
    return _mm_cvt_ss2si(x);
}

Questo ha una dipendenza dal loop trasportato, quindi la CPU non può riordinarlo per ridurre la latenza. Occorrono sempre 3 cicli di clock per iterazione. Il sistema operativo non migrerà il thread su un altro core perché legheremo i thread.

Quindi esegui questa funzione su ciascun core fisico. L'ho fatto con OpenMP. I thread devono essere legati per questo. In Linux con GCC puoi usare export OMP_PROC_BIND=true per legare i thread e supponendo che tu abbia ncores il core fisico fa anche export OMP_NUM_THREADS=ncores . Se vuoi associare a livello di codice e trovare il numero di core fisici per i processori Intel, consulta questo numero-rilevamento-programmatico-di-core-processori-fisici-o-se-hyper-threading e thread-affinity-with-windows-msvc- e-openmp.

void sample_frequency(const int nsamples, const int n, float *max, int nthreads) {
    *max = 0;
    volatile int x = 0;
    double min_time = DBL_MAX;
    #pragma omp parallel reduction(+:x) num_threads(nthreads)
    {
        double dtime, min_time_private = DBL_MAX;
        for(int i=0; i<nsamples; i++) {
             #pragma omp barrier
             dtime = omp_get_wtime();
             x += SpinALot(n);
             dtime = omp_get_wtime() - dtime;
             if(dtime<min_time_private) min_time_private = dtime;
        }
        #pragma omp critical
        {
            if(min_time_private<min_time) min_time = min_time_private;
        }
    }
    *max = 3.0f*n/min_time*1E-9f;
}

Infine, esegui il campionatore in un ciclo e stampa i risultati

int main(void) {
    int ncores = getNumCores();
    printf("num_threads %d, num_cores %d\n", omp_get_max_threads(), ncores);       
    while(1) {
        float max1, median1, max2, median2;
        sample_frequency(1000, 1000000, &max2, &median2, ncores);
        sample_frequency(1000, 1000000, &max1, &median1,1);          
        printf("1 thread: %.3f, %d threads: %.3f GHz\n" ,max1, ncores, max2);
    }
}

Non l'ho testato su processori AMD. Penso che i processori AMD con moduli (ad es. Bulldozer) dovranno collegarsi a ciascun modulo e non a ogni "core" AMD. Questo può essere fatto con export GOMP_CPU_AFFINITY con GCC. Puoi trovare un esempio funzionante completo su https://bitbucket.org/zboson/frequency che funziona su Windows e Linux su processori Intel e troverà correttamente il numero di core fisici per i processori Intel (almeno da Nahalem) e li collegherà a ogni core fisico (senza usare OMP_PROC_BIND che MSVC non ha).

Questo metodo deve essere leggermente modificato per i processori moderni a causa del diverso ridimensionamento della frequenza per SSE, AVX e AVX512.

Ecco una nuova tabella che ottengo dopo aver modificato il mio metodo (vedi il codice dopo la tabella) con quattro processori Xeon 6142 (16 core per processore).

        sums  1-thread  64-threads
SSE        1       3.7         3.3
SSE        8       3.7         3.3
AVX        1       3.7         3.3
AVX        2       3.7         3.3
AVX        4       3.6         2.9
AVX        8       3.6         2.9
AVX512     1       3.6         2.9
AVX512     2       3.6         2.9
AVX512     4       3.5         2.2
AVX512     8       3.5         2.2

Questi numeri concordano con le frequenze in questa tabellahttps://en.wikichip.org/wiki/intel/xeon_gold/6142#Frequencies

La cosa interessante è che ora devo fare almeno 4 somme parallele per ottenere le frequenze più basse. La latenza per addps su Skylake è di 4 cicli di clock. Questi possono andare a due porte (con le porte AVX512 0 e 1 fusibile da contare e una porta AVX512 e le altre operazioni AVX512 vanno alla porta 5).

Ecco come ho fatto otto somme parallele.

static int inline SpinALot(int spinCount) {
  __m512 x1 = _mm512_set1_ps(1.0);
  __m512 x2 = _mm512_set1_ps(2.0);
  __m512 x3 = _mm512_set1_ps(3.0);
  __m512 x4 = _mm512_set1_ps(4.0);
  __m512 x5 = _mm512_set1_ps(5.0);
  __m512 x6 = _mm512_set1_ps(6.0);
  __m512 x7 = _mm512_set1_ps(7.0);
  __m512 x8 = _mm512_set1_ps(8.0);
  __m512 one = _mm512_set1_ps(1.0);
  for(int i=0; i<spinCount; i++) {
    x1 = _mm512_add_ps(x1,one);
    x2 = _mm512_add_ps(x2,one);
    x3 = _mm512_add_ps(x3,one);
    x4 = _mm512_add_ps(x4,one);
    x5 = _mm512_add_ps(x5,one);
    x6 = _mm512_add_ps(x6,one);
    x7 = _mm512_add_ps(x7,one);
    x8 = _mm512_add_ps(x8,one);
  }
  __m512 t1 = _mm512_add_ps(x1,x2);
  __m512 t2 = _mm512_add_ps(x3,x4);
  __m512 t3 = _mm512_add_ps(x5,x6);
  __m512 t4 = _mm512_add_ps(x7,x8);
  __m512 t6 = _mm512_add_ps(t1,t2);
  __m512 t7 = _mm512_add_ps(t3,t4);
  __m512  x = _mm512_add_ps(t6,t7);
  return _mm_cvt_ss2si(_mm512_castps512_ps128(x));
}

Il modo in cui trovi la frequenza della CPU dipende sia dall'architettura CHE dal sistema operativo e non esiste una soluzione astratta.

Se fossimo più di 20 anni fa e stavi utilizzando un sistema operativo senza cambio di contesto e la CPU eseguisse le istruzioni fornite nell'ordine, potresti scrivere del codice C in un ciclo e cronometrarlo, quindi in base all'assembly in cui è stato compilato calcolare il numero di istruzioni in fase di esecuzione. Questo presuppone già che ogni istruzione richieda 1 ciclo di clock, il che è un presupposto piuttosto scarso sin dai tempi dei processori pipeline.

Ma qualsiasi sistema operativo moderno passerà da un processo all'altro. Anche allora puoi provare a cronometrare un sacco di for identici viene eseguito il ciclo (ignorando il tempo necessario per gli errori di pagina e molti altri motivi per cui il processore potrebbe bloccarsi) e ottenere un valore mediano.

E anche se la soluzione precedente funziona, hai processori con più problemi. Con qualsiasi processore moderno, è un gioco leale riordinare le istruzioni, emetterne un po' nello stesso ciclo di clock o persino dividerle su più core.