IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage C++ Discussion :

[Débat] Optimiser la vérification de parité d'un nombre


Sujet :

Langage C++

  1. #21
    Membre chevronné Avatar de Astraya
    Homme Profil pro
    Consommateur de café
    Inscrit en
    Mai 2007
    Messages
    1 042
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Consommateur de café
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Mai 2007
    Messages : 1 042
    Points : 2 232
    Points
    2 232
    Par défaut
    Pour les processeurs récents Intel à un document très complet:

    https://www.intel.com/content/www/us...on-manual.html

    On en revient à une optimisation qui est principalement, aligner la mémoire et limiter le cache-miss. Pour ce qui est du couts des instructions ils discutent aussi des SIMD.
    Heureusement que aujourd'hui on ne s’occupe plus des mêmes choses que au temps de la PS2 Mais certains choses reste toujours présente comme le calcule d'une division qui "internement" parlant sera plus long qu'une multiplication, pipeliné ou pas.
    D'ailleurs dans le document d'Intel je t'invite a jeter un rapide coup d'oeil à 11.12 DIVIDE AND SQUARE ROOT OPERATIONS
    In Intel microarchitectures prior to Skylake, the SSE divide and square root instructions DIVPS and SQRTPS have a latency of 14 cycles (or the neighborhood) and they are not pipelined. This means that the throughput of these instructions is one in every 14 cyclese
    puis
    In microarchitectures that provide DIVPS/SQRTPS with high latency and low throughput, it is possible to speed up single-precision divide and square root calculations using the (V)RSQRTPS and (V)RCPPS instructions. For example, with 128-bit RCPPS/RSQRTPS at 5-cycle latency and 1-cycle throughput or with 256-bit implementation of these instructions at 7-cycle latency and 2-cycle throughput, a single Newton-Raphson iteration or Taylor approximation can achieve almost the same precision as the (V)DIVPS and (V)SQRTPS instructions.
    Homer J. Simpson


  2. #22
    Expert éminent sénior
    Avatar de Kannagi
    Homme Profil pro
    cyber-paléontologue
    Inscrit en
    Mai 2010
    Messages
    3 215
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : cyber-paléontologue

    Informations forums :
    Inscription : Mai 2010
    Messages : 3 215
    Points : 10 140
    Points
    10 140
    Par défaut
    Cela a toujours était (même sur Ps2) que la division est plus lente en 'interne' que la multiplication ou le ET , mais la pipeline permet heureusement que cette instruction a le coût équivalent a un cycle , la simple division est pipeliné donc peut être optimisé et avoir le même coût que la multiplication et le ET.

    Pour les deux instructions elles sont dans des cas spécial faut avoué , avoir 4 division en même temps a fournir c'est pas commode :p
    Pour SQRTPS 4 racine carré en même temps a 14 cycle cela reste intéressant (même si je ne suis jamais tombé sur un tel cas ! ).
    Limite je comprend qu'il a du mal a les pipeliné ^^

    Après je n'ai pas tout regardé (600 pages) et je programme quasiment jamais en assembleur sur un intel

  3. #23
    Membre chevronné Avatar de Astraya
    Homme Profil pro
    Consommateur de café
    Inscrit en
    Mai 2007
    Messages
    1 042
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Consommateur de café
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Mai 2007
    Messages : 1 042
    Points : 2 232
    Points
    2 232
    Par défaut
    Citation Envoyé par Kannagi Voir le message
    Cela a toujours était (même sur Ps2) que la division est plus lente en 'interne' que la multiplication ou le ET , mais la pipeline permet heureusement que cette instruction a le coût équivalent a un cycle , la simple division est pipeliné donc peut être optimisé et avoir le même coût que la multiplication et le ET.
    Il y a plusieurs problème avec le fait de considérer que comme il peut être fait en un cycle il le sera.
    L'ensemble des informations doivent être dans le cache pour commencer, ensuite cela est très dépendant du type de processeur.
    Et même si tu arrives à la faire en 1 cycle, tu aurais pu avancer d'autre instruction plutôt que de tout bloquer dans le pipeline pour 1 div, c'est pour cela que aujourd'hui cela ne veut plus trop rien dire de réfléchir en cycle. Le principale de l'optimisation étant la limitation du cache miss pour permettre ce que tu dis. Mais même avec ça, ton jeu d'instruction aura un bottleneck.

    Citation Envoyé par Kannagi Voir le message
    Pour les deux instructions elles sont dans des cas spécial faut avoué , avoir 4 division en même temps a fournir c'est pas commode :p
    Pour SQRTPS 4 racine carré en même temps a 14 cycle cela reste intéressant (même si je ne suis jamais tombé sur un tel cas ! ).
    Limite je comprend qu'il a du mal a les pipeliné ^^
    La normalisation d'un vecteur 4, d'un quaternion, la division d'une matrice 4*4 ou 4*3. Ce qui est censé être fait quasiment tout le temps ( Au moins 1 fois après modification de l'un de ces éléments )
    Beaucoup de formule mathématique peuvent être améliorer en utilisant les SIMD SSE par exemple (_mm_div_ps pour Microsoft Specific --> DIVPS) Mais la encore on va limiter sont utilisations car comme on le vois dans la documentation d'Intel une tel division prend 14 cycles!! Ce qui est énorme si on compte le nombre de fois ou l'on doit le faire par frame et le nombre de frame par seconde par exemple
    Mais la on digresse à mort sur le sujet de base je crois :p

    Citation Envoyé par Kannagi Voir le message
    Après je n'ai pas tout regardé (600 pages) et je programme quasiment jamais en assembleur sur un intel
    Appendix C Instruction Latency and throughput
    Homer J. Simpson


  4. #24
    Membre émérite
    Avatar de prgasp77
    Homme Profil pro
    Ingénieur en systèmes embarqués
    Inscrit en
    Juin 2004
    Messages
    1 306
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Eure (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur en systèmes embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Juin 2004
    Messages : 1 306
    Points : 2 466
    Points
    2 466
    Par défaut
    Citation Envoyé par Astraya Voir le message
    Changer un * en / et % en & n'est pas en soit un optimisation mais une règle de codage qui permets d'inclure l'optimisation sans avoir à y penser.
    Si sur un projet spécifique, sur un matériel spécifique, quelqu'un a passé du temps en amont pour se convaincre, PoC à l'appui, que celà avait un impact positif mesurable, je suis parfaitement d'accord avec ça ; c'est même ce qu'on attend de bon developpeurs.
    Mais, encore une fois mon message est : conseiller à un débutant de remplacer systématiquement un %2 == 0 par un &1 ou dire que dans tous les cas c'est positif, là je suis contre.

    Si vous pouviez comprendre cette distinction que je fais, peut-être pourrions nous tomber d'accord.
    -- Yankel Scialom

  5. #25
    Expert éminent sénior
    Avatar de Kannagi
    Homme Profil pro
    cyber-paléontologue
    Inscrit en
    Mai 2010
    Messages
    3 215
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : cyber-paléontologue

    Informations forums :
    Inscription : Mai 2010
    Messages : 3 215
    Points : 10 140
    Points
    10 140
    Par défaut
    Partons en HS alors

    Citation Envoyé par Astraya Voir le message
    Et même si tu arrives à la faire en 1 cycle, tu aurais pu avancer d'autre instruction plutôt que de tout bloquer dans le pipeline pour 1 div, c'est pour cela que aujourd'hui cela ne veut plus trop rien dire de réfléchir en cycle. Le principale de l'optimisation étant la limitation du cache miss pour permettre ce que tu dis. Mais même avec ça, ton jeu d'instruction aura un bottleneck.
    Je ne suis pas vraiment d'accord , je serait étonné que le DIV pose encore souci sur des processeurs modernes (tant en terme de cycle que de profondeur de la pipeline).
    Mais oui sur certain processeur actuel (comme AVR-atmel il faut mieux éviter).

    Citation Envoyé par Astraya Voir le message
    La normalisation d'un vecteur 4, d'un quaternion, la division d'une matrice 4*4 ou 4*3. Ce qui est censé être fait quasiment tout le temps ( Au moins 1 fois après modification de l'un de ces éléments )
    Beaucoup de formule mathématique peuvent être améliorer en utilisant les SIMD SSE par exemple (_mm_div_ps pour Microsoft Specific --> DIVPS) Mais la encore on va limiter sont utilisations car comme on le vois dans la documentation d'Intel une tel division prend 14 cycles!! Ce qui est énorme si on compte le nombre de fois ou l'on doit le faire par frame et le nombre de frame par seconde par exemple
    Avis tout t'as fait personnel les instruction SIMD même si fort utile la plupart sont aussi pour des soucis de compatibilité.
    Si tu parle de jeux vidéo , il est clair qu'on prefere faire tout les calculs coté GPU (les consoles sont même pensé pour ce cas de figures de mon point de vue) pour moi "l'abandon" du processeur CELL de Sony pour la PS4 (malgré que en terme de calcul matriciel un processeur CELL est plus performant que un intel même récent en terme de GFLOPS) de je que j'ai pu lire le CPU CELL , c'est en gros comme la PS2 avec 8 co processeur mathématique capable de faire des div , des muladd en un cycle etc sa puissancde de calcul était d’alléger une partie du GPU des calcul mathématique , mais malgré cela il n'a pas était vraiment plus incroyable que la concurrence (mais Sony aime bien les techno exotique).
    Bref pour dire qu'un GPU est massivement parallèle et sur ce coté la en terme de calcul mathématique est plus intéressant.
    Je n'ai pas de preuve sur ce sujet (dans le sens une doc des instruction GPU ) mais les GPU me semble pas avoir des instructions SIMD , leur force se trouve sur leur nombre important de calcul en parallèle et je pense que l'avenir sera de ce coté la (sinon intel aurait mis depuis le temps un muladd donc 4 multiplication + 4 addition en une seule instruction).

    Pour le compilateur je reste sceptique , si tu considère le compilateur mauvais faudrait mieux que tu code en asm alors :p
    (Parce que s'il arrive pas a optimiser les div ou autre , j'imagine pas le reste ).

    PS: 14 cycle je trouve cela peu mais peut être que j'ai l'habitude de ce genre d’instruction longue, sur des vieux proc comme le M68000 (qui équipait la Mega drive , la Neo Geo et la plupart des ordi et borne d'arcade de l'époque) , les instructions coûtait entre 4 et 12 cycle en moyenne , et il fallait faire un jeu avec 8 ou 12 MHZ !

  6. #26
    Membre chevronné Avatar de Astraya
    Homme Profil pro
    Consommateur de café
    Inscrit en
    Mai 2007
    Messages
    1 042
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Consommateur de café
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Mai 2007
    Messages : 1 042
    Points : 2 232
    Points
    2 232
    Par défaut
    Citation Envoyé par prgasp77 Voir le message
    Si sur un projet spécifique, sur un matériel spécifique, quelqu'un a passé du temps en amont pour se convaincre, PoC à l'appui, que celà avait un impact positif mesurable, je suis parfaitement d'accord avec ça ; c'est même ce qu'on attend de bon developpeurs.
    Mais, encore une fois mon message est : conseiller à un débutant de remplacer systématiquement un %2 == 0 par un &1 ou dire que dans tous les cas c'est positif, là je suis contre.

    Si vous pouviez comprendre cette distinction que je fais, peut-être pourrions nous tomber d'accord.
    Alors je vais être plus explicite :

    1- Si tu veux tester si un entier non signé est pair, fait X&1
    2- Si tu veux connaitre le reste d'une division, fait X%Y
    3- Si tu veux connaitre le reste d'une division avec un dividende qui est une puissance de 2, fait X & (Y - 1) (Y est la puissance de 2)
    3- Si tu veux faire une division par autre chose que une puissance de 2, fait X/Y
    4- Si tu veux faire une division par une puissance de 2, fait X>>log2(puissance) ( log2 étant pas calculer au Runtime sinon pas d’intérêt, donc en 32 bits c'est 0]log2]32 et 64 bits 0]log2]64 )

    Tout ceci est énormément utiliser dans les softwares tel Unreal, Unity, 3dsMax, Blender... Également vu dans les APIs fortement multi thread comme les lock-free, qui vont bénéficier de ces "Boosts" en , par exemple, n'allouant que des buffers de taille 'power of 2'.

    Alors oui pour un étudiant, il n'y comprendra rien. Mais ce qui me fait vraiment peur sur developpez.com c'est de voir que des gens que l'on pourrais penser expérimenté professionnellement ne savent pas ça, et reste dans leur carcan.

    Je suis sur que ce code-ci en fera bouillir plus d'un:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
    PtrType* IfAThenAElseB(PtrType* A, PtrType* B)
    {
        const intptr intptrA = reinterpret_cast<intptr>(A);
        const intptr intptrB = reinterpret_cast<intptr>(B);
        const intptr Mask = -(!intptrA); // Mask which all bit is set if intptrA is zero or all bit unset if intptrA is not zero
        return reinterpret_cast<PtrType*>(intptrA | (Mask & intptrB));
    }
    ou ça:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
    PtrType* IfAThenBElseC(PtrTypeTest A, PtrType* B, PtrType* C)
    {
        const intptr intptrB = reinterpret_cast<intptr>(B);
        const intptr intptrC = reinterpret_cast<intptr>(C);
        const intptr Mask = -(!intptr(A));// Mask which all bit is set if A is zero or all bit unset if A is not zero
        return reinterpret_cast<PtrType*>((intptrB & ~Mask) | (intptrC & Mask));
    }
    Et pourtant ce sont toutes ces petites choses qui font que vous pouvez avoir du temps réel réaliste.
    Oh et ça passe sur tout les X86 et autres...

    Pour répondre à Kannagi:

    La PS4 et XBox One et futurs sont sur des X86. La raison est simple, avoir du CELL sur PS et PowerPC sur Xbox fait exploser le cout de développement si tu veux du multiplateformes et n'apportait pas vraiment grand chose sauf de la complexité.

    Ensuite, pour ce qui est du rendu sur le GPU le souci est exactement le même :
    https://devtalk.nvidia.com/default/t...lo-/?offset=10

    https://devtalk.nvidia.com/default/t...nteger-modulo/

    Un petit papier de NVidia également la dessus : http://docs.nvidia.com/cuda/pdf/CUDA...ices_Guide.pdf
    Ici la section 8.1.1
    Également un peu plus bas 8.1.4:
    Prefer faster, more specialized math functions over slower, more

    general ones when possible.
    Et je peux t'assurer que si il y a une diff sur les GPU alors ton CPU sera bien moins performants
    Homer J. Simpson


  7. #27
    Membre expert
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2011
    Messages
    739
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2011
    Messages : 739
    Points : 3 627
    Points
    3 627
    Par défaut
    Citation Envoyé par Astraya Voir le message
    Alors je vais être plus explicite :

    1- Si tu veux tester si un entier non signé est pair, fait X&1
    2- Si tu veux connaitre le reste d'une division, fait X%Y
    3- Si tu veux connaitre le reste d'une division avec un dividende qui est une puissance de 2, fait X & (Y - 1) (Y est la puissance de 2)
    3- Si tu veux faire une division par autre chose que une puissance de 2, fait X/Y
    4- Si tu veux faire une division par une puissance de 2, fait X>>log2(puissance) ( log2 étant pas calculer au Runtime sinon pas d’intérêt, donc en 32 bits c'est 0]log2]32 et 64 bits 0]log2]64 )
    Ce ne sont pas des choses qu'un débutant à besoin de savoir. Lui montrer des X & (Y - 1) va davantage le perturber qu'autre chose. Et avec des constantes, le compilateur sais très bien transformer en masque binaire et autres joyeusetés.

    Si on utilise ce genre d'optimisation sur des variables, alors on travaille implicitement/explicitement en puissance de 2 et je ne considère plus les formules comme une optimisation, mais comme une logique de continuation. Par contre utiliser des puissances de 2 à probablement un but d'optimisation. Le débutant gagnerait plus à faire des petites abstractions qu'il pourra optimiser par la suite.

    Citation Envoyé par Astraya Voir le message
    Alors oui pour un étudiant, il n'y comprendra rien. Mais ce qui me fait vraiment peur sur developpez.com c'est de voir que des gens que l'on pourrais penser expérimenté professionnellement ne savent pas ça, et reste dans leur carcan.

    Je suis sur que ce code-ci en fera bouillir plus d'un:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
    PtrType* IfAThenAElseB(PtrType* A, PtrType* B)
    {
        const intptr intptrA = reinterpret_cast<intptr>(A);
        const intptr intptrB = reinterpret_cast<intptr>(B);
        const intptr Mask = -(!intptrA); // Mask which all bit is set if intptrA is zero or all bit unset if intptrA is not zero
        return reinterpret_cast<PtrType*>(intptrA | (Mask & intptrB));
    }
    ou ça:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
    PtrType* IfAThenBElseC(PtrTypeTest A, PtrType* B, PtrType* C)
    {
        const intptr intptrB = reinterpret_cast<intptr>(B);
        const intptr intptrC = reinterpret_cast<intptr>(C);
        const intptr Mask = -(!intptr(A));// Mask which all bit is set if A is zero or all bit unset if A is not zero
        return reinterpret_cast<PtrType*>((intptrB & ~Mask) | (intptrC & Mask));
    }
    Et pourtant ce sont toutes ces petites choses qui font que vous pouvez avoir du temps réel réaliste.
    Oh et ça passe sur tout les X86 et autres...
    Cool, mais niveau lisibilité on pourra repasser. Et pas sûr que les versions "optimisées" le soit vraiment: https://godbolt.org/g/ZpAzo1

  8. #28
    Expert éminent sénior
    Avatar de Luc Hermitte
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2003
    Messages
    5 275
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Août 2003
    Messages : 5 275
    Points : 10 985
    Points
    10 985
    Par défaut
    Citation Envoyé par Astraya Voir le message
    Changer un * en / et % en & n'est pas en soit un optimisation mais une règle de codage qui permets d'inclure l'optimisation sans avoir à y penser.
    Quand j'ai commencé à bidouiller il y a plus de 20 ans, c'était vrai sur les PC de l'époque. Jouer avec les bits était plus efficace que des modulos, et je le faisais, comme probablement beaucoup.

    Seulement, cela fait un paquet de temps que les compilateurs savent reconnaitre certains patterns pour produire un code strictement identique avec une forme ou l'autre. Je me souviens de cas (exposées par James Kanze sur fclc++ avec Sun CC) où des multiplications se retrouvaient remplacées par additions et décalages, dans notre dos. A se demander quelle pertinence il y a à offusquer du code pour gagner une optim que le compilo produit déjà pour nous.

    Dans certains cas (en absence d'intrisincs et/ou de besoin de portabilité), je n'hésite pas à aller faire un tour sur http://graphics.stanford.edu/~seander/bithacks.html et autres archives similaires quand je cherche à éviter des boucles pour travailler sur des bits -- et je laisse une référence pour que les prochains sachent d'où vient le hack illisible. Mais j'avoue, je prends rarement le temps de faire des benchs sérieux pour vérifier si cela vaut toujours, le mot est important, le coup.

    Maintenant concernant "&1" VS "%2", la question est de savoir comment la notion de parité est comprise. Dans un monde où le développeur n'a qu'une formation scientifique ou une autre, mais non spécialisée, le "%2" devrait être plus parlant -- en gros le monde des SSII. Dans un monde d'informaticiens de formations, j'espère bien qu'ils sauront lire le "&1" et en connaitre les limitations -- non, je n'attends pas la même choses des scientifiques sur le %2. J'espère aussi qu'ils comprennent la notion de modulo! Dans tous les cas, godbolt nous le montre bien: c'est exactement le même code assembleur qui est généré (*). Reste-t-il des compilos trop exotiques pour avoir suffisamment de financement qui leur permettrait d'être capables de reconnaitre que "&1" et "%2" devraient aboutir au même code assembleur ? Bonne question. J'ai envie d'être idéaliste sur ce cas précis.

    NB: Concernant les ternaires VS if..return/break, j'avoue que je suis dans le doute. J'ai observé un assembleur produit différent. Et dans mes derniers tests, le saut conditionnel semblait l'emporter après mesures imparfaites, chose qui contredisait mon intuition.

    (*) godbolt n'est pas un site de bench. C'est un ensemble de compilos en ligne qui permettent aussi et surtout de voir l'assembleur généré avec divers compilos, en diverses versions, avec diverses options, pour diverses archis cibles.
    Blog|FAQ C++|FAQ fclc++|FAQ Comeau|FAQ C++lite|FAQ BS|Bons livres sur le C++
    Les MP ne sont pas une hotline. Je ne réponds à aucune question technique par le biais de ce média. Et de toutes façons, ma BAL sur dvpz est pleine...

  9. #29
    Expert éminent sénior

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 186
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 186
    Points : 17 126
    Points
    17 126
    Par défaut
    Citation Envoyé par Astraya Voir le message
    Alors je vais être plus explicite :
    1- Si tu veux tester si un entier non signé est pair, fait X&1
    2- Si tu veux connaitre le reste d'une division, fait X%Y
    3- Si tu veux connaitre le reste d'une division avec un dividende qui est une puissance de 2, fait X & (Y - 1) (Y est la puissance de 2)
    3- Si tu veux faire une division par autre chose que une puissance de 2, fait X/Y
    4- Si tu veux faire une division par une puissance de 2, fait X>>log2(puissance) ( log2 étant pas calculer au Runtime sinon pas d’intérêt, donc en 32 bits c'est 0]log2]32 et 64 bits 0]log2]64 )
    Personellement, je vois déjà plein de soucis:
    • Ces équivalences ne sont pas vraies pour les nombres négatifs. (le complément à deux n'est pas requis par la norme)
    • Ces avis ne s'appliquent qu'aux entiers.
    • le right shift >> est défini par l'implémentation, changer de compilateur peut changer sa signification.
      For unsigned a and for signed a with nonnegative values, the value of a >> b is the integer part of a/2b
      For negative a, the value of a >> b is implementation-defined (in most implementations, this performs arithmetic right shift, so that the result remains negative).
      cité de cppreference.com
    • Les contraintes sur les valeurs utilisables ne sont pas les mêmes (surtout pour le shift)
    • Et pour diviser par -4, faut-il écrire - (x >> 2) ou (-x) >> 2? Que fais précisément -x >> 2?
    Mes principes de bases du codeur qui veut pouvoir dormir:
    • Une variable de moins est une source d'erreur en moins.
    • Un pointeur de moins est une montagne d'erreurs en moins.
    • Un copier-coller, ça doit se justifier... Deux, c'est un de trop.
    • jamais signifie "sauf si j'ai passé trois jours à prouver que je peux".
    • La plus sotte des questions est celle qu'on ne pose pas.
    Pour faire des graphes, essayez yEd.
    le ter nel est le titre porté par un de mes personnages de jeu de rôle

  10. #30
    Expert éminent sénior
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 612
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 612
    Points : 30 611
    Points
    30 611
    Par défaut
    Dites les gars!

    Je ne suis peut-être plus modérateur, soit.

    Mais vous ne pensez pas que vous commencer à digresser un peu beaucoup, surtout que nous sommes dans la section "débuter"

    Typiquement, dans cette section, la priorité est de fournir quelque chose qui fonctionne, et non quelque chose qui est rapide.

    On se fout pas mal de ce qui sera le plus rapide sur une architecture quelconque, on veut d'abord et avant tout que cela fonctionne!

    @Astraya: tu as fait tes expériences, grand bien te fasse. Et si, un jour, j'ai besoin de profiter de ces expériences pour résoudre un problème de performances, ne t'en fais pas, je ferai appel à toi en priorité.

    Mais dans le cas présent, on se fout pas mal que x%2 prenne 8 cycles alors que x&1 n'en prend que 4. Ce que l'on veut -- d'abord et avant tout -- c'est que le PO (qui doit se sentir bien perdu dans toute cette discussion) puisse résoudre le problème de débutant auquel il est confronté.

    Je vous serais très reconnaissant de recentrer un tout petit peu la discussion sur les problèmes réels de notre ami
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  11. #31
    Rédacteur/Modérateur


    Homme Profil pro
    Network game programmer
    Inscrit en
    Juin 2010
    Messages
    7 113
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : Juin 2010
    Messages : 7 113
    Points : 32 958
    Points
    32 958
    Billets dans le blog
    4
    Par défaut
    Meci Koala, j'ai découpé la discussion.

    Il faut remettre les choses dans l'ordre
    - Astraya a posé des hypothèses et périmètre d'action qu'il convient de conserver : s'il s'agit d'un nombre non signé pour tester la parité (pair ou impair, donc divisible par 2)
    > partant de là, les "et si on veut tester la divisibilité par 3 ?" ou "et s'il s'agit d'un chiffre négatif ?" sont au mieux non avenus
    > ces autres tests ont d'autres astuces, ou au pire on utilisera la version classique du modulo

    - Que le compilateur sache l'optimiser avec les bonnes options est bien
    > que ce simple calcul puisse être optimisé indépendemment des options est un plus non négligeable
    > lancer une appli (en l'occurence on parle d'un jeu 3D temps réel) en debug est toujours lent, ces petites aides sont très bénéfiques à l'ensemble de l'équipe
    >> quand je veux debugger du réseau, que j'utilise la config debug, si l'affichage ou toute autre partie est moins lente c'est appréciable
    >> pour atteindre les 30, 60 ou 120 fps tant vénérées par les joueurs, ce genre d'astuce est importante, surtout dans des éléments clés comme le rendu et engine
    >> la lisibilité est quasi secondaire face aux performances, c'est pas un code touché par des rigolos ou débutants

    - Dans le monde des consoles, gcc n'existe pas, chaque constructeur a son compilo et son implémentation
    > implémentations privées et dont on ne trouve que très peu voire aucune information sur le net, en dehors des sites de support du constructeur (très grosse NDA pour les utiliser)
    Pensez à consulter la FAQ ou les cours et tutoriels de la section C++.
    Un peu de programmation réseau ?
    Aucune aide via MP ne sera dispensée. Merci d'utiliser les forums prévus à cet effet.

  12. #32
    Expert éminent sénior

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 186
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 186
    Points : 17 126
    Points
    17 126
    Par défaut
    Mes premiers commentaires avaient justement trait au fait qu'on était sur une question d'un débutant.

    Dans le cadre d'un programme hyper optimisé, pour une cible précise, et par un compilateur précis, la question est toute autre.
    Et la réponse qui me paraît adaptée est "ce qui est indiqué par des mesures honnètes".
    Mes principes de bases du codeur qui veut pouvoir dormir:
    • Une variable de moins est une source d'erreur en moins.
    • Un pointeur de moins est une montagne d'erreurs en moins.
    • Un copier-coller, ça doit se justifier... Deux, c'est un de trop.
    • jamais signifie "sauf si j'ai passé trois jours à prouver que je peux".
    • La plus sotte des questions est celle qu'on ne pose pas.
    Pour faire des graphes, essayez yEd.
    le ter nel est le titre porté par un de mes personnages de jeu de rôle

  13. #33
    Expert éminent sénior
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2005
    Messages
    27 369
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2005
    Messages : 27 369
    Points : 41 518
    Points
    41 518
    Par défaut
    En parlant de mesures honnêtes, cette histoire de bit-hacks m'a rappelé ce post:
    The wrong way of benchmarking the most efficient integer comparison function
    En gros, ces bit-hacks gênent l'optimiseur plus qu'autre chose.

    Tu veux ton &1 et tu es à trois cycles près ? Alors déclare ton entier en unsigned et laisse le compilo remplacer %2 par &1, car au moins dans ce cas il continuera à optimiser.
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

Discussions similaires

  1. Réponses: 18
    Dernier message: 18/08/2017, 20h48
  2. Comment déterminer la parité d'un nombre
    Par DelphiCool dans le forum Codes sources à télécharger
    Réponses: 10
    Dernier message: 08/02/2013, 18h07
  3. [XL-2007] Optimiser une vérification
    Par Loki83 dans le forum Macros et VBA Excel
    Réponses: 2
    Dernier message: 18/08/2010, 18h59
  4. [Débat] Optimisation, utilisation de sgbd ?
    Par Targan dans le forum Optimisations
    Réponses: 4
    Dernier message: 14/02/2008, 15h33
  5. optimiser vérification de doublons
    Par julien.63 dans le forum SQL Procédural
    Réponses: 3
    Dernier message: 12/10/2007, 12h49

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo