Allouer un bloc de mémoire dans le Heap

Salut tout le monde.

Je ne sais pas si le code ci-dessous a un sens ou non.
Mais comme j’aime partager pour m’instruire, je poste mon code.

La kernell32.dll possède (entre autres) les fonctions
GetProcessHeap qui donne le handle du heap (le tas) c’est-à-dire l’un des deux segments de mémoire utilisés durant l’exécution du programme. (L’autre segment étant la pile (stack)
HeapAlloc pour allouer un bloc de mémoire à partir du heap
HeapFree pour libérer la mémoire allouée.

J’ai essayé d’utiliser ces fonctions et voici le fruit de mon labeur.
Je me demande si ça pourrait servir à quelque chose de concret. allouer - Allouer un bloc de mémoire dans le Heap U_THIN%7E1

allouer - Allouer un bloc de mémoire dans le Heap U_THIN%7E1

Code:: rem ============================================================================
rem Allouer un bloc de mémoire dans le Heap (tas)
rem ============================================================================

dim hHeap% : ' Handle du Heap
dim pteur% : ' Pointeur vers la mémoire allouée
dim NbOctets% : NbOctets% = 100 : ' Nombre d'octets à allouer
DIM IpMem% : ' Pointeur de la zone mémoire à libérer
dim free% : ' Résultat de la fonction de libération de la mémoire
dim t$ : t$ = "Salut tout le monde"
dim i,m$
top 0, 100 : left 0,300 : height 0, 150
dll_on "kernel32.dll"
rem ============================================================================
' Obtenir le handle du heap du process appelé
hHeap% = dll_call0("GetProcessHeap")
print : print " Handle du Heap : " + str$(hHeap%)
rem ============================================================================
' Allouer un bloc de mémoire à partir du heap
' En cas de succès, retourne un pointeur vers la mémoire allouée
' Sinon retourne la valeur NULL
' Les paramètres d'appel sont :
' hHeap% : handle du heap à partir duquel la mémoire peut être allouée
' dwFlags% : pour contrôl : la valeur 0 pour initialiser la mémoire allouée à zéro
' dwBytes% : nombre d'octets à allouer
pteur% = dll_call3("HeapAlloc",hHeap%,0,NbOctets%)
print " Pointeur vers la mémoire allouée de " + str$(NbOctets%) + " Octets : " + str$(pteur%)
rem ===========================================================================
' Ecrire un texte dans le bloc de la mémoire allouée
print " J'écris un texte dans la mémoire allouée : " + t$
for i = 0 to len(t$) -1
   poke pteur% + i ,asc(mid$(t$,i+1,1))
next i
' Lire le texte à partie de la mémoire allouée
for i = 0 to len(t$) -1
   m$ = m$ + chr$(peek(pteur%+i))
next i
print " Je récupère mon texte à partir de la mémoire allouée : " + m$

rem ===========================================================================
' Libérer le bloc de mémoire allouée
' Si la fonction échoue, elle retourne 0, sinon elle retourne une valeur non zéro
' Les paramètres :
' hHeap% : handle du Heap
' dwFlags%
' IpMem% : Pointeur de la zone mémoire à libérer : ce pointeur a été retourné
' par la fonction HeapAlloc sous le nom pteur%
IpMem% = pteur%
free% = dll_call3("HeapFree",hHeap%,0,IpMem%)
if free% > 0
   print " Libération de la mémoire allouée OK"
else
   print " Echec de la libération de la mémoire allouée"
end_if

rem ============================================================================
m$ = ""
for i = 0 to len(t$) -1
   m$ = m$ + chr$(peek(pteur%+i))
next i
print " La preuve : ce n'est plus le même texte : " + m$
rem ===========================================================================

Oui peut être interessant. Je n'ai pas la culture nécessaire pour le moment pour en apprécier le potentiel. J'attends de voir les réactions et les propositions d'applications potentielles. Elles existent surement et ce sera sans doute pratique à ces fins.

Excellent, Papydall ! Bien sûr que ça peut servir ! Tu peux t'en servir un peu comme un disque virtuel en mémoire, par exemple. Avec un accès ultra-rapide. Par contre, il faut abandonner les moyens Panoramic comme PEEK et POKE qui sont certes fonctionnels, mais qui ne marchent que sur un octet à la fois et sont TRES lents !

Cherche des fonctions comme CopyMemory(dest%,org%,count%).
dest% est un pointeur vers la zone de mémoire de destination. Ca peut être adr(a$) ou une adresse dans le heap.
org% est un pointeur vers la zone de mémoire d'origine. Ca peut être adr(a$) ou une adresse dans le heap.
count% est le nombre d'octets à transférer.

dest% et org% peuvent tous deux être un adr(x$) (adresse d'une variable Panoramic), ou tous deux une adresse dans le heap. Tu peux ainsi copier en une seule opération un grand nombre d'octets, et c'est uttra-rapide. Mais surtout, ne te trompe pas d'adresse ni de nombre d'octets, sous peine de violation de mémoire...

En tout cas, c'est excellent et je vais me le garder soigneusement !

EDIT

En fait, dans Kernel32.dll, il y a RtlMoveMemory avec exactement les mêmes paramètres que CopyMemory. CopyMemory n'est qu'un synonyme. Donc, dans la même DLL, tu as tout ce qu'il faut...

Merci Klaus.
En me baladant quelque part dans le virtuel, j’ai atterri sur ce terrain .

allouer - Allouer un bloc de mémoire dans le Heap Images13

Puis à la lettre H j’ai eu un rendez-vous avec HeapAlloc / HeapFree ….
J’ai voulu savoir si je peux faire la traduction vers Panoramic et voilà, c’est tout.

En plus, ton lien est très intéressant ! Merci encore pour ce partage !

J'ai repris ton code, en remplaçant les boucles PEEK et POKE par un seul appel à RtlMoveMemory. La seule chose à savoir, c'est que adr(a$) ne donne pas l'adresse des données de la variable a$, mais l'adresse d'un pointeur vers les données de a$ ! En fait, adr(a$) pointe vers un PSTRING en notation Delphi. Il faut donc faire un premier RtlMoveMemory de 4 octets pour récupérer la vraie adresse des données, puis un second pour la véritable copie. C'est fait dans cette version du code. Et pour montrer l'effet de la copie, j'ai initalisé m$ (la destination de la relecture) par 30 caractères "#". Voici:

Code:: rem ============================================================================
rem Allouer un bloc de mémoire dans le Heap (tas)
rem ============================================================================
rem klaus: RtlMoveMemory(pdest,porg,cnt) dans Kernel32.dll
rem ============================================================================

dim hHeap% : ' Handle du Heap
dim pteur% : ' Pointeur vers la mémoire allouée
dim NbOctets% : NbOctets% = 100 : ' Nombre d'octets à allouer
DIM IpMem% : ' Pointeur de la zone mémoire à libérer
dim free% : ' Résultat de la fonction de libération de la mémoire
dim t$ : t$ = "Salut tout le monde"
dim i,m$, res%, adr_t%, adr_m%
top 0, 100 : left 0,300 : height 0, 150
dll_on "kernel32.dll"
rem ============================================================================
' Obtenir le handle du heap du process appelé
hHeap% = dll_call0("GetProcessHeap")
print : print " Handle du Heap : " + str$(hHeap%)
rem ============================================================================
' Allouer un bloc de mémoire à partir du heap
' En cas de succès, retourne un pointeur vers la mémoire allouée
' Sinon retourne la valeur NULL
' Les paramètres d'appel sont :
' hHeap% : handle du heap à partir duquel la mémoire peut être allouée
' dwFlags% : pour contrôl : la valeur 0 pour initialiser la mémoire allouée à zéro
' dwBytes% : nombre d'octets à allouer
pteur% = dll_call3("HeapAlloc",hHeap%,0,NbOctets%)
print " Pointeur vers la mémoire allouée de " + str$(NbOctets%) + " Octets : " + str$(pteur%)
rem ===========================================================================
' Ecrire un texte dans le bloc de la mémoire allouée
print " J'écris un texte dans la mémoire allouée : " + t$
' for i = 0 to len(t$) -1
' poke pteur% + i ,asc(mid$(t$,i+1,1))
' next i
' Lire le texte à partie de la mémoire allouée
res% = dll_call3("RtlMoveMemory",adr(adr_t%),adr(t$),4)
res% = dll_call3("RtlMoveMemory",pteur%,adr_t%,len(t$))

' for i = 0 to len(t$) -1
' m$ = m$ + chr$(peek(pteur%+i))
' next i
m$ = string$(30,"#")
res% = dll_call3("RtlMoveMemory",adr(adr_m%),adr(m$),4)
res% = dll_call3("RtlMoveMemory",adr_m%,pteur%,len(t$))
print " Je récupère mon texte à partir de la mémoire allouée : " + m$

rem ===========================================================================
' Libérer le bloc de mémoire allouée
' Si la fonction échoue, elle retourne 0, sinon elle retourne une valeur non zéro
' Les paramètres :
' hHeap% : handle du Heap
' dwFlags%
' IpMem% : Pointeur de la zone mémoire à libérer : ce pointeur a été retourné
' par la fonction HeapAlloc sous le nom pteur%
IpMem% = pteur%
free% = dll_call3("HeapFree",hHeap%,0,IpMem%)
if free% > 0
   print " Libération de la mémoire allouée OK"
else
   print " Echec de la libération de la mémoire allouée"
end_if

rem ============================================================================
m$ = ""
for i = 0 to len(t$) -1
   m$ = m$ + chr$(peek(pteur%+i))
next i
print " La preuve : ce n'est plus le même texte : " + m$
rem ===========================================================================

Papydall, c'est super. Ca ouvre de nouveaux horizons: on peut mettre des bitmaps en mémoire, des textes, des tableaux de valeurs entières etc. Tu ouvres ainsi une mémoire de stockage librement formattable, et de dimensions libres. Bravo !

EDIT

D'ailleurs, une fois que tu es connecté sur le heep, tu peu appeler HeapAlloc plusieurs fois pour allouer plusieurs portions de mémoire, de tailles différentes ! Seule précaution à prendre: bien veiller à libérer toute cette mémoire lorsqu'elle n'est plus nécessaire !

Merci Klaus.
Tes compliments ça me touche énormément !
J’espère que toi (mille et une fois plus doué que moi), tu en sortiras des choses intéressantes pour en faire profiter tout le monde.

J'ai hate de lire la suite. Si ça peut signifier la fin des créations de fichiers temporaires sur le disque et l'usage de la mémoire àla place, en effet, ce serait très utile.

Oui, et ce n'est qu'une des applications possibles ! Il faut que je prenne un peu de recul pour voir ce qu'on peut faire et ne pas faire avec cet outil. Ce qui est certain, c'est que c'est très puissant.

jicehel a écrit:: J'ai hate de lire la suite. Si ça peut signifier la fin des créations de fichiers temporaires sur le disque et l'usage de la mémoire àla place, en effet, ce serait très utile.

Hé, jeune homme ! Du calme ! Laughing

Maître Klaus veut prendre un peu de recul pour voir, alors patiente un peu tout en frottant les mains : ça risque de devenir sérieux ! (mais on est encore dans les inutilitaires).
Avec Klaus, on s’attend à tout.

Une première application:
la sauvegarde complète d'un tableau d'entiers en un seul appel de la fonction RtlMoveMemory. Dans mon cas, le tableau fait 5 entiers: dim array%(4), il prend donc 5*4=20 octets. Je charge le tableau avec les 5 premiers nombres primaires, je le copie dans le heap, je l'efface, puis je le relis du heap - bingo !

Code:: rem ============================================================================
rem Allouer un bloc de mémoire dans le Heap (tas)
rem ============================================================================
rem klaus: RtlMoveMemory(pdest,porg,cnt) dans Kernel32.dll
rem ============================================================================

dim hHeap% : ' Handle du Heap
dim pteur% : ' Pointeur vers la mémoire allouée
dim NbOctets% : NbOctets% = 100 : ' Nombre d'octets à allouer
DIM IpMem% : ' Pointeur de la zone mémoire à libérer
dim free% : ' Résultat de la fonction de libération de la mémoire
dim t$ : t$ = "Salut tout le monde"
dim i,m$, res%, adr_t%, adr_m%, array%(4)
array%(0) = 1 : array%(1) = 3 : array%(2) = 5 : array%(3) = 7 : array%(4) = 11
top 0, 100 : left 0,300 : height 0, 150
dll_on "kernel32.dll"
rem ============================================================================
' Obtenir le handle du heap du process appelé
hHeap% = dll_call0("GetProcessHeap")
print : print " Handle du Heap : " + str$(hHeap%)
rem ============================================================================
' Allouer un bloc de mémoire à partir du heap
' En cas de succès, retourne un pointeur vers la mémoire allouée
' Sinon retourne la valeur NULL
' Les paramètres d'appel sont :
' hHeap% : handle du heap à partir duquel la mémoire peut être allouée
' dwFlags% : pour contrôl : la valeur 0 pour initialiser la mémoire allouée à zéro
' dwBytes% : nombre d'octets à allouer
pteur% = dll_call3("HeapAlloc",hHeap%,0,NbOctets%)
print " Pointeur vers la mémoire allouée de " + str$(NbOctets%) + " Octets : " + str$(pteur%)
rem ===========================================================================
' Ecrire un texte dans le bloc de la mémoire allouée
print " J'écris un texte dans la mémoire allouée : " + t$
' for i = 0 to len(t$) -1
' poke pteur% + i ,asc(mid$(t$,i+1,1))
' next i
' Lire le texte à partie de la mémoire allouée
res% = dll_call3("RtlMoveMemory",adr(adr_t%),adr(t$),4)
res% = dll_call3("RtlMoveMemory",pteur%,adr_t%,len(t$))

' for i = 0 to len(t$) -1
' m$ = m$ + chr$(peek(pteur%+i))
' next i
m$ = string$(30,"#")
res% = dll_call3("RtlMoveMemory",adr(adr_m%),adr(m$),4)
res% = dll_call3("RtlMoveMemory",adr_m%,pteur%,len(t$))
print " Je récupère mon texte à partir de la mémoire allouée : " + m$

rem ===========================================================================
' ecrire un tableau de 5 mots
print " J'écris un tableau dans la mémoire allouée : " + str$(array%(0))+","+str$(array%(1))+","+str$(array%(2))+","+str$(array%(3))+","+str$(array%(4))
res% = dll_call3("RtlMoveMemory",pteur%,adr(array%),20)
array%(0) = 0 : array%(1) = 0 : array%(2) = 0 : array%(3) = 0 : array%(4) = 0
print " J'efface mon tableau dans Panoramic : " + str$(array%(0))+","+str$(array%(1))+","+str$(array%(2))+","+str$(array%(3))+","+str$(array%(4))
res% = dll_call3("RtlMoveMemory",adr(array%),pteur%,20)
print " Je récupère mon tableau à partir de la mémoire allouée : " + str$(array%(0))+","+str$(array%(1))+","+str$(array%(2))+","+str$(array%(3))+","+str$(array%(4))

rem ===========================================================================
' Libérer le bloc de mémoire allouée
' Si la fonction échoue, elle retourne 0, sinon elle retourne une valeur non zéro
' Les paramètres :
' hHeap% : handle du Heap
' dwFlags%
' IpMem% : Pointeur de la zone mémoire à libérer : ce pointeur a été retourné
' par la fonction HeapAlloc sous le nom pteur%
IpMem% = pteur%
free% = dll_call3("HeapFree",hHeap%,0,IpMem%)
if free% > 0
print " Libération de la mémoire allouée OK"
else
print " Echec de la libération de la mémoire allouée"
end_if

rem ============================================================================
m$ = ""
for i = 0 to len(t$) -1
m$ = m$ + chr$(peek(pteur%+i))
next i
print " La preuve : ce n'est plus le même texte : " + m$
rem ===========================================================================

end

Le tableau peut bien sûr avoir n'importe quelle taille, en 1 ou 2 dimensions, pourvu que le heap soit déclaré avec une taille suffisante et que le nombre d'octets soit calculé correctement. Et accessoirement, on voit que la fonction ADR() sur un tableau donne maintenant la bonne adresse !

Je vais faire d'autres essais...

Une autre application pourrait être de copier le canvas d'un picture dans le heap, puis dans un tableau d'entiers à 2 dimensions, sachant que chaque pixel sera défini par un mot du format 00RRGGBB. on pourra alors faire toutes les manipulations sur ce tableau, en mémoire, et pour finir, le recopier dans le heap, et de là, dans le canvas. Et même, si l'on n'a pas besoin de garder le canvas en mémoire (dans le heap), on peut copier directement du canvas dans un tableau et retour.

D'aileurs, la fonction RtlMoveMemory peut même servir à copier tout ou partie d'un tableau dans un autre, avec une seule ligne au lieu de faire une boucle:

Code:: dim org%(300,40) : dest%(300,40); res%
res% = dll_call3("RtlMoveMemory",adr(dest%),adr(org%),301*41*4)

Je pense que je vais intégrer ces fonctions dans KGF.dll. Certes, on peut y accéder directement par Kernel32.dll. Mais pour ceux qui utilisent KGF.dll, il serait utile de ne pas avoir à fermer KGF.dll pour utiliser Kernel32.dll et vice-versa.

Je suis vraiment content que tu t’en donnes à cœur joie ! cheers

EDIT
Agrandir le FORM 0 pour visualiser tous les PRINTs
Ligne 15

Code:: top 0, 100 : left 0,300 : height 0, 250

J'ai intégré ces fonctions dans KGF.dll. Regarde dans le fil de discussion sur les nouvelles versions de KGF.dll - il y a la doc provisoire. C'est la version V4.73 du 11/05/2015.

Et voici ton programme, capable de marcher, au choix, avec Kernel32.dll ou KGF.dll, en fonction de la variable KGF% définie en ligne 7:

Code:: rem ============================================================================
rem Allouer un bloc de mémoire dans le Heap (tas)
rem ============================================================================
rem klaus: RtlMoveMemory(pdest,porg,cnt) dans Kernel32.dll
rem ============================================================================

dim KGF% : KGF% = 1 : ' 0=Kernel32.dll 1=KGF.dll
dim hHeap% : ' Handle du Heap
dim pteur% : ' Pointeur vers la mémoire allouée
dim NbOctets% : NbOctets% = 100 : ' Nombre d'octets à allouer
DIM IpMem% : ' Pointeur de la zone mémoire à libérer
dim free% : ' Résultat de la fonction de libération de la mémoire
dim t$ : t$ = "Salut tout le monde"
dim i,m$, res%, adr_t%, adr_m%, array%(4)
array%(0) = 1 : array%(1) = 3 : array%(2) = 5 : array%(3) = 7 : array%(4) = 11
top 0, 100 : left 0,300 : height 0, 250
select KGF%
case 0: dll_on "kernel32.dll"
case 1: dll_on "KGF.dll"
end_select
rem ============================================================================
' Obtenir le handle du heap du process appelé
select KGF%
case 0: hHeap% = dll_call0("GetProcessHeap")
case 1: hHeap% = dll_call0("GetDynamicMemoryID")
end_select
print : print " Handle du Heap : " + str$(hHeap%)
rem ============================================================================
' Allouer un bloc de mémoire à partir du heap
' En cas de succès, retourne un pointeur vers la mémoire allouée
' Sinon retourne la valeur NULL
' Les paramètres d'appel sont :
' hHeap% : handle du heap à partir duquel la mémoire peut être allouée
' dwFlags% : pour contrôl : la valeur 0 pour initialiser la mémoire allouée à zéro
' dwBytes% : nombre d'octets à allouer
select KGF%
case 0: pteur% = dll_call3("HeapAlloc",hHeap%,0,NbOctets%)
case 1: pteur% = dll_call2("RequestDynamicMemory",hHeap%,NbOctets%)
end_select
print " Pointeur vers la mémoire allouée de " + str$(NbOctets%) + " Octets : " + str$(pteur%)
rem ===========================================================================
' Ecrire un texte dans le bloc de la mémoire allouée
print " J'écris un texte dans la mémoire allouée : " + t$
' for i = 0 to len(t$) -1
' poke pteur% + i ,asc(mid$(t$,i+1,1))
' next i
' Lire le texte à partie de la mémoire allouée
select KGF%
case 0
res% = dll_call3("RtlMoveMemory",adr(adr_t%),adr(t$),4)
res% = dll_call3("RtlMoveMemory",pteur%,adr_t%,len(t$))
case 1
res% = dll_call3("CopyDynamicMemory",adr(adr_t%),adr(t$),4)
res% = dll_call3("CopyDynamicMemory",pteur%,adr_t%,len(t$))
end_select

' for i = 0 to len(t$) -1
' m$ = m$ + chr$(peek(pteur%+i))
' next i
m$ = string$(30,"#")
select KGF%
case 0
res% = dll_call3("RtlMoveMemory",adr(adr_m%),adr(m$),4)
res% = dll_call3("RtlMoveMemory",adr_m%,pteur%,len(t$))
case 1
res% = dll_call3("CopyDynamicMemory",adr(adr_m%),adr(m$),4)
res% = dll_call3("CopyDynamicMemory",adr_m%,pteur%,len(t$))
end_select
print " Je récupère mon texte à partir de la mémoire allouée : " + m$

rem ===========================================================================
' ecrire un tableau de 5 mots
print " J'écris un tableau dans la mémoire allouée : " + str$(array%(0))+","+str$(array%(1))+","+str$(array%(2))+","+str$(array%(3))+","+str$(array%(4))
select KGF%
case 0: res% = dll_call3("RtlMoveMemory",pteur%,adr(array%),20)
case 1: res% = dll_call3("CopyDynamicMemory",pteur%,adr(array%),20)
end_select
array%(0) = 0 : array%(1) = 0 : array%(2) = 0 : array%(3) = 0 : array%(4) = 0
print " J'efface mon tableau dans Panoramic : " + str$(array%(0))+","+str$(array%(1))+","+str$(array%(2))+","+str$(array%(3))+","+str$(array%(4))
select KGF%
case 0: res% = dll_call3("RtlMoveMemory",adr(array%),pteur%,20)
case 1: res% = dll_call3("CopyDynamicMemory",adr(array%),pteur%,20)
end_select
print " Je récupère mon tableau à partir de la mémoire allouée : " + str$(array%(0))+","+str$(array%(1))+","+str$(array%(2))+","+str$(array%(3))+","+str$(array%(4))

rem ===========================================================================
' Libérer le bloc de mémoire allouée
' Si la fonction échoue, elle retourne 0, sinon elle retourne une valeur non zéro
' Les paramètres :
' hHeap% : handle du Heap
' dwFlags%
' IpMem% : Pointeur de la zone mémoire à libérer : ce pointeur a été retourné
' par la fonction HeapAlloc sous le nom pteur%
IpMem% = pteur%
select KGF%
case 0: free% = dll_call3("HeapFree",hHeap%,0,IpMem%)
case 1: free% = dll_call2("FreeDynamicMemory",hHeap%,IpMem%)
end_select
if free% > 0
print " Libération de la mémoire allouée OK"
else
print " Echec de la libération de la mémoire allouée"
end_if

rem ============================================================================
m$ = ""
for i = 0 to len(t$) -1
m$ = m$ + chr$(peek(pteur%+i))
next i
print " La preuve : ce n'est plus le même texte : " + m$
rem ===========================================================================

end

Testé et adopté !

» REM en bloc
» pour memoire
» J'ai la mémoire qui flanche...
» Ma pauvre mémoire
» copie images en mémoire