Détecter actuelle du PROCESSEUR, Vitesse d'Horloge par programme sur OS X?

Je viens d'acheter une chouette MBA 13" Core i7. Je me suis dit que la vitesse du CPU varie automatiquement, et assez sauvagement, trop. Je voudrais vraiment être en mesure de surveiller avec une simple application.

Y a du Cacao ou du C des appels à la vitesse de l'horloge, sans affecter réellement?

Edit: je suis d'accord avec les réponses données à l'aide de Terminal appels, ainsi que la programmation.

Merci!

N'étant pas particulièrement familier avec osx, mais ne serait-il pas être un répertoire /proc type de système de fichier avec cette information? par exemple, sur Linux c'est /proc/cpuinfo
Il n'y a pas /proc/ aussi loin que je peux dire. Il y a un system_profiler de commande qui donne la vitesse du PROCESSEUR figurant sur la boîte, mais il ne change pas avec le live de la mise à jour de la vitesse d'horloge
Voir cette question pourquoi c'est extrêmement difficile à faire.
De la lecture à travers maintenant. Si elle permet à tous, je ne se soucient pas de tricheurs - depuis que je ne vais pas essayer de tricher avec moi-même. C'est plus une curiosité de l'outil.
Mystique, je suis sur le point de mettre un bounty sur cette question. Encore une fois, je n'ai pas besoin de tricher-preuve - je voulez juste regarder le TurboBoost coup de pied dans (peut-être écrire une application pour jouer cette vidéo chaque fois qu'il le fait)

OriginalL'auteur Tim | 2012-03-30

  1. 12

    Essayer cet outil appelé "Intel Power Gadget". Il affiche IA fréquence et IA puissance en temps réel.

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

    C'est vraiment exactement ce que je voulais. Il inclut même échantillon objective-c... Parfait!
    +1: très utile!

    OriginalL'auteur Yevgeni

  2. 11

    Vous pouvez interroger la vitesse du CPU facilement via sysctl, soit en ligne de commande:

    sysctl hw.cpufrequency

    Ou via 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;
}
    Malheureusement, il semble que ce retour de la "zone annoncé le" speed (maintenant 2.3 ghz sur mon MBPR), mais pas le SpeedStep vitesse.
    Cependant, c'est un outil utile et facile aperçu de l'utilisation de la variable sysctl, donc je vous en remercie!
    Ne donne pas de courant, mais la vitesse annoncée. hw.cpufrequency, hw.cpufrequency_min, hw.cpufrequency_max donnent tous le même.
    Ce code permet de dépassement de la Hz sur la nouvelle génération d' > 4Ghz processeurs. Besoin de l'utiliser. sysctlbyname("hw.cpufrequency_max", &vitesse, &len, NULL, 0); à l'appui d'une valeur de 64 bits pour la fréquence.
    hmm sysctl hw.cpufrequency toujours des rapports 2500000000 pour moi. L'Intel Power Gadgetreports différentes "IA" valeurs de 1.3 Ghz à 3.4 GHz, demandez-vous si il existe un moyen d'obtenir plus de place pour les valeurs de date...

    OriginalL'auteur DarkDust

  3. 6

    Puisque c'est un processeur Intel, vous pouvez toujours utiliser RDTSC. C'est une instruction assembleur qui renvoie le cycle actuel de contre — 64 bits compteur qui s'incrémente à chaque cycle. Ce serait un peu approximatifs, mais par exemple

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

    Sortie Horloges par seconde: 2002120630 sur mon processeur à 2 ghz MacBook Pro.

    Sur mon MBA, il montre à 1,8 ghz, ce qui est tout à fait exact, mais est-il un moyen de forcer le i7 en turbo boost?
    rdtsc n'est pas un moyen fiable de mesurer un processeur vitesse d'horloge. Il ne permet pas de régler lui-même le turbo-boost/PROCESSEUR d'accélération (entre autres choses).
    au contraire, il est généralement conseillé comme étant peu fiable façon de mesurer un CPU vitesse d'horloge fait il est affecté par turbo boost et la limitation des processeurs.
    Mes tests suggère que d'autres sages. Sur mon Xeon stock 3.2 GHz rdtsc dit toujours 3.2 GHz, indépendamment de ce que j'ai mis le multiplicateur de (2.4, 2.6, 2.8, 3.0, 3.2 GHz... tous signalés comme 3.2 GHz par rdtsc) rdtsc semble changer seulement quand vous commencez à jouer avec la vitesse du bus.
    Est-il un moyen de déterminer ce que le multiplicateur est? Je suis intéressé par les deux sachant que speedstep tire du CPU au ralenti et où TurboBoost met le CPU est en charge.

    OriginalL'auteur Tommy

  4. 0

    Il y a un noyau de vulgarisation écrits par des "flocons" qui ouvre le processeur p-état de la journalisation du noyau.
    http://www.insanelymac.com/forum/index.php?showtopic=258612

    peut-être vous pourriez le contacter pour le code.

    OriginalL'auteur nurbs999

  5. 0

    Cela semble fonctionner correctement sur OSX.
    Toutefois, il ne fonctionne pas sur Linux, où sysctl est obsolète et KERN_CLOCKRATE est pas défini.

    #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);
    L'exécution de sysctl kern.clockrate à la ligne de commande me donne un équilibre kern.clockrate: { hz = 100, tick = 10000, tickadj = 2, profhz = 100, stathz = 100 } où le PROCESSEUR Intel profiler montre des valeurs, donc je ne pense pas que cela fonctionne avec le speedstep ajustements.

    OriginalL'auteur tbh