Tu aurais peut être dû le faire toi-même, car j'ai tapé exactement ça sur google et le tout premier résultat c'est :Envoyé par newbie06
http://stackoverflow.com/questions/3...he-scenes-in-c
Surprise! There are no extra instructions at all on the normal code path. The compiler instead generated extra out-of-line fixup code blocks, referenced via a table at the end of the function (which is actually put on a separate section of the executable).
Quant aux compilos qui ralentissent le code quand les exceptions sont activées (en fait toutes les versions de VC++ qui target du 32bits sont concernées, alors que chez GCC ce n'est plus le cas depuis longtemps), j'ai trouvé un petit benchmark qui montre que le ralentissement n'est au maximum que de 1 à 2 % (pour un jeu vidéo tu perds 0.5 fps), tandis que certains codes sont même plus rapide lorsque les exceptions sont activées (oui c'est surprenant). Au final dans un gros programme ça pourrait presque s'annuler le code qui va plus lentement et le code qui va plus vite, mais là je m'avance un peu.
Alors la question qu'il faut te poser est : penses-tu que mettre un if après chaque appel de fonction ça ralentit moins que 1 à 2 % ? Je suis sûr que c'est beaucoup plus lent, en plus d'être ultra lourd à faire, de mettre des if partout plutôt que de rajouter une petite option au compilo.
Affichage des résultats 2 521 à 2 550 sur 10008
-
22/11/2012, 07h41 #2521Tyranaus0r
- Ville
- Che suis alßaßien
Dernière modification par Tomaka17 ; 22/11/2012 à 08h08.
Rust fanboy
-
22/11/2012, 10h59 #2522*X86 ADV*
- Ville
- Vence
Raaaaaaah à force d'insister, rOut et tomaka17, vous m'avez obligé à prendre 1h de temps pour regarder moi-même ce que faisait gcc. Hé ben, ça n'était pas du temps perdu, sur mes exemples simples les exceptions ne perturbent pas le chemin standard ; en revanche en cas d'exception, c'est l'horreur la plus totale.
Donc merci à vous deux d'avoir insisté
-
22/11/2012, 11h17 #2523Tyranaus0r
- Ville
- Che suis alßaßien
Le problème c'est qu'il y a des milliers de gens comme toi qui ont cette idée reçue que les exceptions c'est lent, ou bien qui pensent qu'elles ont tel ou tel désavantage parce qu'ils ne les utilisent pas correctement.
Mais c'est pas un reproche, car il y a énormément d'articles totalement obsolètes sur le net, et beaucoup de gens avec des méthodes de codage totalement obsolètes qui écrivent des articles ou qui sévissent sur des forums.
Par exemple si tu cherches sur le net tu trouveras plein d'articles sur "la STL c'est nul". La STL c'est l'ancêtre de la librairie standard, et ça n'existe même plus aujourd'hui. Sauf qu'à cause de ces articles, ben y a plein de monde non seulement qui croît que la librairie standard s'appelle la STL, mais en plus qui pense que c'est lent, mal foutu, etc.Rust fanboy
-
22/11/2012, 11h35 #2524*X86 ADV*
- Ville
- #10000, Baby.
Un lien rigolol pour voir ce que fait GCC et les autres compilos : http://gcc.godbolt.org/ Envoyé par newbie06
Raaaaaaah à force d'insister, rOut et tomaka17, vous m'avez obligé à prendre 1h de temps pour regarder moi-même ce que faisait gcc. Hé ben, ça n'était pas du temps perdu, sur mes exemples simples les exceptions ne perturbent pas le chemin standard ; en revanche en cas d'exception, c'est l'horreur la plus totale.
Donc merci à vous deux d'avoir insisté
Sinon un gus qui a fait la même recherche http://www.lazarenko.me/c-plus-plus-...-performance//
En cas d'exceptions, c'est certes plus lourd qu'un return, mais c'est pas non plus l'horreur totale, tout est masqué par __cxa_throw, __cxa_begin_catch et __cxa_end_catch (du moins chez GCC). Je ne sais pas si c'est quelque chose de normalisé sous Linux, mais GCC et Clang on l'air de respecter ça (je ne sais pas pour les autres compilos).
Bon, après l'implémentation de ces trois fonctions est assez dégueu, avec des promenades dans la stack, et le tout basé sur tout un tas de fonctionalités spécifiques à l'implémentation... Mais t'as des libs comme libunwind dédiées pour faire ça."Dieu est mort" · "Si le téléchargement c’est du vol, Linux c’est de la prostitution."
-
22/11/2012, 11h43 #2525*X86 ADV*
Oui, mais les exceptions et la bibliothèque standard, ça marche bien aussi parce que les compilateurs sont totalement à la rue sur les processeurs modernes (multi-core et extensions SIMD).
Si tu compares un code avec toutes les dernières fonctionnalités C++ à la mode avec un code en C de barbu des années 70, tu verras quasiment pas de différence en perf : les deux tourneront à 5% des perfs crêtes.
Quand on doit écrire du code performant, on code en C++, mais pas avec la bibliothèque standard. On va utiliser tout un tas d'autres bibliothèques plus ou moins propriétaires et plus ou moins platform-specific.
Et allez-donc me rajouter un "if(isnan(x)) throw Exception();" anodin dans une fonction interne des BLAS pour voir comment ça se vectorise bien…
Après, peut-être que je ne suis pas à jour non plus. La bibliothèque standard C++11 a-t-elle été revue pour que les opérations puissent être multi-threadées et vectorisées ?
-
22/11/2012, 11h44 #2526*X86 ADV*
- Ville
- #10000, Baby.
Bin je ne sais pas. Mais si tu as un exemple de code vectorisable tu peux faire l'essai là: http://gcc.godbolt.org/.
"Dieu est mort" · "Si le téléchargement c’est du vol, Linux c’est de la prostitution."
-
22/11/2012, 11h48 #2527*X86 ADV*
- Ville
- Vence
C'est énorme, y'a même icc ! Le top ça serait qu'on puisse comparer la sortie de deux compilos Envoyé par rOut
-
22/11/2012, 11h50 #2528*X86 ADV*
- Ville
- #10000, Baby.
Envoyé par newbie06
C'est énorme, y'a même icc ! Le top ça serait qu'on puisse comparer la sortie de deux compilos"Dieu est mort" · "Si le téléchargement c’est du vol, Linux c’est de la prostitution."
-
22/11/2012, 11h59 #2529Tyranaus0r
- Ville
- Che suis alßaßien
Y a rien en C++11 là dessus. C'est pas surprenant vu que ce genre de trucs ça doit être l'enfer à définir si on veut pas être platform-specific (en fait j'en sais rien mais j'imagine). Y a sûrement pas assez de recul sur tout ce qui est SIMD aussi.
Bon, niveau multithreading t'as std::async. En gros si tu veux faire X trucs en parallèle, tu fais (X-1) appels à std::async, et la dernière tâche dans le corps même de la fonction. Le compilo est ensuite censé déterminer automatiquement si std::async va créer un nouveau thread, ou bien prendre un thread d'un thread pool, ou bien ne pas être asynchrone du tout en fait.
C'est rien de très folichon, d'ailleurs ils ont prévu de rajouter plein plein plein de features relatives au multithreading dans les prochains TR.
---------- Post added at 11h59 ---------- Previous post was at 11h54 ----------
Par exemple :
Selon le compilo et selon l'implémentation, soit work2 est exécuté dans un thread différent (dont la provenance n'est pas spécifée par le standard), soit work2 n'est exécuté qu'au moment du "handle.get()" et donc dans le même thread.Code:int work1(int value); int work2(int value); int work(int value) { auto handle = std::async([=]{ return work2(value); }); int tmp = work1(value); return tmp + handle.get(); }
Evidemment si on le souhaite on peut préciser laquelle des deux solutions on désire en rajoutant un paramètre à std::async.
À noter qu'on aurait pu écrire aussi :
C'est peut être plus simple qu'une lambda.Code:auto handle = std::async(work2, value);
Rust fanboy
-
22/11/2012, 12h04 #2530*X86 ADV*
Code:#include <vector> #include <algorithm> // Type your code here, or load an example. void saxpy_c(float * __restrict__ x, float a, float * __restrict__ y, int n) { for(int i = 0; i != n; ++i) { x[i] = a * x[i] + y[i]; } } void saxpy_cpp(std::vector<float> & x, float a, std::vector<float> const & y, int n) { std::transform(x.begin(), x.end(), y.begin(), x.begin(), [&] (float x, float y) { return a * x + y; }); } int main() { return 0; }
Compiler output
Killed - processing time exceeded
Compilation failed
-
22/11/2012, 12h11 #2531*X86 ADV*
- Ville
- #10000, Baby.
C'est vectorisé ça ?
Code:saxpy_c(float*, float, float*, int): # @saxpy_c(float*, float, float*, int) testl %edx, %edx je .LBB0_2 .LBB0_1: # %.lr.ph movss (%rdi), %xmm1 mulss %xmm0, %xmm1 addss (%rsi), %xmm1 movss %xmm1, (%rdi) addq $4, %rsi addq $4, %rdi decl %edx jne .LBB0_1 .LBB0_2: # %._crit_edge ret main: # @main xorl %eax, %eax ret
"Dieu est mort" · "Si le téléchargement c’est du vol, Linux c’est de la prostitution."
-
22/11/2012, 12h15 #2532Tyranaus0r
- Ville
- Che suis alßaßien
Non, il fait du movss/mulss/addss (l'un des 's' veut dire 'single precision', c'est à dire juste un float) et fait une boucle où il décale à chaque fois rsi et rdi de 4 octets (la taille d'un float).
T'façons tu reconnais un code vectorisé à ses opcodes qui font la moitié de l'écran
EDIT : ah non je confonds avec les opérations sur les entiers qui font la moitié de l'écran
En fait dans "movss", le premier 's' veut dire 'scalar' (c'est à dire un seul nombre) et le deuxième 's' veut dire 'single precision' (c'est à dire float). Quand tu fais des trucs vectorisés c'est du mulps/addps/subps/etc. avec le 'p' qui veut dire 'packed'Rust fanboy
-
22/11/2012, 12h19 #2533*X86 ADV*
- Ville
- #10000, Baby.
Genre comme ça je suppose ? (Je comprends qu'il y a différents cas suivant l'alignement et le nombre de float restant et tout) :
Code:saxpy_c(float*, float, float*, int): leal 3(%rdx), %r11d testl %edx, %edx pushq %rbp cmovns %edx, %r11d pushq %rbx andl $-4, %r11d je .L1 movq %rdi, %rcx andl $15, %ecx shrq $2, %rcx negq %rcx andl $3, %ecx cmpl %ecx, %r11d cmovb %r11d, %ecx cmpl $4, %r11d cmovbe %r11d, %ecx testl %ecx, %ecx je .L12 xorl %eax, %eax .L5: movss (%rdi,%rax,4), %xmm1 leal 1(%rax), %r10d mulss %xmm0, %xmm1 addss (%rsi,%rax,4), %xmm1 movss %xmm1, (%rdi,%rax,4) addq $1, %rax cmpl %eax, %ecx ja .L5 cmpl %ecx, %r11d je .L1 .L4: movl %r11d, %ebp movl %ecx, %r8d subl %ecx, %ebp movl %ebp, %edx shrl $2, %edx leal 0(,%rdx,4), %ebx testl %ebx, %ebx je .L7 movaps %xmm0, %xmm1 salq $2, %r8 xorps %xmm3, %xmm3 leaq (%rdi,%r8), %r9 shufps $0, %xmm1, %xmm1 addq %rsi, %r8 xorl %eax, %eax xorl %ecx, %ecx movaps %xmm1, %xmm4 .L8: movaps (%r9,%rax), %xmm1 addl $1, %ecx movaps %xmm3, %xmm2 mulps %xmm4, %xmm1 movlps (%r8,%rax), %xmm2 movhps 8(%r8,%rax), %xmm2 addps %xmm2, %xmm1 movaps %xmm1, (%r9,%rax) addq $16, %rax cmpl %edx, %ecx jb .L8 addl %ebx, %r10d cmpl %ebx, %ebp je .L1 .L7: subl $1, %r11d movslq %r10d, %rcx subl %r10d, %r11d leaq 0(,%rcx,4), %rdx addq %r11, %rcx leaq 4(%rdi,%rcx,4), %rcx leaq (%rdi,%rdx), %rax addq %rsi, %rdx .L10: movss (%rax), %xmm1 mulss %xmm0, %xmm1 addss (%rdx), %xmm1 addq $4, %rdx movss %xmm1, (%rax) addq $4, %rax cmpq %rcx, %rax jne .L10 .L1: popq %rbx popq %rbp ret .L12: xorl %r10d, %r10d jmp .L4 main: xorl %eax, %eax ret
"Dieu est mort" · "Si le téléchargement c’est du vol, Linux c’est de la prostitution."
-
22/11/2012, 12h21 #2534Tyranaus0r
- Ville
- Che suis alßaßien
Ouai voilà, dans L4 et L8 quand t'as du movaps/movhps/addps/etc. c'est qu'il travaille par vecteurs.
Après je suis pas un spécialiste du sujet non plus.Rust fanboy
-
22/11/2012, 12h22 #2535*X86 ADV*
- Ville
- Vence
Avec gcc 4.7. Pour icc, je n'y suis pas arrivé, mais j'ai pas vraiment essayé non plus.
Code:saxpy_c(float*, float, float*, int): pushq %rbp testl %edx, %edx pushq %rbx je .L1 movq %rdi, %r8 andl $15, %r8d shrq $2, %r8 negq %r8 andl $3, %r8d cmpl %r8d, %edx cmovb %edx, %r8d cmpl $4, %edx cmovbe %edx, %r8d testl %r8d, %r8d je .L12 xorl %eax, %eax .L5: movss (%rdi,%rax,4), %xmm1 leal 1(%rax), %r11d mulss %xmm0, %xmm1 addss (%rsi,%rax,4), %xmm1 movss %xmm1, (%rdi,%rax,4) addq $1, %rax cmpl %eax, %r8d ja .L5 cmpl %r8d, %edx je .L1 .L4: movl %edx, %ebp movl %r8d, %r9d subl %r8d, %ebp movl %ebp, %ecx shrl $2, %ecx leal 0(,%rcx,4), %ebx testl %ebx, %ebx je .L7 salq $2, %r9 movaps %xmm0, %xmm1 xorl %eax, %eax leaq (%rdi,%r9), %r10 shufps $0, %xmm1, %xmm1 addq %rsi, %r9 movaps %xmm1, %xmm4 xorl %r8d, %r8d xorps %xmm3, %xmm3 .L8: movaps (%r10,%rax), %xmm1 movaps %xmm3, %xmm2 addl $1, %r8d movlps (%r9,%rax), %xmm2 mulps %xmm4, %xmm1 movhps 8(%r9,%rax), %xmm2 addps %xmm2, %xmm1 movaps %xmm1, (%r10,%rax) addq $16, %rax cmpl %ecx, %r8d jb .L8 addl %ebx, %r11d cmpl %ebx, %ebp je .L1 .L7: subl $1, %edx movslq %r11d, %r8 leaq 0(,%r8,4), %rcx subl %r11d, %edx leaq (%rdi,%rcx), %rax addq %rdx, %r8 addq %rsi, %rcx leaq 4(%rdi,%r8,4), %rdx .L10: movss (%rax), %xmm1 mulss %xmm0, %xmm1 addss (%rcx), %xmm1 addq $4, %rcx movss %xmm1, (%rax) addq $4, %rax cmpq %rdx, %rax jne .L10 .L1: popq %rbx popq %rbp ret .L12: xorl %r11d, %r11d jmp .L4 saxpy_cpp(std::vector<float, std::allocator<float> >&, float, std::vector<float, std::allocator<float> > const&, int): movq (%rdi), %rdx movq 8(%rdi), %r8 movq (%rsi), %rcx cmpq %r8, %rdx je .L32 leaq 4(%rdx), %rax movq %r8, %r10 pushq %rbx leaq 16(%rcx), %rsi subq %rax, %r10 leaq 16(%rdx), %rbx shrq $2, %r10 addq $1, %r10 movq %r10, %rdi shrq $2, %rdi cmpq $5, %r10 leaq 0(,%rdi,4), %r9 seta %r11b cmpq %rsi, %rdx setae %sil cmpq %rbx, %rcx setae %bl orl %ebx, %esi testb %sil, %r11b je .L23 testq %r9, %r9 je .L23 movaps %xmm0, %xmm1 xorl %eax, %eax xorl %esi, %esi shufps $0, %xmm1, %xmm1 movaps %xmm1, %xmm4 xorps %xmm3, %xmm3 .L24: movaps %xmm3, %xmm2 movaps %xmm3, %xmm1 addq $1, %rsi movlps (%rdx,%rax), %xmm2 movlps (%rcx,%rax), %xmm1 movhps 8(%rdx,%rax), %xmm2 movhps 8(%rcx,%rax), %xmm1 mulps %xmm4, %xmm2 addps %xmm2, %xmm1 movlps %xmm1, (%rdx,%rax) movhps %xmm1, 8(%rdx,%rax) addq $16, %rax cmpq %rsi, %rdi ja .L24 leaq 0(,%r9,4), %rax addq %rax, %rcx addq %rax, %rdx cmpq %r9, %r10 je .L21 leaq 4(%rdx), %rax .L23: subq %rax, %r8 xorl %eax, %eax shrq $2, %r8 leaq 4(,%r8,4), %rsi .L26: movss (%rdx,%rax), %xmm1 mulss %xmm0, %xmm1 addss (%rcx,%rax), %xmm1 movss %xmm1, (%rdx,%rax) addq $4, %rax cmpq %rsi, %rax jne .L26 .L21: popq %rbx .L32: rep ret main: xorl %eax, %eax ret
-
22/11/2012, 12h24 #2536Tyranaus0r
- Ville
- Che suis alßaßien
Mais comment vous sortez ces résultats là ? Des options pour le compilo ?
Parce que moi il me sort le premier résultat de rOut.Rust fanboy
-
22/11/2012, 12h29 #2537*X86 ADV*
- Ville
- #10000, Baby.
Il faut choisir le compilateur, par défaut je crois que c'est clang, qui ne vectorise pas.
Sinon apparemment il vectorise aussi la version avec std::transform.
Et pour ne pas perdre la vectorisation, tu peux faire :
Code:void saxpy_cpp(std::vector<float> & x, float const a, std::vector<float> const & y, int const n) { std::for_each(x.begin(), x.begin() + n, [] (float const x) { if(isnan(x)) throw std::exception(); }); std::for_each(y.begin(), y.begin() + n, [] (float const x) { if(isnan(x)) throw std::exception(); }); std::transform(x.begin(), x.begin() + n, y.begin(), x.begin(), [&] (float const x, float const y) { return a * x + y; }); }"Dieu est mort" · "Si le téléchargement c’est du vol, Linux c’est de la prostitution."
-
22/11/2012, 13h29 #2538Figure paternelle de substitution
Ouaiis, Rhoo le naze, exact, j'ai confondu avec valarray au temps pour moi, désolé les coincoins. Envoyé par alecool
---------- Post added at 13h29 ---------- Previous post was at 13h21 ----------
Que le traitement des exceptions soit beaucoup plus long qu'un simple test de code retour ne va gêner que les gens qui font de la programmation basée sur les exceptions, autrement dit qui vont utiliser les exceptions pour gérer des situations qui ne sont pas des erreurs.
C'est hyper rare (et hyper pourri, oui). Sinon effectivement, perdre 1/1000e de secondes avant d'afficher un message d'erreur, hé hé hé...
-
22/11/2012, 14h12 #2539Tyranaus0r
- Ville
- Che suis alßaßien
D'ailleurs pour moi t'es même pas censé utiliser les exceptions en cas d'erreur de la part de l'utilisateur.
J'imagine plutôt un code de ce genre :
Le try-catch est là "au cas où", mais ne devrait se déclencher qu'en cas d'erreur bizarre, du genre erreur d'écriture dans le fichier ou incohérence dans les données qui étaient pourtant cohérentes au moment de l'ouverture.Code:void callback(UI& ui) { // fonction appelée lorsque l'utilisateur clique sur un bouton if (!test_si_possible()) { ui.sendErrorMessage("Impossible de faire cette action"); return; } auto userInput = getUserInput(); if (!is_valid(userInput)) { ui.sendErrorMessage("Les données entrées sont invalides"); return; } try { faire_action(userInput); } catch(const std::exception&) { logException(std::current_exception()); ui.sendError("Erreur pendant l'action"); } }
Le fait que l'utilisateur essaye de faire quelque chose qu'il n'a pas le droit de faire ou rentre un input invalide n'est pour moi pas dans le cadre des exceptions.Rust fanboy
-
22/11/2012, 14h24 #2540*X86 ADV*
Ouais mais c'est shadok comme solution, autant ne pas vectoriser que de se taper le parcours du tableau 3 fois... Envoyé par rOut
Avec icc en -march=core-avx2 sur le code C:
Oh, un FMA et du déroulage de boucle.Code:..B2.12: # Preds ..B2.12 ..B2.11 vmovups (%rdi,%r9,4), %ymm2 #10.16 vmovups 32(%rdi,%r9,4), %ymm3 #10.16 vfmadd213ps (%rsi,%r9,4), %ymm1, %ymm2 #10.23 vfmadd213ps 32(%rsi,%r9,4), %ymm1, %ymm3 #10.23 vmovups %ymm2, (%rdi,%r9,4) #10.5 vmovups %ymm3, 32(%rdi,%r9,4) #10.5 addq $16, %r9 #8.3 cmpq %r8, %r9 #8.3 jb ..B2.12 # Prob 82% #8.3
C'est quoi l'option -march pour Xeon Phi ?Dernière modification par Møgluglu ; 22/11/2012 à 14h37.
-
22/11/2012, 14h45 #2541*X86 ADV*
- Ville
- #10000, Baby.
Bah ouais mais de toute manière c'est quoi l'autre solution sans exceptions ? Je veux dire, soit tu checkes que chaque valeur est OK, soit pas mais dans tous les cas ton check va difficilement se vectoriser non ?
Si tu veux être sûr que les valeurs sont toutes valides, tu vas devoir faire le check pour chaque valeur.
---------- Post added at 14h45 ---------- Previous post was at 14h40 ----------
T'as la même chose avec le code C++ et/ou gcc. Envoyé par Møgluglu
"Dieu est mort" · "Si le téléchargement c’est du vol, Linux c’est de la prostitution."
-
22/11/2012, 15h08 #2542*X86 ADV*
- Ville
- Vence
J'ai ri. Envoyé par Møgluglu
EDIT : Allez je vais être constructif même si Xeon Phi sapuduk : #pragma offload target(mic)
http://software.intel.com/en-us/arti...mpilerswitches
---------- Post added at 15h03 ---------- Previous post was at 14h55 ----------
Alors j'ai donc essayé le pragma et ça me sort des erreurs. Ca commence bien pour la facilité de portage à Xeon Phi kilétrobokilvatuerleGPU
---------- Post added at 15h08 ---------- Previous post was at 15h03 ----------
J'y suis arrivé. C'est laid et c'est pas vraiment du Phi
Code:L__routine_start_main_0: main: pushq %rbp #19.1 movq %rsp, %rbp #19.1 andq $-128, %rsp #19.1 subq $128, %rsp #19.1 pushq $3 #19.1 popq %rdi #19.1 call __intel_new_proc_init #19.1 stmxcsr (%rsp) #19.1 movl $.2.5_2_kmpc_loc_struct_pack.1, %edi #19.1 xorl %esi, %esi #19.1 orl $32832, (%rsp) #19.1 xorl %eax, %eax #19.1 ldmxcsr (%rsp) #19.1 call __kmpc_begin #19.1 movl $.2.5_2_kmpc_loc_struct_pack.12, %edi #20.10 xorl %eax, %eax #20.10 call __kmpc_end #20.10 xorl %eax, %eax #20.10 movq %rbp, %rsp #20.10 popq %rbp #20.10 ret #20.10 .2.5_2_kmpc_loc_struct_pack.1: .long 0 .long 2 .long 0 .long 0 .quad .2.5_2__kmpc_loc_pack.0 .byte 59 .byte 117 .byte 110 .byte 107 .byte 110 .byte 111 .byte 119 .byte 110 .byte 59 .byte 109 .byte 97 .byte 105 .byte 110 .byte 59 .byte 49 .byte 57 .byte 59 .byte 49 .byte 57 .byte 59 .byte 59 .2.5_2_kmpc_loc_struct_pack.12: .long 0 .long 2 .long 0 .long 0 .quad .2.5_2__kmpc_loc_pack.11 .byte 59 .byte 117 .byte 110 .byte 107 .byte 110 .byte 111 .byte 119 .byte 110 .byte 59 .byte 109 .byte 97 .byte 105 .byte 110 .byte 59 .byte 50 .byte 48 .byte 59 .byte 50 .byte 48 .byte 59 .byte 59 L__routine_start__Z7saxpy_cPffS_i_1: saxpy_c(float*, float, float*, int): subq $360, %rsp #9.1 xorl %ecx, %ecx #10.3 movq %rdi, 8(%rsp) #9.1 movl $2, %edi #10.3 movq %rsi, 336(%rsp) #9.1 movl $-1, %esi #10.3 movl %edx, 352(%rsp) #9.1 movl $1, %edx #10.3 movl $__sd_2inst_string.1, %r8d #10.3 movl $10, %r9d #10.3 xorl %eax, %eax #10.3 movss %xmm0, 344(%rsp) #9.1 call __offload_target_acquire #10.3 testq %rax, %rax #10.3 je ..B2.5 # Prob 50% #10.3 movl $256, %edx #10.3 lea 80(%rsp), %rdi #10.3 movq %rax, (%rsp) #10.3 lea .2.6_2__offload_var_desc1_p.47(%rip), %rsi #10.3 call _intel_fast_memcpy #10.3 movq (%rsp), %rax # lea 16(%rsp), %r9 #10.3 pushq $64 #10.3 popq %r10 #10.3 ..B2.33: # Preds ..B2.33 ..B2.35 movq -8+.2.6_2__offload_var_desc2_p.52(%r10), %rdx #10.3 movq -16+.2.6_2__offload_var_desc2_p.52(%r10), %rcx #10.3 movq -24+.2.6_2__offload_var_desc2_p.52(%r10), %rsi #10.3 movq -32+.2.6_2__offload_var_desc2_p.52(%r10), %r8 #10.3 movq %rdx, -8(%r9,%r10) #10.3 movq %rcx, -16(%r9,%r10) #10.3 movq %rsi, -24(%r9,%r10) #10.3 movq %r8, -32(%r9,%r10) #10.3 subq $32, %r10 #10.3 jne ..B2.33 # Prob 50% #10.3 movl $__sd_2inst_string.2, %esi #10.3 lea 80(%rsp), %r8 #10.3 movq %rax, %rdi #10.3 lea 8(%rsp), %r10 #10.3 movq %r10, 56(%r8) #10.3 lea 336(%rsp), %r11 #10.3 movq %r11, 200(%rsp) #10.3 lea 352(%rsp), %rdx #10.3 movq %rdx, 264(%rsp) #10.3 lea 344(%rsp), %rcx #10.3 movq %rcx, 328(%rsp) #10.3 xorl %r10d, %r10d #10.3 pushq %rsp #10.3 pushq %r10 #10.3 pushq %r10 #10.3 xorl %edx, %edx #10.3 pushq $4 #10.3 popq %rcx #10.3 xorl %eax, %eax #10.3 pushq %r10 #10.3 call __offload_offload #10.3 addq $32, %rsp #10.3 testl %eax, %eax #10.3 jne ..B2.26 # Prob 50% #10.3 ..B2.5: # Preds ..B2.2 ..B2.4 movslq 352(%rsp), %rcx #11.23 testq %rcx, %rcx #11.23 je ..B2.26 # Prob 10% #11.23 movq 8(%rsp), %rdi #13.16 cmpq $8, %rcx #11.3 movss 344(%rsp), %xmm0 #13.12 movq 336(%rsp), %rsi #13.23 jl ..B2.27 # Prob 10% #11.3 movq %rdi, %rdx #11.3 andq $15, %rdx #11.3 testl %edx, %edx #11.3 je ..B2.10 # Prob 50% #11.3 testb $3, %dl #11.3 jne ..B2.27 # Prob 10% #11.3 negl %edx #11.3 addl $16, %edx #11.3 shrl $2, %edx #11.3 ..B2.10: # Preds ..B2.9 ..B2.7 movl %edx, %eax #11.3 lea 8(%rax), %r8 #11.3 cmpq %r8, %rcx #11.3 jl ..B2.27 # Prob 10% #11.3 movl %ecx, %r9d #11.3 movl %r9d, %r8d #11.3 subl %edx, %r8d #11.3 andl $7, %r8d #11.3 subl %r8d, %r9d #11.3 xorl %r8d, %r8d #11.3 movslq %r9d, %r9 #11.3 testq %rax, %rax #11.3 jbe ..B2.15 # Prob 0% #11.3 ..B2.13: # Preds ..B2.11 ..B2.13 movss (%rdi,%r8,4), %xmm1 #13.16 mulss %xmm0, %xmm1 #13.16 addss (%rsi,%r8,4), %xmm1 #13.23 movss %xmm1, (%rdi,%r8,4) #13.5 incq %r8 #11.3 cmpq %rax, %r8 #11.3 jb ..B2.13 # Prob 82% #11.3 ..B2.15: # Preds ..B2.13 ..B2.11 movl %edx, %edx #13.23 lea (%rsi,%rdx,4), %r8 #13.23 testq $15, %r8 #11.3 je ..B2.19 # Prob 60% #11.3 movaps %xmm0, %xmm1 #11.3 shufps $0, %xmm1, %xmm1 #11.3 ..B2.17: # Preds ..B2.17 ..B2.16 movaps (%rdi,%rax,4), %xmm3 #13.16 movaps 16(%rdi,%rax,4), %xmm5 #13.16 mulps %xmm1, %xmm3 #13.16 mulps %xmm1, %xmm5 #13.16 movups (%rsi,%rax,4), %xmm2 #13.23 movups 16(%rsi,%rax,4), %xmm4 #13.23 addps %xmm2, %xmm3 #13.23 addps %xmm4, %xmm5 #13.23 movaps %xmm3, (%rdi,%rax,4) #13.5 movaps %xmm5, 16(%rdi,%rax,4) #13.5 addq $8, %rax #11.3 cmpq %r9, %rax #11.3 jb ..B2.17 # Prob 82% #11.3 jmp ..B2.22 # Prob 100% #11.3 ..B2.19: # Preds ..B2.15 movaps %xmm0, %xmm1 #11.3 shufps $0, %xmm1, %xmm1 #11.3 ..B2.20: # Preds ..B2.20 ..B2.19 movaps (%rdi,%rax,4), %xmm2 #13.16 movaps 16(%rdi,%rax,4), %xmm3 #13.16 mulps %xmm1, %xmm2 #13.16 mulps %xmm1, %xmm3 #13.16 addps (%rsi,%rax,4), %xmm2 #13.23 addps 16(%rsi,%rax,4), %xmm3 #13.23 movaps %xmm2, (%rdi,%rax,4) #13.5 movaps %xmm3, 16(%rdi,%rax,4) #13.5 addq $8, %rax #11.3 cmpq %r9, %rax #11.3 jb ..B2.20 # Prob 82% #11.3 ..B2.22: # Preds ..B2.20 ..B2.17 ..B2.27 cmpq %rcx, %r9 #11.3 jae ..B2.26 # Prob 0% #11.3 ..B2.24: # Preds ..B2.22 ..B2.24 movss (%rdi,%r9,4), %xmm1 #13.16 mulss %xmm0, %xmm1 #13.16 addss (%rsi,%r9,4), %xmm1 #13.23 movss %xmm1, (%rdi,%r9,4) #13.5 incq %r9 #11.3 cmpq %rcx, %r9 #11.3 jb ..B2.24 # Prob 82% #11.3 ..B2.26: # Preds ..B2.24 ..B2.4 ..B2.5 ..B2.22 addq $360, %rsp #15.1 ret #15.1 ..B2.27: # Preds ..B2.6 ..B2.10 ..B2.8 # Infreq xorl %r9d, %r9d #11.3 jmp ..B2.22 # Prob 100% #11.3 .2.6_2__offload_var_desc1_p.47: .byte 34 .byte 1 .byte 1 .byte 1 .long 4 .long 0 .long 0 .long 0x00000000,0x00000000 .long 0x00000004,0x00000000 .long 0x00000001,0x00000000 .long 0x00000000,0x00000000 .long 0x00000000,0x00000000 .long 0x00000000,0x00000000 .byte 34 .byte 3 .byte 1 .byte 1 .long 4 .long 0 .long 0 .long 0x00000000,0x00000000 .long 0x00000004,0x00000000 .long 0x00000001,0x00000000 .long 0x00000000,0x00000000 .long 0x00000000,0x00000000 .long 0x00000000,0x00000000 .byte 17 .byte 1 .byte 1 .byte 1 .long 8 .long 0 .long 0 .long 0x00000000,0x00000000 .long 0x00000004,0x00000000 .long 0x00000001,0x00000000 .long 0x00000000,0x00000000 .long 0x00000000,0x00000000 .long 0x00000000,0x00000000 .byte 17 .byte 1 .byte 1 .byte 1 .long 8 .long 0 .long 0 .long 0x00000000,0x00000000 .long 0x00000004,0x00000000 .long 0x00000001,0x00000000 .long 0x00000000,0x00000000 .long 0x00000000,0x00000000 .long 0x00000000,0x00000000 .2.6_2__offload_var_desc2_p.52: .quad __sd_2inst_string.3 .long 0x00000000,0x00000000 .quad __sd_2inst_string.4 .long 0x00000000,0x00000000 .quad __sd_2inst_string.5 .long 0x00000000,0x00000000 .quad __sd_2inst_string.6 .long 0x00000000,0x00000000 __sd_2inst_string.1: .byte 47 .byte 116 .byte 109 .byte 112 .byte 47 .byte 103 .byte 99 .byte 99 .byte 45 .byte 101 .byte 120 .byte 112 .byte 108 .byte 111 .byte 114 .byte 101 .byte 114 .byte 45 .byte 99 .byte 111 .byte 109 .byte 112 .byte 105 .byte 108 .byte 101 .byte 114 .byte 49 .byte 49 .byte 50 .byte 49 .byte 48 .byte 52 .byte 45 .byte 49 .byte 48 .byte 55 .byte 56 .byte 45 .byte 104 .byte 119 .byte 49 .byte 109 .byte 50 .byte 57 .byte 47 .byte 101 .byte 120 .byte 97 .byte 109 .byte 112 .byte 108 .byte 101 .byte 46 .byte 99 .byte 112 .byte 112 .byte 0 .byte 120 .byte 0 .byte 121 .byte 0 .byte 110 .byte 0 .byte 97 .byte 0 __sd_2inst_string.2: .byte 95 .byte 95 .byte 111 .byte 102 .byte 102 .byte 108 .byte 111 .byte 97 .byte 100 .byte 95 .byte 101 .byte 110 .byte 116 .byte 114 .byte 121 .byte 95 .byte 101 .byte 120 .byte 97 .byte 109 .byte 112 .byte 108 .byte 101 .byte 95 .byte 99 .byte 112 .byte 112 .byte 95 .byte 49 .byte 48 .byte 95 .byte 90 .byte 55 .byte 115 .byte 97 .byte 120 .byte 112 .byte 121 .byte 95 .byte 99 .byte 80 .byte 102 .byte 102 .byte 83 .byte 95 .byte 105 .byte 0 .byte 95 .byte 95 .byte 111 .byte 102 .byte 102 .byte 108 .byte 111 .byte 97 .byte 100 .byte 95 .byte 101 .byte 110 .byte 116 .byte 114 .byte 121 .byte 95 .byte 101 .byte 120 .byte 97 .byte 109 .byte 112 .byte 108 .byte 101 .byte 95 .byte 99 .byte 112 .byte 112 .byte 95 .byte 49 .byte 48 .byte 95 .byte 90 .byte 55 .byte 115 .byte 97 .byte 120 .byte 112 .byte 121 .byte 95 .byte 99 .byte 80 .byte 102 .byte 102 .byte 83 .byte 95 .byte 105 .byte 0
-
22/11/2012, 15h32 #2543*X86 ADV*
Je comprend pas, pourtant je croyais que c'était du x86.
Je crois que le code qui fait le calcul est là :
Et peut-être dans __sd_2inst_string.1, __sd_2inst_string.2 qu'il faudrait tenter d'extraire avec un coup d'awk et déassembler, mais j'ai la flemme...Code:call __offload_offload #10.3
Edit: non, c'est un path de fichier temporaire en ASCII.Dernière modification par Møgluglu ; 22/11/2012 à 16h07.
-
22/11/2012, 15h44 #2544Yugi Rival
- Ville
- Ville:Ville:Ville
Bonjour les barbus, j'ai une petite question de noob. Je bosse le C# et XNA en ce moment dans mon coin (et un peu avec CPC).
Je voudrais mettre en place un genre de système d'équation comme ce qui suit :
A + B = C
A + F = D
A + C = E
A + B + D = G
etc...
Avec l'utilisateur qui balance les additions et le programme qui lui renvoi la solution, ceci logiquement en comparant les valeurs d'un tableau. Existe-il un moyen plus simple et optimisé que de créer trouzemille conditions pour chaque solution possible ?
-
22/11/2012, 16h33 #2545Tyranaus0r
- Ville
- Che suis alßaßien
L'utilisateur il tape "A + B", ou bien il tape des nombres ?
Un programme qui lit des trucs du genre "5+3*4" et qui renvoie la solution, c'est probablement beaucoup plus complexe que tu ne le penses.Rust fanboy
-
22/11/2012, 16h41 #2546Yugi Rival
- Ville
- Ville:Ville:Ville
-
22/11/2012, 16h47 #2547Tyranaus0r
- Ville
- Che suis alßaßien
Je connais pas le C#, mais t'as des trucs qui s'appellent des hash table.
C'est comme un tableau associatif.
Au moment d'initialiser ton programme tu écris :
Et losque l'utilisateur tape un truc, tu fais simplement "tableau[trucQueLutilisateurAEcrit]".Code:tableau["A + B"] = "C"; tableau["A + D"] = "E"; etc.
C'est pas tout à fait clair ton truc mais je pense que c'est ça que tu veux.Rust fanboy
-
22/11/2012, 16h54 #2548Yugi Rival
- Ville
- Ville:Ville:Ville
-
22/11/2012, 19h04 #2549*X86 ADV*
Si c'est bien ce sont parle Tomaka17, alors en C# tu peux par exemple utiliser Dictionary.
Mais à vrai dire je ne suis pas bien sûr d'avoir compris ton besoin ni ton problème
edit: en fait t'as déjà un tableau de correspondance avec tous les cas gérés du type x + y + ... = R, et ce que tu cherches est un moyen simple et rapide de trouver la partie droite de l'égalité en fonction de la partie gauche, sans devoir de taper plein de if ou de switch ?
-
22/11/2012, 20h50 #2550Tyranaus0r
Cette dernière page...
(Vous êtes des fous)
- Mon projet de jeu : EXIL : Des morts, de la plateforme, des colosses et des saucisses.
!Portfolio! - Twitter - Google+ - LinkedIn
Règles de messages
- Vous ne pouvez pas créer de nouvelles discussions
- Vous ne pouvez pas envoyer des réponses
- Vous ne pouvez pas envoyer des pièces jointes
- Vous ne pouvez pas modifier vos messages
- Les balises BB sont activées : oui
- Les smileys sont activés : oui
- La balise [IMG] est activée : oui
- La balise [VIDEO] est activée : oui
- Le code HTML peut être employé : non