Optimisation

Anonyme · Message par **Anonyme** » jeu. 13/juil./2006 1:44

Voilà, je voudrais savoir si il y a une méthode de lecture/ecriture
plus rapide par rapport aux listes chainée. Car j'ai une enorme liste qui contient la position (x,y,z) de chaque vertex d'un objet 3D quelconque.

File:1->GL01.rar

je pense que l'asm peut m'aider, mais cela ne m'interesse pas , pas le temps d'apprendre

Merci.

Message par **Fred** » jeu. 13/juil./2006 2:08

Utiliser un tableau peut etre ?

Guimauve · Message par **Guimauve** » jeu. 13/juil./2006 2:20

C'est bizarre parce que d'ordinaire la lecture/écriture sur fichier n'a pas vraiment besoin d'être rapide. De plus, les opérations de lecture/écriture varie beaucoup en fonction des disques durs.

Comment tu fais la sauvegarde de ta liste ?

Le moyen le plus rapide que je connais c'est de faire un WriteData() de la grandeur de la liste.

Vais faire des tests ce soir et demain parce que ça m'intéresse et je metterai une soluce ici.

A+
Guimauve

Anonyme · Message par **Anonyme** » jeu. 13/juil./2006 2:25

Vous dormez pas à cette heure là? (3h30 du mat

)

Ce que je voulais dire, c'est savoir si il y a un moyen plus rapide que les listes chainées pour traiter les données qui y sont stockés.

Edit : je parle des données d'une liste quelconque donc la RAM pas le disque.

Guimauve · Message par **Guimauve** » jeu. 13/juil./2006 3:01

Dans mon cas il est 22h00 !!

Voiçi un petit exemple sur différentes méthodes pour sauvegarder une liste de vertices sur fichier binaire. Moi les 3 méthodes donnent le même temps.

À toi de voir ce que ca donne

A+
Guimauve

Code : Tout sélectionner

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; CODE GÉNÉRÉ AUTOMATIQUEMENT, NE PAS MODIFIER À
; MOINS D'AVOIR UNE RAISON TRÈS TRÈS VALABLE !!!
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Déclaration de la Structure >>>>>

Structure Vertex
   
   x.f
   y.f
   z.f
   
EndStructure

; <<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Les mutateurs >>>>>

Macro SetVertexx(ObjetA, P_x)
   
   ObjetA\x = P_x
   
EndMacro

Macro SetVertexy(ObjetA, P_y)
   
   ObjetA\y = P_y
   
EndMacro

Macro SetVertexz(ObjetA, P_z)
   
   ObjetA\z = P_z
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Les observateurs >>>>>

Macro GetVertexx(ObjetA)
   
   ObjetA\x
   
EndMacro

Macro GetVertexy(ObjetA)
   
   ObjetA\y
   
EndMacro

Macro GetVertexz(ObjetA)
   
   ObjetA\z
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Update >>>>>

Macro UpdateVertex(ObjetA, P_x, P_y, P_z)
   
   SetVertexx(ObjetA, P_x)
   SetVertexy(ObjetA, P_y)
   SetVertexz(ObjetA, P_z)
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Lecture fichier Binaire >>>>>

Macro ReadVertex(FileID, ObjetA)
   
   ReadData(FileID, ObjetA, 12)
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Écriture fichier Binaire >>>>>

Macro WriteVertex(FileID, ObjetA)
   
   WriteData(FileID, ObjetA, 12)
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Code généré en : 31 ms <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Macro CountArray(array)
   
   PeekL(@array - 8)
   
EndMacro

Procedure SaveVertexList(FileID, FileName.s, List.Vertex())
   
   If CreateFile(FileID, FileName)
      
      ForEach List()
         
         WriteVertex(FileID, List())
         
      Next 
      
      CloseFile(FileID)
      
   EndIf 
   
EndProcedure 

Procedure SaveVertexArray(FileID, FileName.s, Array.Vertex(1))
   
   If CreateFile(FileID, FileName)
      
      LastIndex = CountArray(Array()) 
      
      For Index = 0 To LastIndex 
         
         WriteVertex(FileID, Array(Index))
         
      Next 
      
      CloseFile(FileID)
      
   EndIf 
   
EndProcedure 

