Optimisation d'un code PB en ASM

[SPH]

Salut à tous (et particulièrement a Manababel),

Y aurait il un code assembleur pouvant booster cette partie d'un code ? :

Code : Tout sélectionner

  
quad_hazard.q=octets1(x)+octets1(x+1)*256+octets1(x+2)*65536+octets1(x+3)*16777216+octets1(x+4)*4294967296+octets1(x+5)*1099511627776+octets1(x+6)*281474976710656+octets1(x+7)*72057594037927936
x=Random(Len(sph$))+1
quad_hazard.q!octets2(x)+octets2(x+1)*256+octets2(x+2)*65536+octets2(x+3)*16777216+octets2(x+4)*4294967296+octets2(x+5)*1099511627776+octets2(x+6)*281474976710656+octets2(x+7)*72057594037927936

Et cette partie aussi :

Code : Tout sélectionner

  tableau(a)!quad_hazard
  q=Random(65536*32768-1)+cent(Random(100))
  q*Random(65536*32768-1)*vingt(Random(20)+1)
  q*Random(65536*32768-1)+vingt(Random(20)+1)
  q+Random(65536*32768-1)+cent(Random(100))
  tableau(a)!q

Merci

[manababel]

Bonjour SPH ,
ca ne me pose pas de probleme pour vous aider.
mais je ne comprends pas ce que vous voulez faire.
pouvez vous poster un autre code que je puisse compiler.

Dans le premier code posté , si c'est des nombre entriers , utilisez plutot le decalage de bits que la multiplication ( x<<8 = x*256 )
Dans le deuxieme code essayé d'utilisez un minimum de ramdom , si c,'est posible .

[manababel]

voici comment je traduirais la ligne :

quad_hazard.q=octets1(x)+octets1(x+1)*256+octets1(x+2)*65536+octets1(x+3)*16777216+octets1(x+4)*4294967296+octets1(x+5)*1099511627776+octets1(x+6)*281474976710656+octets1(x+7)*72057594037927936

par :

Dim octets1.q(999)
x.q=0
pointer.q = @octets1()
!mov rax,[v_x]
!shl rax,3
!add rax,[v_pointer]
!movq xmm0,[rax+0*0]
!movq xmm1,[rax+1*8]
!psllq xmm1,8 ; * 256
!movq xmm2,[rax+2*8]
!psllq xmm2,16 ; * 65536
!movq xmm3,[rax+3*8]
!psllq xmm3,24 ; ...
!movq xmm4,[rax+4*8]
!psllq xmm4,32
!movq xmm5,[rax+5*8]
!psllq xmm5,40
!movq xmm6,[rax+6*8]
!psllq xmm6,48
!movq xmm7,[rax+7*8]
!psllq xmm7,64
!paddq xmm0,xmm1
!paddq xmm0,xmm2
!paddq xmm0,xmm3
!paddq xmm0,xmm4
!paddq xmm0,xmm5
!paddq xmm0,xmm6
!paddq xmm0,xmm7
!movq [v_quad_hazard],xmm0

[SPH]

Merci, je regarde ça !

[SPH]

Bon, j'ai mis bout à bout mon code et le tiens.
Ca n'affiche pas les mêmes valeurs...

Code : Tout sélectionner

Dim octets1.w(100)
For i=0 To 100
  octets1.w(i)=Random(65535)
Next
x=0

quad_hazard.q=octets1(x)+octets1(x+1)*256+octets1(x+2)*65536+octets1(x+3)*16777216+octets1(x+4)*4294967296+octets1(x+5)*1099511627776+octets1(x+6)*281474976710656+octets1(x+7)*72057594037927936

Debug quad_hazard

;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;

pointer.q = @octets1()
!mov rax,[v_x]
!shl rax,3
!add rax,[v_pointer]
!movq xmm0,[rax+0*0]
!movq xmm1,[rax+1*8]
!psllq xmm1,8 ; * 256
!movq xmm2,[rax+2*8]
!psllq xmm2,16 ; * 65536
!movq xmm3,[rax+3*8]
!psllq xmm3,24 ; ...
!movq xmm4,[rax+4*8]
!psllq xmm4,32
!movq xmm5,[rax+5*8]
!psllq xmm5,40
!movq xmm6,[rax+6*8]
!psllq xmm6,48
!movq xmm7,[rax+7*8]
!psllq xmm7,64
!paddq xmm0,xmm1
!paddq xmm0,xmm2
!paddq xmm0,xmm3
!paddq xmm0,xmm4
!paddq xmm0,xmm5
!paddq xmm0,xmm6
!paddq xmm0,xmm7
!movq [v_quad_hazard],xmm0

;quad_hazard.q=octets1(x)+octets1(x+1)*256+octets1(x+2)*65536

Debug quad_hazard

