Max Floodeur prématuré
Inscrit le: 13 Jan 2009 Messages: 550 Sujets: 47 Spécialité en worldedit: La partie déclencheurs sauf le GUI.
|
Posté le: 12/03/09 17:45 Sujet du message: tests limite actions par trigger |
|
|
Le nom du sujet n'est pas clair, je n'en ai pas trouvé un de très convenable.
J'ai remarqué que lorsqu'on veut faire beaucoup d'actions à un même instant dans un même déclencheur, il arrive qu'on dépasse une certaine limite, et les actions ne sont pas toutes faites. J'ai donc décidé de faire quelques tests là dessus.
Voici mes déclencheurs de test :
Jass: | //déclencheur test_calcul, actions exécutées à temps de jeu 0 s
globals
integer i
endglobals
function Trig_test_calcul_Actions takes nothing returns nothing
local real x
set i = 0
loop
exitwhen i > 100000
//code
set i = i + 1
endloop
endfunction
//===========================================================================
function InitTrig_test_calcul takes nothing returns nothing
set gg_trg_test_calcul = CreateTrigger( )
call TriggerAddAction( gg_trg_test_calcul, function Trig_test_calcul_Actions )
call TriggerRegisterTimerEvent( gg_trg_test_calcul, 0, false )
endfunction |
Jass: | //déclencheur aff_i, actions exécutées à temps de jeu 0,1 s
function Trig_aff_i_Actions takes nothing returns nothing
call DisplayTextToForce( GetPlayersAll(), I2S( i ) )
endfunction
//===========================================================================
function InitTrig_aff_i takes nothing returns nothing
set gg_trg_aff_i = CreateTrigger( )
call TriggerRegisterTimerEvent( gg_trg_aff_i, 0.1, false )
call TriggerAddAction( gg_trg_aff_i, function Trig_aff_i_Actions )
endfunction
|
On met le code que l'on veut tester à la place de //code. Le code est éxécuté un certain nombre de fois, au maximum 100 000 (en fait 100 001). Au temps 0,1 s, le nombre de fois que le code s'est exécuté avant que les actions soient interrompues s'affiche. J'ai donc fait différents tests avec des codes différents :
(il ne faut pas oublier les lignes "exitwhen i > 100 000" et "set i = i + 1" exécutées à chaque fois)
pas de code -> 23 076
call DoNothing -> 19 999
set x = 20. -> 19 999
set x = 20 -> 18 749
set x = 20. * 3. -> 15 789
set x = 20. + 3. -> 15 789
call Cos( 2 ) -> 17 646 , idem avec Sin
set x = Cos( 2 ) -> 16 666 , idem avec Sin
call Cos( 2. ) -> 18 749 , idem avec Sin
set x = Cos( 2. ) -> 17 646 , idem avec Sin
call CosBJ( 45 ) -> 10 714 , idem avec SinBJ
set x = CosBJ( 45 ) -> 10 344 , idem avec SinBJ
call GetUnitX( udg_mob ) -> 18 749 , idem avec GetUnitY
set x = GetUnitX( udg_mob ) -> 17 646 , idem avec GetUnitY
set x = GetUnitFacing( udg_mob ) -> 17 646
set x = GetUnitFacing( udg_mob[ 0 ] ) -> 16 666
set x = GetUnitFacing( udg_mob[ 0 ] ) * 20 -> 13 043
set n = R2I( GetUnitFacing( udg_mob[ 0 ] ) * 20 ) -> 11 999
set x = GetTerrainType( 0, 0 ) -> 13636
call SetTerrainType( 0, 0, 'Nice', -1, 1, 0 ) -> 10 344
call SetTerrainType( 0, 0, 'Nice', -1, 5, 0 ) -> 10 344
call SetTerrainType( 0, 0, 1315529573, -1, 1 , 0 ) -> 10 344 //avec la valeur entière de 'Nice'
call SetTerrainType( 0, 0, NICE, -1, 1 , 0 ) -> 10 344 (NICE : constante )
call SetTerrainType( 0, 0, nice, -1, 1 , 0 ) -> 10 344 (nice : variable )
On remarque qu'il semblerait que ce soit le nombre d'actions effectuées qui influe sur le nombre de fois que la boucle est exécutée, alors que la difficulté des calculs n'influe pas.
Par exemple :
set x = 20 -> conversion de 20 en réel, puis assignation à x
call Cos( 2. ) -> calcul d'un cosinus
Ces deux actions sont exécutées le même nombre de fois ( 18 749 ).
Pourtant, elles n'ont rien à voir.
De même, je trouve étonnant la comparaison suivante :
set x = 20. * 3. -> 15 789
set x = Cos( 2. ) -> 17 646
Je pense qu'au niveau du processeur, un calcul de cosinus est bien plus compliqué qu'une multiplication.
Idem si on compare les deux lignes suivantes :
set x = 20. * 3. -> 15 789
set x = 20. + 3. -> 15 789
Une addition est pourtant bien plus simple qu'une multiplication.
edit : En fait je viens de me rendre compte qu'on peut se passer de la ligne exitwhen, cela augmente alors le nombre d'exécutions du code dans tous les cas. (je pensais auparavant que sans condition de sortie, ça ne pourrait fonctionner)
Tout ça pour essayer de mieux comprendre comment ça marche, afin au final de pouvoir au mieux optimiser son code.
Petite parenthèse n'ayant rien à voir : j'ai découvert récemment que le périodique le plus élevé que l'on puisse utiliser n'est pas "every 0.01 s" (limite minimum des nombres réels en gui) mais "every 0.0001 s". Soit 10 000 fois par seconde. Je me sers d'un périodique si élevé lorsque je veux faire beaucoup d'actions en le moins de temps possible, et que celles-ci ne peuvent être exécutées toutes d'un coup. _________________
|
|