Meilleure méthode pour effacer la mémoire ? [Résolu]

Kwai chang caine

Bonjour la famille

Je suis en train d'utiliser l'instruction serveur

ReceiveNetworkData(IdConnection, *Buffer, 1000)

Et je m'apperçois que parfois, il me reste des relicats d'anciennes données ecrites à cet emplacement.
Je vousdrais donc effacer les 1000 octets pour etre sur que y'ai pas d'embrouilles

Alors avant de vous déranger, j'ai chercher comme dirais quinquin que je ne citerais pas

et je me suis rendu compte que deux methodes marchent.

Quand je refais dans une boucle un allocatememory et quand je rempli de vide les octets.
Quelle est la meilleure methode, n'est ce pas dangereux de reallouer a chaque passage de boucle, ou faut il remplir de vide ???

Code : Tout sélectionner

Debug "J'alloue 1000 caracteres en mémoire"
 *Buffer = AllocateMemory(1000)
 Debug ""
 
 Debug "J'ecris 1000 fois A"
 PokeS(*Buffer, RSet("", 1000, "A"), 1000)
 Debug PeekS(*Buffer,10)
 Debug ""
 
 Debug "J'efface la mémoire, en ecrivant des vides"
 PokeS(*Buffer, RSet("", 1000, ""), 1000)
 Debug PeekS(*Buffer,10)
 Debug Len(PeekS(*Buffer,10))
 Debug ""
 
 Debug "J'ecris à nouveau 1000 fois A"
 PokeS(*Buffer, RSet("", 1000, "A"), 1000)
 Debug PeekS(*Buffer,10)
 Debug ""
 
 Debug "Je réalloue 1000 caracteres en mémoire, pour effacer"
 *Buffer = AllocateMemory(1000)
 Debug PeekS(*Buffer,10)
 Debug Len(PeekS(*Buffer,10))

Pour une fois que je veux effacer quelque chose de ma memoire

D'habitude ça se fait tout seul

Merci et bonne journée

Patrick88 · Message par **Patrick88** » lun. 26/janv./2009 19:24