Par contre, en utilisant "<<", ça marche (et c'est en effet plus rapide) :

Code : Tout sélectionner

Dim octets1.w(100)
For i=0 To 100
  octets1.w(i)=Random(65535)
Next
x=0

quad_hazard.q=octets1(x)+octets1(x+1)*256+octets1(x+2)*65536+octets1(x+3)*16777216+octets1(x+4)*4294967296+octets1(x+5)*1099511627776+octets1(x+6)*281474976710656+octets1(x+7)*72057594037927936

Debug quad_hazard

;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;

quad_hazard.q=octets1(x)+octets1(x+1)<<8+octets1(x+2)<<16+octets1(x+3)<<24+octets1(x+4)<<32+octets1(x+5)<<40+octets1(x+6)<<48+octets1(x+7)<<56

Debug quad_hazard

[manababel]

Voici une version optimisée , mais le gain est insignifiant.

Code : Tout sélectionner

Dim octets1.u(100)
For i=0 To 100
  octets1(i)=Random(65535)
Next
x=0

quad_hazard.q=octets1(x)+octets1(x+1)<<8+octets1(x+2)<<16+octets1(x+3)<<24+octets1(x+4)<<32+octets1(x+5)<<40+octets1(x+6)<<48+octets1(x+7)<<56
Debug quad_hazard


pointer.q = @octets1()
!mov rax,[v_x]
!shl rax,1
!add rax,[v_pointer]
!pxor xmm0,xmm0
!pxor xmm1,xmm1
!pxor xmm2,xmm2
!pxor xmm3,xmm3
!pinsrw xmm0,[rax+00],0
!pinsrw xmm1,[rax+02],0
!psllq xmm1,8
!pinsrw xmm0,[rax+04],1
!pinsrw xmm2,[rax+06],0
!psllq xmm2,24
!pinsrw xmm0,[rax+08],2
!pinsrw xmm3,[rax+10],0
!psllq xmm3,40
!paddq xmm0,xmm1
!paddq xmm0,xmm2
!pxor xmm1,xmm1
!pinsrw xmm0,[rax+12],3
!pinsrw xmm1,[rax+14],0
!psllq xmm1,56
!paddq xmm0,xmm3
!paddq xmm0,xmm1
!movq [v_quad_hazard],xmm0
Debug quad_hazard

[manababel]

pour la partie avec les "random"
si possible , utiliser cette commande un minimum de fois ( je me répète )
et/ou utiliser un "custom random", il exit une version rapide avec "XOR" au lieu de "MOD"
mais c'est plus délicat à mètre en œuvre.

[SPH]

Code : Tout sélectionner

Dim octets1.u(100)

C'est quoi un dim ".u" ? même taille qu'un ".w" ?

pour les randoms, je sais mais je n'ai pas le choix

[case]

.u unsigned ?

[SPH]

Je regarderais demain sur mon autre ordi mais j'utilise des :

Code : Tout sélectionner

Dim octets1.w(100)

Je pense que les ".u" ne seront pas compatibles...

[manababel]

.u = unsigned
u => 0 à 655535
w => -32768 à 32767
je regard si je peux le rendre compatible .w

[SPH]

.u = unsigned
u => 0 à 655535
w => -32768 à 32767
je regard si je peux le rendre compatible .w

Je ne savais pas que ".u" pouvait etre renseigner dans PB (contrairement a l'asm).

Merci pour ton essai de compatibilité ".w"

[manababel]

Tel quelle, je ne pense pas pouvoir optimise le code en Asm, PB fait très bien son travail

voici le code que PB crée

Code : Tout sélectionner

Dim octets1.w(100)
pointer.q = @octets1()
var.q = 0
For i=0 To 100
  octets1(i)=Random(65535)
Next
x=0
quad_hazard.q = octets1(x+0) +octets1(x+1)<<8+octets1(x+2)<<16+octets1(x+3)<<24+octets1(x+4)<<32+octets1(x+5)<<40+octets1(x+6)<<48+octets1(x+7)<<56
Debug quad_hazard

!mov rax,[v_x]
!shl rax,1
!add rax,[v_pointer]

!movsx  r8, word[rax+00]
!movsx  r9, word[rax+02]
!shl r9,8
!add r8,r9
!movsx  r9, word[rax+04]
!shl r9,16
!add r8,r9
!movsx  r9, word[rax+06]
!shl r9,24
!add r8,r9
!movsx  r9, word[rax+08]
!shl r9,32
!add r8,r9
!movsx  r9, word[rax+10]
!shl r9,40
!add r8,r9
!movsx  r9, word[rax+12]
!shl r9,48
!add r8,r9
!movsx  r9, word[rax+14]
!shl r9,56
!add r8,r9

!mov [v_quad_hazard],r8
Debug quad_hazard

le mnémonique "MOVSX" permet de convertir un "word signé"(16bits) en un "quad signé"(64bits) . ( dans le prog ci-dessus )
il n'y a pas d’équivalent dans les "simd".

[SPH]

Grand merci manababel,

j'en ai appris des trucs avec ce post !
Pour la peine, je vais refaire un troisieme crypteur

ThX a LoT

[Ollivier]

Petite remarque : il me semble que les multiplication et division entières par puissances de 2 sont optimisées.

x.i * 2 ; <=> x.i << 1