Ce n' __asm__ __volatile__ faire en C?

J'ai regardé dans du code C à partir de

http://www.mcs.anl.gov/~kazutomo/rdtsc.html

Ils utilisent des trucs comme "inline", "asm" etc comme suit:

code1:

static __inline__ tick gettick (void) {
    unsigned a, d;
    __asm__ __volatile__("rdtsc": "=a" (a), "=d" (d) );
    return (((tick)a) | (((tick)d) << 32));
}

code2:

volatile int  __attribute__((noinline)) foo2 (int a0, int a1) {
    __asm__ __volatile__ ("");
}

Je me demandais quel est le code1 code2 et faire?

InformationsquelleAutor user3692521 | 2014-10-19
  1. 55

    La __volatile__ modificateur sur un __asm__ empêcher les forces du compilateur optimiseur pour exécuter le code en tant que-est. Sans elle, l'optimiseur peut penser qu'il peut être supprimé purement et simplement, ou de sortir d'une boucle et mis en cache.

    C'est utile pour l' rdtsc instruction comme suit:

    __asm__ __volatile__("rdtsc": "=a" (a), "=d" (d) )

    Cela ne prend pas de dépendances, de sorte que le compilateur pourrait supposer que la valeur peut être mis en cache. Volatile est utilisé afin de le forcer à lire un frais d'horodatage.

    Lorsqu'il est utilisé seul, comme ceci:

    __asm__ __volatile__ ("")

    Il ne sera pas réellement exécuter quoi que ce soit. Vous pouvez étendre ce système, cependant, à obtenir au moment de la compilation barrière de mémoire qui ne permettent pas à la réorganisation de la mémoire de l'accès instructions:

    __asm__ __volatile__ ("":::"memory")

    La rdtsc instruction est un bon exemple pour les volatiles. rdtsc est généralement utilisé lorsque vous avez besoin de temps combien de temps certaines instructions pour exécuter. Imaginez un code comme celui-ci, où vous voulez le temps r1 et r2s'exécution:

    __asm__ ("rdtsc": "=a" (a0), "=d" (d0) )
r1 = x1 + y1;
__asm__ ("rdtsc": "=a" (a1), "=d" (d1) )
r2 = x2 + y2;
__asm__ ("rdtsc": "=a" (a2), "=d" (d2) )

    Ici, le compilateur est effectivement permis de mettre en cache le timestamp, et valide la sortie pourrait montrer que chaque ligne a pris exactement 0 horloges à exécuter. Évidemment, ce n'est pas ce que vous voulez, donc vous présenter __volatile__ à empêcher la mise en cache:

    __asm__ __volatile__("rdtsc": "=a" (a0), "=d" (d0))
r1 = x1 + y1;
__asm__ __volatile__("rdtsc": "=a" (a1), "=d" (d1))
r2 = x2 + y2;
__asm__ __volatile__("rdtsc": "=a" (a2), "=d" (d2))

    Maintenant, vous obtiendrez un nouveau timestamp à chaque fois, mais il a encore un problème que le compilateur et le PROCESSEUR sont autorisés à réorganiser l'ensemble de ces déclarations. Il pourrait finir par l'exécution de l'asm blocs après r1 et r2 ont déjà été calculés. Pour contourner ce problème, vous devez ajouter quelques obstacles que la force de la sérialisation:

    __asm__ __volatile__("mfence;rdtsc": "=a" (a0), "=d" (d0) :: "memory")
r1 = x1 + y1;
__asm__ __volatile__("mfence;rdtsc": "=a" (a1), "=d" (d1) :: "memory")
r2 = x2 + y2;
__asm__ __volatile__("mfence;rdtsc": "=a" (a2), "=d" (d2) :: "memory")

    Note le mfence instruction ici, qui applique un PROCESSEUR côté de la barrière, et la "mémoire" spécificateur de la volatilité de l'édifice, qui applique au moment de la compilation de la barrière. Sur les Processeurs modernes, vous pouvez remplacer mfence:rdtsc avec rdtscp pour quelque chose de plus efficace.

    • donc, avec bloc vide, c'est une sorte d'instruction de la barrière?
    • Notez que le compilateur ne peut contrôler que le code statique afin qu'il génère, et éviter de déplacer des trucs passé cette barrière au moment de la compilation, mais il ne peut pas contrôler l'exécution réelle de l'ordre au sein de la CPU, qui peut la modifier (le CPU ne sais pas à propos de la volatilité de l'attribut, ou le vide d'un bloc de code). Avec rdtsc cela peut éventuellement provoquer des erreurs.
    • En effet, d'où l'expression "au moment de la compilation de la barrière".
    • +1, Enfin une réponse qui répond à la question.
    • J'ai eu des problèmes avec des clôtures et des tdr sur Haswells (i3, i5, i7 de différentes générations). Pas seulement de la clôture n'a pas de bon, mais il a ajouté plus d'inexactitude, si je me souviens bien rdtscp sur son propre avait +/- 4 tiques à partir de la moyenne et (divers) les clôtures seulement augmenté. La plupart des ressources en ligne sur elle l'air de s'arrêter sur les Pentium 4 ère, et apparemment, certaines choses ont changé.
    • Surtout, le code de la question suce juste. Il doit utiliser la __rdtsc intrinsèque. volatile est inutile dans asm volatile(""). Et votre explication de la volatilité n'est pas bon, avec asm("rdtsc":... le compilateur peut même réorganiser l'asm blocs (ou de les supprimer si a0 et d0 sont inutilisés), alors qu'avec volatile il a de les garder dans cet ordre, mais il peut encore bouger les ajouts et les magasins à travers.
    • Remarque: Bien que pas particulièrement liées, rdtsc devrait être évitée pour la surveillance de la performance depuis beaucoup de facteurs peuvent modifier le résultat.

    InformationsquelleAutor Cory Nelson
  2. 4

    asm est, y compris pour les natifs du code assembleur dans le code source C. E. g.

    int a = 2;
