PureBasic

Hello,

Je suis en train de porter une assez grosse application OpenGL de VB à PB.

Alors que je croyais évident que PB serait bien plus rapide que VB dans tous les cas de figure, je rencontre des différences de performances à l'avantage de VB dans des grosses boucles notamment dans les cas suivants :

1) Loader d'objet 3D. Il s'agit d'une boucle permettant de charger une scène OpenGL à partir de fichiers ".OBJ". En VB, cette boucle met 500 ms à s'exécuter alors qu'elle met 1600 ms en PB. Le code est exactement le même à la différence de syntaxe du langage près.

2) Boucle de rafraîchissement d'affichage OpenGL. Là ou j'ai un framerate de 20 FPS en fullscreen en VB, je n'ai que 15 FPS en PB. Cette boucle fait des "glCallList" sur l'ensemble des Mesh de la scène OpenGL.

Ma question est donc la suivante : Est-il connu que les boucles (FOR, FOREACH) ou les appels d'APIs (API OpenGL en l'occurrence) ou encore les tableaux ou listes chaînées de PB sont particulièrement lent ?

Cordialement.

Peut être que VB optimize les boucles qui ne servent à rien, comme pour le C ?
as-tu veillé à ne pas mettre des choses du genre ;

Code : Tout sélectionner

For t=0 to variable-1

?
Faut pas faire de calcul dans les boucles

Je peux t'assurer que mes boucles ne sont pas vides

Il n'y en a qu'une dans chacun des deux cas de figure que je décris et de toute façon, le code qu'elle contiennent est le même dans VB et dans PB donc le problème de leur contenu (calculs) n'est pas vraiment en cause.

As-tu désactivé le débugger de PB car le débugger allonge fortement les temps lors des comparaisons.

Oui, en fait je compare la vitesse d'exécution des exécutables

Niffo a écrit :Oui, en fait je compare la vitesse d'exécution des exécutables

Non, quand je dis calcul, c'est dans la ligne ou tu écrit "For", car ça éxecute le calcul à chaque boucles, ce qui, forcément, ralentit tout, alors que d'autres compilers n'éxécute le calcul qu'une seule fois (je ne sais pas pour vb...)

Je ne connais rien à VB, mais une différence pareille me paraît bizarre quand même.

500 ms enVB, 1600 ms en PB, c'est quand même plus de 3 fois plus lent

Que PB ne soit pas plus rapide, c'est possible, pourquoi pas. Mais 3 fois plus lent, ....

Par contre, dans les deux cas, ce sont des boucles bourrées d'appels aux APIs OpenGL (glVertex, glCallList, etc ...)

C'est peut-être une piste ?

Je suis comme Chris, d'autant quer VB fait appel encore à une sous-couche (dll)

En fait, poste donc le code en Purebasic pour voir

Code : Tout sélectionner

    ForEach TabDecors()
        *TD.Object3D = @TabDecors()\OB
        glPushMatrix_()

        glLoadName_(ListIndex(TabDecors()))

        glTranslatef_(*TD\Position\x, *TD\Position\y, -*TD\Position\z)
        glRotatef_(*TD\Orientation\x, 1.0, 0.0, 0.0)
        glRotatef_(-*TD\Orientation\y, 0.0, 1.0, 0.0)
        glRotatef_(*TD\Orientation\z, 0.0, 0.0, 1.0)
        glScalef_(*TD\Scale\x, *TD\Scale\y, *TD\Scale\z)
        glColor4f_(*TD\Color\r, *TD\Color\g, *TD\Color\b, *TD\Color\a)
        glCallList_(*TD\Object)

        glPopMatrix_()
        ;End With
    Next

Hmm, je parlais du code, en entier, quoi, pour qu'on puisse voir vraiment ce qui cloche

Tu a l'air de t'y connaitre bien en OpenGL.
Mais je savais pas que fonctions openGL était dans l'api Windows.
Aujourd'ui j'ai apris un truc

.

Mais je savais pas que fonctions openGL était dans l'api Windows.

Oui, Windows inclue les APIs OpenGL. Sauf que sur la prochaine version de Windows, Windows Vista, l'OpenGL ne sera plus implenté nativement. Si l'on souhaite travailler avec OpenGL va nous falloir installer les DLLs nous même.

A+
Guimauve

@Polo : mon programme fait plus de 8000 lignes

PureBasic

Différence de performances VB => PB ?

Différence de performances VB => PB ?