freememory( ?

pat

Kwai chang caine

Merci beaucoup PATRICK de ta reponse

En fait je veux pas vraiment la libérer, mais la vider.

Alors est ce que ça pose un probleme de faire ça, ou bien c'est comme ça qui faut faire :

Code : Tout sélectionner

For i = 1 To 100
 
 *Buffer = AllocateMemory(1000) 
 PokeS(*Buffer, RSet("", 1000, "A"), 1000) 
 Debug PeekS(*Buffer,10) 
 FreeMemory(*Buffer)
 Debug "" 
 
Next

En fait je veux utiliser une mémoire la nettoyer pour etre sur qu'il ne reste pas de caracteres qui traine, et la réutiliser à nouveau et ceci X fois de suite

Ollivier · Message par **Ollivier** » lun. 26/janv./2009 21:51

Bijour Mssieur Kwaï,

Un problème de crasse? Je connais, je les cultive à mon insu, je dirais même...

Pour nettoyer en profondeur et plus blanc que le blanc vendu auparavant, je vous conseille la lessive ZeroMemory_().

En effet, ZeroMemory_() va nettoyer là où aucune lessive ne nettoyait jusque là, et même si vous faites un noeud.

Code : Tout sélectionner

TailleZoneEnOctets = 1000
*Adresse = AllocateMemory(TailleZoneEnOctets)

; Ici tu mets la saleté à coup de PokeX() et tout le toutim...

ZeroMemory_(*Adresse, TailleZoneEnOctets)

Vendu par Crosoft Corp. «Don't worry... Be A.P.I.»

Kwai chang caine

Merci beaucoup mon bon OLLIVIER

J'savais pas qu'y avait un "NOUVEL OUMOUL"

Alors je peut ecrire un boucle comme celle la, sans poser aucun probleme ???

Code : Tout sélectionner

For i = 1 To 100 
  
 *Buffer = AllocateMemory(1000) 
 PokeS(*Buffer, RSet("", 1000, "A"), 1000) 
 Debug PeekS(*Buffer,10) 
 ZeroMemory_(*Buffer, 1000)
 Debug "" 
  
Next

Ollivier · Message par **Ollivier** » lun. 26/janv./2009 22:05

Tu peux même surboucler, faire autant de boucle que tu veux: je te l'ai bien dit, même avec des noeuds ça nettoie...

Kwai chang caine

Merci beaucoup.
Cette fois j'ai bien compris

Je croyais qu'il fallait faire un allocate memory qu'une fois dans un prog

Alors, je t'explique pas le bordel de ce qui me remontait

Alors impecable, je vais faire exactement cette boucle

Comme ça ma mémoire y va etre toute propre

Merci Mr PROPRELLIVIER

flaith · Message par **flaith** » lun. 26/janv./2009 22:53

J'allais le dire, utilise Zeromemory, comme j'ai pas cherché sous Linux s'il existait, j'ai fait ca

Code : Tout sélectionner

Procedure ZeroMemory(*memory.CHARACTER, size.l)
Protected iByte

  iByte = 0
  While iByte <= size
    PokeL(*memory + iByte, $00)
    iByte + 4
  Wend
EndProcedure

Ca marche aussi bien sous GNU/Linux que sous win.

Kwai chang caine · Message par **Kwai chang caine** » mar. 27/janv./2009 9:11

Merci beaucoup FLAITH

Je viens d'essayer ton code, et j'ai une jolie barre rouge à la ligne 14

ça plante à la 42e reprise
Seul le maitre des clefs peut me dire pourquoi.
Peut etre une histoire de decalage de quelque chose

Code : Tout sélectionner

Procedure ZeroMemory(*memory.CHARACTER, size.l) 
Protected iByte 

  iByte = 0 
  While iByte <= size 
    PokeL(*memory + iByte, $00) 
    iByte + 4 
  Wend 
EndProcedure

For i = 1 To 100 
  
 *Buffer = AllocateMemory(1000) 
 PokeS(*Buffer, RSet("", 1000, "A"), 1000)
 Debug i
 Debug PeekS(*Buffer,10) 
 ZeroMemory(*Buffer, 1000) 
 Debug PeekS(*Buffer,10) 
 Debug "" 
  
Next

Le code de PATRICK avec FREEMEMORY ne marche pas tout à fait.
Car quand j'essai de relire, j'ai un hieroglyphe.
Je pense que c'est normal, car j'essai de lire une partie de la memoire qui n'existe plus

Code : Tout sélectionner

For i = 1 To 100 
  
 *Buffer = AllocateMemory(1000) 
 PokeS(*Buffer, RSet("", 1000, "A"), 1000) 
 Debug i
 Debug PeekS(*Buffer,10) 
 FreeMemory(*Buffer) 
 Debug PeekS(*Buffer,10) 
 Debug "" 
  
Next

Par contre le code de OLLIVIER marche avec l'API

Code : Tout sélectionner


For i = 1 To 100 
  
 *Buffer = AllocateMemory(1000) 
 PokeS(*Buffer, RSet("", 1000, "A"), 1000) 
 Debug i
 Debug PeekS(*Buffer,10) 
 ZeroMemory_(*Buffer, 1000) 
 Debug PeekS(*Buffer,10) 
 Debug "" 
  
Next

Le Soldat Inconnu

zigoto, si tu fait FreeMemory, il faut refaire un AllocateMemory derrière, sinon, ta zone mémoire n'existe plus

Code : Tout sélectionner

For i = 1 To 100 
  
 *Buffer = AllocateMemory(1000) 
 PokeS(*Buffer, RSet("", 1000, "A"), 1000) 
 Debug PeekS(*Buffer,10) 
 FreeMemory(*Buffer) 
 Debug "" 
  
Next

sinon, évite de faire 36 AllocateMemory sans faire un freememory
si tu fais ça, c'est pas bon !

Code : Tout sélectionner

For i = 1 To 100 
  
 *Buffer = AllocateMemory(1000) 
 PokeS(*Buffer, RSet("", 1000, "A"), 1000) 
 Debug PeekS(*Buffer,10) 
 ZeroMemory_(*Buffer, 1000) 
 Debug "" 
  
Next

Tu as allouer 100 zones mémoires de 1000 octets

il faut faire comme ça :

Code : Tout sélectionner

*Buffer = AllocateMemory(1000) 
For i = 1 To 100 
  
 PokeS(*Buffer, RSet("", 1000, "A"), 1000) 
 Debug PeekS(*Buffer,10) 
 ZeroMemory_(*Buffer, 1000) 
 Debug "" 
  
Next

Kwai chang caine · Message par **Kwai chang caine** » mar. 27/janv./2009 9:35

zigoto !!!!

Coooooool !!! KCC il a un nouveau titre

KCC il espere, avoir un jour la poitrine de samantha fox, pour pouvoir accrocher toutes les medailles de ses amis du forum.

Parce que maintenant KCC il est (Dans l'ordre "montrologique")
Le bouffon de FLYPE (Il me manque d'ailleur mon roi

)
Le IDIOTMAN de SROD
Et fier d'etre le ZIGOTO de SOLDAT

Merci beaucoup soldat, c'est "beaucoup trop de la honnir" (Rabbi jacob)

Tres bien, donc j'ai compris que l'API efface la memoire sans la tuer et c'est exactement ce que je voulais faire

Freememory TUE la memoire , tin tin tintin tin tintin tintin tintin

Mes bien cher freres nous somme tous réunis en cette journée de grace afin de faire un dernier adieu a cette mémoire......

Il faut donc en recréer une toute neuve avec "ALLO CAT SAUVETAGE".....non non KCC t'es une burne

le gentil monsieur y t'as dit ALLOCATMEMORY

Merci de cette marque de gratitude et surtout de ton aide.
ATTENTION !!! KCC il y tiens à son titre

Les autres y ont qu'a prendre un autre......Abruti, bouffon, etc....c'est pas ce qui manque

PAPIPP · Message par **PAPIPP** » mar. 27/janv./2009 9:48

Je viens de faire quelques essais
et voici les résultats
J'ai modifier la première méthode pour allouer 100 zones
et les retrouver

Code : Tout sélectionner

; ; code 
Debug "**************** première  méthode **************"

Dim *buffer(100)
For i = 0 To 100
  
  *Buffer(I) = AllocateMemory(1000)
  PokeS(*Buffer(i), RSet("", 1000, "A"), 1000)
  Debug PeekS(*Buffer(i), 10)
  
  Debug ""+Str(i)+"adress="+Hex(*buffer(i))
  
Next
Debug "**************** fin libere la mémoire les zones d'allocation sont enregitrées **************"
For i=0 To 100
Debug PeekS(*Buffer(i), 10)
Debug ""+Str(i)+"adress="+Hex(*buffer(i))

FreeMemory(*Buffer(i))
Next
; *******************************************************************************************************
; ; Code:
Debug "**************** deuxième méthode  comment retrouver les zones d'allocation ?? **************"
For i = 1 To 100
  
  *Buffer = AllocateMemory(1000)
  PokeS(*Buffer, RSet("", 1000, "A"), 1000)
  Debug PeekS(*Buffer, 10)
  ZeroMemory_(*Buffer, 1000)
  Debug ""+Str(i)+"adress="+Hex(*buffer)
  
Next
;*************************************************************************************************************** 
; code 
Debug "**************** troisième méthode ici il n'y a qu'une zone d'allouée et non 100 zones **************"

*Buffer = AllocateMemory(1000)
For i = 1 To 100
  
  PokeS(*Buffer, RSet("", 1000, "A"), 1000)
  Debug PeekS(*Buffer, 10)
  ZeroMemory_(*Buffer, 1000)
  Debug ""+Str(i)+"adress="+Hex(*buffer)
Next

Kwai chang caine

Merci PAPIPP

Mais j'ai une petite erreur ligne 27

PAPIPP · Message par **PAPIPP** » mar. 27/janv./2009 12:01

oups! j'avais réalisé les essais en plaçant les autres méthodes en commentaires et je n'ai pas pas vu cette erreur d'allocation.
Après plusieurs essais dont certains avec 200 allocations j'ai une erreur sur freememory dans la première méthode.
Avec 100 allocations les 3 méthodes prises les unes après les autres
fonctionnent normalement
Il semble que quelque chose nous limite en nombre d'allocation
A voir de plus près peut-être y-a-t'il une bogue

Code : Tout sélectionner

; ; code
 #imax=100
; Debug "**************** première  méthode **************"
; 
; Dim *buffer(#imax)
; For i = 0 To #imax
;   
;   *Buffer(I) = AllocateMemory(1000)
;   PokeS(*Buffer(i), RSet("", 1000, "A"), 1000)
;   Debug PeekS(*Buffer(i), 10)
;   
;   Debug "" + Str(i) + "adress=" + Hex(*buffer(i))
;   
; Next
; Debug "*************** fin libere la mémoire les zones d'allocation sont enregitrées **************"
; ; For i = #imax To 0 Step -1
; For i = 0 To #imax
; 
;   Debug PeekS(*Buffer(i), 10)
;   Debug "" + Str(i) + "adress=" + Hex(*buffer(i))
;   
;   FreeMemory(*Buffer(i))
; Next
; ; Delay (1000)
; 
; ; *******************************************************************************************************
; ; ; Code:
Debug "**************** deuxième méthode  comment retrouver les zones d'allocation ??  **************"
For i = 1 To #imax
  
  *Buffer = AllocateMemory(1000)
  PokeS(*Buffer, RSet("", 1000, "A"), 1000)
  Debug PeekS(*Buffer, 10)
  ZeroMemory_(*Buffer, 1000)
  Debug "" + Str(i) + "adress=" + Hex(*buffer)
  ; FreeMemory(*Buffer)

Next
;***************************************************************************************************************
; code
Debug "**************** troisième méthode ici il n'y a qu'une zone d'allouée et non 100 zones **************"

*Buffer = AllocateMemory(1000)
For i = 1 To 100
  
  PokeS(*Buffer, RSet("", 1000, "A"), 1000)
  Debug PeekS(*Buffer, 10)
  ZeroMemory_(*Buffer, 1000)
  Debug "" + Str(i) + "adress=" + Hex(*buffer)
Next

Kwai chang caine

Cette fois plus d'erreur merci beaucoup PAPIPP

Je vais etudier ça