asm("mov a, 3");
printf("%i", a); //will print 3

    Compilateurs ont différentes variantes de celui-ci. __asm__ devrait être synonyme, peut-être avec quelques compilateur des différences spécifiques.

    volatile signifie que la variable peut être modifiée à partir de l'extérieur (aka pas par le programme C). Par exemple, lors de la programmation d'un microcontrôleur où l'adresse de la mémoire 0x0000x1234 est mappé à un périphérique spécifique de l'interface (c'est à dire lors du codage de la GameBoy, boutons/écran/etc sont accessibles de cette manière.)

    volatile std::uint8_t* const button1 = 0x00001111;

    Cette désactivé les optimisations du compilateur qui s'appuient sur *button1 ne pas changer, à moins d'être modifiée par le code.

    Il est également utilisé en multi-thread de programmation (pas plus nécessaire aujourd'hui?) lorsqu'une variable peut être modifiée par un autre thread.

    inline est une indication pour le compilateur "inline" appels à une fonction.

    inline int f(int a) {
    return a + 1
}

int a;
int b = f(a);

    Cela ne devrait pas être compilé dans un appel de fonction à f mais en int b = a + 1. Comme si f où une macro. La plupart des compilateurs faire cette optimisation automatiquement en fonction de la fonction d'usage/contenu. __inline__ dans cet exemple peut avoir un sens plus précis.

    De même __attribute__((noinline)) (GCC-syntaxe spécifique) empêche une fonction inline.

    • Thx!! Et quel est l'avantage de noinline?
    • Et ce qui ne l'assemblage de code dans code2 faire?
    • Je suppose que cela est tout à fait sûr que l'appel foo2 se traduit à un appel de fonction à un vide de fonction avec deux arguments entiers et renvoyant un entier, dans l'assemblée. Au lieu d'être optimisé à l'écart. Cette fonction peut être mise en œuvre dans le code assembleur généré.
    • comment sait-elle de retourner un entier(qui entier?) si la fonction est vide?
    • Il est défini comme une fonction retournant un int. Cela signifie que le code assembleur généré sera telle que l'appelant attend un int valeur de retour pour être sur certains inscrire (selon convention d'appel). Dans le code assembleur le corps de la fonction peut être modifiée pour faire que.
    • Je dirais volatile sur un asm bloc est un peu différente de la volatilité sur une variable. Bien que la commune themre reste, à savoir qu'il restreint les libertés de l'optimiseur.
    • "Il est également utilisé en multi-thread de programmation (pas plus nécessaire aujourd'hui?) lorsqu'une variable peut être modifiée par un autre thread." - s'il est bien utilisé c'est incorrect car il garantit seulement l'instruction de commande de accède pas l'atomicité de l'accès à la mémoire (mais aligné d'accès est atomique sur la plupart des architectures), de la mémoire des clôtures (à l'exception de la MSVC extension - qui est désactivé sur les BRAS). Pour une utilisation correcte, il est nécessaire d'utiliser le C(++)11 atomics ou le compilateur intrinsèques.

    InformationsquelleAutor tmlen
  3. -1

    La __asm__ attribut spécifie le nom à utiliser dans le code assembleur de la fonction ou variable.

    La __volatile__ qualificatif, généralement utilisé en Temps Réel-l'Informatique des systèmes embarqués, traite d'un problème avec le compilateur tests de la status register pour la ERROR ou READY peu de causer des problèmes lors de l'optimisation. __volatile__ a été présenté comme une façon de dire au compilateur que l'objet est soumis à une évolution rapide et à force de chaque référence de l'objet à une véritable référence.

    • Pas vraiment, c'est pour quoi que ce soit à des effets secondaires, vous n'avez pas / ne peut pas décrire avec des opérande contraintes, par exemple, lorsque vous le souhaitez tout de même se produire, même si tous les opérandes de sortie ne sont pas utilisées.
    • N'est-ce pas forcer chaque référence de l'objet à une véritable référence dit? La raison pour laquelle je suis un peu confus par la "pas vraiment", est la description a été prise presque mot à mot à partir de la documentation de référence comme il en existait dans Oct. 2014. Je vais voir si je peut creuser jusqu'à la cité.
    • J'ai surtout en désaccord avec le fait de dire qu'il est seulement approprié pour les CCF. Il n'est pas sur la "rapidité" de changement, tout ce qui peut avoir des effets secondaires. "Chaque référence une véritable référence" sonne comme une description de la volatile type de qualificatif (par exemple volatile int), pas GNU C asm volatile. Avec inline asm il n'y a pas "l'objet".
    • Gotcha, je suppose que ce serait mieux formulée à-dire volatile désactive l'optimisation de la jeter asm états s'ils décident, il n'est pas nécessaire pour les variables de sortie, de toute façon :)
    • Oui, plus certains prévention de re-commander, et plus si vous utilisez un "memory" tabasser pour en faire un compilateur de la barrière.
    InformationsquelleAutor David C. Rankin