Allocation Mémoire

[LeCyb]

J'ai quelques doutes sur mes buffers donc je me lance.

1) Que se passe-t-il si on réalloue un espace mémoire plus petit que d'origine ?
Le buffer a quelle taille, 10 ou 5 ?

Code : Tout sélectionner

*buffer = AllocateMemory(10)
*buffer = ReAllocateMemory(5)

2) Y a-t-il un moyen quelconque pour avoir la taille d'un espace mémoire (mis à part une variable que l'on gère) ?
Exemple: si je veux retourner un nouvel espace en mémoire fraîchement créé par une procédure.

3) Quelle est la bonne syntaxe pour intégrer un espace mémoire dans une interface ?
Exemple:

Code : Tout sélectionner

Interface MonObjet
  MaProcedure()
EndInterface

Structure MesFonctions
  MaProcedure.l
EndStructure

Structure MaStructure
  *Fonctions.MesFonctions
  buffersize.l
  ; ici je fais *buffer.l ?
EndStructure

Procedure MaProcedure(*this.MaStructure)
  ; si je veux faire un Peek ou autre
  ;*this\*buffer ?
  ;*this\buffer ?
  ;*this\autre ?
EndProcedure

4) Un peu moins dans le trip mémoire mais est-ce que les tableaux sont des Global ? Est-ce qu'il sont thread-safe ?

Merci

[Chris]

En principe, ReAllocateMemory() donne la taille que tu lui demande de donner. Dans ton cas, il la diminue. (A confirmer, quand même)

Pour connaitre la taille de la mémoire allouée, j'utilise la fonction LocalSize(*Buffer), de l'API Windows. Je ne sais pas si c'est bon, mais pour moi, ça marche.
Par contre, si la taille de ce qui est en mémoire est plus grande que ce que tu veux reallouer, le contenu de ce qui est en plus est perdu.

C'est, tout au moins, ce que je constate avec ce test:

Code : Tout sélectionner

*Buffer = AllocateMemory(100)

For i = 0 To 99
  a$+"a"
Next
PokeS(*Buffer, a$)

Size = LocalSize_(*Buffer)
Debug Size : Debug PeekS(*Buffer)

*Buffer = ReAllocateMemory(*Buffer, 50)

Size = LocalSize_(*Buffer)
Debug Size : Debug PeekS(*Buffer)

Pour la question 3, je ne sais pas, pour la 4, oui, il sont globaux, et pour thread-safe, je ne sais même pas ce que ça veut dire

[nico]

1) chris a répondu

2) une autre solution sans api serait d'utiliser ta zone mémoire pour renvoyer le nombre d'octets.

Code : Tout sélectionner

Procedure test()
     *buffer = AllocateMemory(19)   
     PokeS(*buffer+4,"Ma zone mémoire")
     *Newbuffer = ReAllocateMemory(*buffer,42+4) 
     PokeS(*Newbuffer+Len("Ma zone mémoire")+4," est maintenant plus grande")
     PokeL(*Newbuffer,44)
     ProcedureReturn *Newbuffer
EndProcedure

*pointeur= test()
Debug PeekL(*pointeur)
Debug PeekS(*pointeur+4)

3) la bonne syntaxe ext:

Code : Tout sélectionner

structure MaStructure
       *buffer.l
;.................
;................
EndStructure

*this.MaStructure

*this\buffer 

4) comme Chris , ce terme ne m'est pas familier; mais les tableaux sont des zones mémoires distinctes donc devrait pas y avoir de problème.

[LeCyb]

2) C'est exactement ce que je cherchais, LocalSize est mon ami

1) Grâce à LocalSize on voit clairement que ça diminue la taille, LocalSize devient mon meilleur ami

3) Impec

4) Après quelques tests j'ai conclus qu'ils ne sont pas Global mais par contre ils ne sont pas thread-safe si on fait un tableau de chaînes (logique puisque les chaînes ne sont pas encore thread-safe).

Super merci à vous deux.

@Crhis, le thread-safe cela veut dire que l'on peut utiliser la chose en question dans des threads et que ça ne pose pas de problème.

[nico]

Si tu stockes toi même tes chaines dans des blocs mémoires alloués alors t'a plus de problème, non!

[LeCyb]

Oui c'est un fait mais cela peut être très laborieux dans certains cas (le mien :p).
Mais dans la V4 Fred m'a dit que les chaînes allaient être thread-safe.