Comment puis-je trouver par programmation la fréquence du processeur avec C

J'essaie de savoir si il est de toute façon pour avoir une idée de la fréquence du PROCESSEUR du système mon code C est en cours d'exécution sur.

De préciser, je suis à la recherche d'une solution abstraite, (qui ne sera pas lié à une architecture spécifique ou OS) qui peut me donner une idée de la fréquence de fonctionnement de l'ordinateur que mon code est en cours d'exécution sur. Je n'ai pas besoin d'être exact, mais je voudrais être dans le ballon parc (ie. J'ai un processeur 2,2 GHz, je voudrais être en mesure de dire dans mon programme que je suis dans un délai de quelques centaines de MHz)

Quelqu'un a une idée de l'utilisation standard de code C?

source d'informationauteur Mike | 2012-07-29

  1. 6

    Comment vous trouvez la fréquence du PROCESSEUR est à la fois l'architecture ET de l'OS à charge, et il n'y a pas de solution abstraite.

    Si nous étions plus de 20 ans et ont été à l'aide d'un OS avec pas de changement de contexte et la CPU exécuté les instructions données dans l'ordre, vous pouvez écrire du code C dans une boucle et l'heure, puis, en fonction de l'assemblée il a été compilé en calculer le nombre d'instructions lors de l'exécution. C'est déjà faire l'hypothèse que chaque instruction prend 1 cycle d'horloge, ce qui est plutôt une mauvaise hypothèse depuis pipeline processeurs.

    Mais tout système d'exploitation moderne vous permettra de basculer entre plusieurs processus. Même alors, vous pouvez tenter de fois qu'un tas de identique for boucle s'exécute (sans tenir compte du temps nécessaire pour les défauts de page et de multiples autres raisons pour lesquelles votre processeur de décrochage) et d'obtenir une valeur médiane.

    Et même si la solution précédente ne fonctionne, vous avez multi-problème de processeurs. Avec n'importe quel processeur moderne, c'est le jeu juste à changer l'ordre de vos instructions, numéro un tas d'entre eux dans le même cycle d'horloge, ou même de les diviser entre les cœurs.

  2. 9

    Il est possible de trouver une solution générale qui obtient la fréquence de fonctionnement correctement pour un fil ou plusieurs fils. Cela n'a pas besoin d'admin/root, soit l'accès à un modèle spécifique registres. J'ai testé sur Linux et Windows sur des processeurs Intel, y compris, Nahalem, Ivy Bridge et Haswell avec un socket jusqu'à quatre sockets (40 sujets). Les résultats de tous s'écartent de moins de 0,5% de réponses correctes. Avant que je vous montre comment faire cela, laissez-moi vous montrer les résultats (à partir de GCC 4.9 et 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%

    J'ai eu l'idée de ce à partir de ce lien
    http://randomascii.wordpress.com/2013/08/06/defective-heat-sinks-causing-garbage-gaming/

    Pour ce faire, vous vous faites d'abord ce que vous faites depuis 20 ans. Vous écrire un peu de code avec une boucle où vous savez que le temps de latence et le temps. Voici ce que j'ai utilisé:

    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);
}

    Cela a un boucle de dépendance si le CPU ne peut pas réorganiser pour réduire le temps de latence. Il prend toujours 3 cycles d'horloge par itération. Le système d'exploitation ne migrent pas le thread à un autre cœur parce que nous allons lier les fils.

    Ensuite, vous exécutez cette fonction sur chaque noyau physique. Je l'ai fait avec OpenMP. Le filetage doit être lié à cela. Sous linux avec GCC, vous pouvez utiliser export OMP_PROC_BIND=true pour lier les fils et en supposant que vous avez ncores physique core faire aussi export OMP_NUM_THREADS=ncores. Si vous souhaitez par programme de lier et de trouver le nombre de cœurs physiques pour les processeurs Intel voir ce par programmation-détecter-nombre-de-physique-processeurs-carottes-ou-si-hyper-threading et fil-affinity-avec-windows-msvc-et-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;
}

    Enfin exécuter l'échantillonneur dans une boucle et d'imprimer les résultats

    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);
    }
}

    Je n'ai pas testé sur des processeurs AMD. Je pense que les processeurs AMD avec les modules d'e.g Bulldozer) auront à se lier à chaque module et non pas de chaque AMD "de base". Cela pourrait être fait avec export GOMP_CPU_AFFINITY avec GCC. Vous pouvez trouver plein d'exemple à https://bitbucket.org/zboson/frequency qui fonctionne sur Windows et Linux sur processeurs Intel et correctement trouver le nombre de cœurs physiques pour les processeurs Intel (au moins depuis Nahalem) et les lie à chaque physiques de base (sans l'aide de OMP_PROC_BIND qui MSVC n'a pas).

  3. 7

    Par souci d'exhaustivité, il y a déjà une solution simple, rapide, précise, en mode utilisateur de la solution avec un énorme inconvénient: il fonctionne sur Intel Skylake, Kabylake et les nouveaux processeurs. L'exigence exacte est le CPUID niveau de 16h soutien. Selon Intel Software developer's Manual 325462 libération 59, page 770:

    • CPUID.16h.EAX = Processeur de Base de la Fréquence (en MHz);

    • CPUID.16h.EBX = Maximum de la Fréquence (en MHz);

    • CPUID.16h.ECX = Bus (de Référence) de la Fréquence (en MHz).

    Visual Studio 2015 exemple de code:

    #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;
}
  4. 2

    La fréquence du CPU est un matériel de chose, donc il n'y a pas de méthode générale que vous pouvez appliquer pour l'obtenir, il dépendra aussi de l'OS que vous utilisez.

    Par exemple, si vous utilisez Linux, vous pouvez lire le fichier /proc/cpuinfo ou vous pouvez analyser les dmesg journal de démarrage pour obtenir cette valeur, ou si vous voulez, vous pouvez voir comment le noyau linux de gérer ce genre de choses ici et essayer de personnaliser le code pour répondre à votre besoin :

    https://github.com/torvalds/linux/blob/master/arch/x86/kernel/cpu/proc.c

    Ce qui concerne.

  5. 0

    J'imagine une façon pour obtenir la fréquence de l'horloge à partir d'un logiciel est par le codage en dur des connaissances en Matériel Manuel de Référence(GRH) dans le logiciel. Vous pouvez lire l'horloge des registres de configuration du logiciel. En supposant que vous savez la source de la fréquence de l'horloge, le logiciel peut utiliser le multiplicateur et diviseur valeurs de l'horloge des registres et d'appliquer des formules appropriées comme indiqué dans la GRH pour dériver la fréquence de l'horloge.