Procedure QuickSaveVertexArray(FileID, FileName.s, Array.Vertex(1))
   
   If CreateFile(FileID, FileName)

      WriteData(FileID, @Array(), 12 * CountArray(Array()))
      
      CloseFile(FileID)
      
   EndIf 
   
EndProcedure 

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

#Meridian = 120
#Parallele = 120

NbSommet=2+((#Meridian+1)*#Parallele)
Dim Sommets.Vertex(NbSommet-1)
NewList ListSommets.Vertex()

For i=0 To #Meridian
   
   theta.f =i*3.14159*2.0/#Meridian
   ctheta.f=Cos(theta)
   stheta.f=Sin(theta)
   
   For j=1 To #Parallele
      
      Alpha.f =j*3.14159/(#Parallele+1)
      calpha.f =Cos(Alpha)
      salpha.f=Sin(Alpha)
      Index = (i*#Parallele) + (j-1)
      
      UpdateVertex(Sommets(Index), salpha*ctheta, salpha*stheta, calpha)
      
      AddElement(ListSommets())
      UpdateVertex(ListSommets(), salpha*ctheta, salpha*stheta, calpha)
      
   Next j
Next i  

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; Début du test

TempsDepartSaveVertexList = ElapsedMilliseconds()

SaveVertexList(0, "SaveVertexList.data", ListSommets())

TempsSaveVertexList = ElapsedMilliseconds()-TempsDepartSaveVertexList



TempsDepartSaveVertexArray = ElapsedMilliseconds()

SaveVertexArray(1, "SaveVertexArray.data", Sommets())

TempsSaveVertexArray = ElapsedMilliseconds()-TempsDepartSaveVertexArray



TempsDepartQuickSaveVertexArray = ElapsedMilliseconds()

QuickSaveVertexArray(2, "QuickSaveVertexArray.data", Sommets())

TempsQuickSaveVertexArray = ElapsedMilliseconds()-TempsDepartQuickSaveVertexArray

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; Résultat du test

message.s = "Le temps pour SaveVertexList : " + Str(TempsSaveVertexList) + " ms" + Chr(13) + Chr(10)
message.s + "Le temps pour SaveVertexArray: " + Str(TempsSaveVertexList) + " ms" + Chr(13) + Chr(10)
message.s + "Le temps pour QuickSaveVertexArray : " + Str(TempsSaveVertexList) + " ms" + Chr(13) + Chr(10)
message.s + "Il y a " + Str(NbSommet) + " vertice à écrire dans les fichiers"

MessageRequester("Test de Sauvegarde", message)

; <<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< FIN DU FICHIER <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<

Guimauve · Message par **Guimauve** » jeu. 13/juil./2006 3:08

Je viens juste de lire le 2e message.

Si tu travaille dans la mémoire, un tableau est plus rapide qu'une liste chainé.

Regarde dans le code que j'ai donnée, j'ai repris une macro écrite par Flype pour trouver la dimension du tableau (1 dimension seulement).

Code : Tout sélectionner

LastIndex = CountArray(Array()) 
      
For Index = 0 To LastIndex 
         
      ; On fait quelque chose avec les vertices
         
Next

Et tu ne sera pas contraint de donner la dimension du tableau à chaque fois dans le cas ou tu voudrait faire des meshs procédurales.

A+
Guimauve

Lna · Message par **Lna** » jeu. 13/juil./2006 3:33

Cpl.Bator tu nous empêches toujours de dormir avec tes questions.

La dernière fois c'était celle de la poule et de l'oeuf qui est arrivé en premier.
Maintenant que tu as trouvé la réponse par toi même, tu nous remets ça.

Il n'y aura pas plus rapide qu'un tableau en mémoire, après il faudra voir la manière de le gérer par rapport aux besoins.

Vivement Kolanta qu'on les voit s'entrebouffer.

A peluche les nounours

Anonyme · Message par **Anonyme** » jeu. 13/juil./2006 8:01

En fait , ce que je voulais savoir si en faisant ceci :

Selectelement(Point3D(),x)
X = Point3D()\X
...
...

si je peut l'optimiser? Pointeurs , peek/poke

@Guimauve, Merci pour ton code ^^

Flype · Message par **Flype** » jeu. 13/juil./2006 8:21

une autre méthode - très rapide - consiste à écrire directement le bloc mémoire du tableau :

Code : Tout sélectionner

;--------------------------------------------------- écriture mémoire
#NBPOINT = 1000

Dim tableau.Point(#NBPOINT)

For i = 0 To #NBPOINT-1
  tableau(i)\x = Random(640)
  tableau(i)\y = Random(480)
Next

;--------------------------------------------------- écriture fichier

If CreateFile(0, "c:\test.bin")
  WriteData(0, @tableau(), #NBPOINT*SizeOf(POINT))
  CloseFile(0)
EndIf

;--------------------------------------------------- lecture fichier

Dim test.Point(#NBPOINT)

If ReadFile(0, "")
  ReadData(0, @tableau(), #NBPOINT*SizeOf(POINT))
  CloseFile(0)
EndIf

;--------------------------------------------------- lecture mémoire

For i = 0 To #NBPOINT-1
  Debug Str(tableau(i)\x) + ", " + Str(tableau(i)\y)
Next

;--------------------------------------------------- fin

mais attention çà ne marche que s'il n'y a pas de données 'externes', c'est à dire des données avec pointeurs sur d'autres zones mémoires.

Flype · Message par **Flype** » jeu. 13/juil./2006 8:23

en fait c'est le même principe que ce bout de code :

Code : Tout sélectionner

Dim hexa.c(15) ; .c pour compatibilité unicode

PokeS(@hexa(), "0123456789ABCDEF")

For i = 0 To 15
  Debug Chr(hexa(i))
Next

djes · Message par **djes** » jeu. 13/juil./2006 8:28

La question de CPL.Bator n'est pas idiote. Les listes chaînées ne sont pas particulièrement rapides en pure. Et utiliser un tableau, c'est se priver de fonctionnalités très intéressantes (insertion/suppression surtout).

Flype · Message par **Flype** » jeu. 13/juil./2006 8:49

c'est pour çà qu'un arbre utilisé à bon escient s'avère toujours beaucoup plus rapide qu'une liste chaînée...
sauf si on a besoin de parcourir tous les éléments auquel cas le tableau est plus adapté. mais quand on veut accéder à un seul élément dans une liste, l'arbre sera forcément plus rapide.

comtois · Message par **comtois** » jeu. 13/juil./2006 9:10

Cpl.Bator a écrit :Voilà, je voudrais savoir si il y a une méthode de lecture/ecriture
plus rapide par rapport aux listes chainée. Car j'ai une enorme liste qui contient la position (x,y,z) de chaque vertex d'un objet 3D quelconque.

File:1->GL01.rar

je pense que l'asm peut m'aider, mais cela ne m'interesse pas , pas le temps d'apprendre
Merci.

Ton objet 3D n'est pas quelconque , il est parfaitement défini

*MESH_NUMVERTEX 4284
*MESH_NUMFACES 8478

dans ce cas une liste chainée ne se justifie pas ,et un tableau sera toujours le plus rapide.

Anonyme · Message par **Anonyme** » jeu. 13/juil./2006 9:18

Merci pour vos réponses, je vais ferais des test de perfs d'accès mémoire.

En principe la taille mémoire nécessaire pour un objet 3D est connue d'avance non ?
J'ai toujours vu le nombre de vertices donné dans le header du fichier.A moins que tu cherches à faire quelque chose de vraiment particulier sinon une liste chainée ne se justifie pas dans ce cas.

@Comtois le nombre de vertex est connu d'avance certe, mais pas la scène à afficher. Chaque objet peut bouger selon c'est propre axes (normal) mais le rendu se fait de manière globale, je traitre toute les vertex qui rentre dans certaine conditions, c'est plus performant de cette manière, que de faire un rendu propre à chaque objet (trop d'appel de fonction) C'est pour cela que j'ai besoin d'un accès rapide à la mémoire vive.

File:1->GL02.rar

Faites pas gaffe aux UV , je les gères pas lors du chargements

Z,Q,S,D,Pavnum8 & 2

comtois · Message par **comtois** » jeu. 13/juil./2006 9:29

je ne comprends pas trop ce que tu fais, mais pour le rendu d'un Z-buffer tu peux le faire dans un tableau de la taille de ton écran ou de la taille de l'image finale qui sera affichée sur l'écran.

PureBasic

Optimisation

Optimisation

Re: Optimisation