FORUM DE DISCUSSION SUR LE LANGAGE PANORAMIC

Développement d'applications avec le langage Panoramic
 
AccueilAccueil  FAQFAQ  RechercherRechercher  S'enregistrerS'enregistrer  MembresMembres  GroupesGroupes  Connexion  
Derniers sujets
» un nouveau editeur panobasic
par Jean Claude Aujourd'hui à 10:18

» Compilateur FBPano
par jean_debord Aujourd'hui à 10:07

» Le compilateur.
par Pedro Alvarez Aujourd'hui à 8:36

» COMPILATEUR V 0.9 beta 7 du 10 aout 2017
par Jack Hier à 20:23

» Pb 16 (en analyse): ON_CLOSE plante à l'exécution
par Jack Hier à 20:00

» Pb 15 (en analyse): TIMER_ON plante à l'exécution
par Jack Hier à 19:58

» KGF_dll - nouvelles versions
par Yannick Dim 13 Aoû 2017 - 17:35

» probleme d'outil
par Yannick Dim 13 Aoû 2017 - 17:32

» Carte de France des régions
par Yannick Sam 12 Aoû 2017 - 21:33

» Pb 14 (en analyse): PRINT_LOCATE plante à l'exécution
par Jack Ven 11 Aoû 2017 - 22:37

» Petit avertissement [Mots réservés]
par papydall Ven 11 Aoû 2017 - 13:45

» Distances sur plan
par JL35 Jeu 10 Aoû 2017 - 21:29

» Tracé : Triangle, Carrée, Dents de scie, Sinusoïde redressée
par papydall Jeu 10 Aoû 2017 - 14:52

» Troncature dans une image
par JL35 Mer 9 Aoû 2017 - 13:45

» A chacun son point de vue
par papydall Mar 8 Aoû 2017 - 17:20

Navigation
 Portail
 Index
 Membres
 Profil
 FAQ
 Rechercher
Rechercher
 
 

Résultats par :
 
Rechercher Recherche avancée
Août 2017
LunMarMerJeuVenSamDim
 123456
78910111213
14151617181920
21222324252627
28293031   
CalendrierCalendrier

Partagez | 
 

  Allouer un bloc de mémoire dans le Heap

Voir le sujet précédent Voir le sujet suivant Aller en bas 
AuteurMessage
papydall

avatar

Nombre de messages : 5501
Age : 67
Localisation : Moknine (Tunisie) Entre la chaise et le clavier
Date d'inscription : 03/03/2012

MessageSujet: Allouer un bloc de mémoire dans le Heap    Dim 10 Mai 2015 - 21:56

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.

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 ===========================================================================
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://papydall-panoramic.forumarabia.com/
Jicehel

avatar

Nombre de messages : 5849
Age : 45
Localisation : 77500
Date d'inscription : 19/04/2011

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Dim 10 Mai 2015 - 22:00

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.


Dernière édition par Jicehel le Lun 11 Mai 2015 - 0:26, édité 1 fois
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Klaus

avatar

Nombre de messages : 10062
Age : 68
Localisation : Ile de France
Date d'inscription : 29/12/2009

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Dim 10 Mai 2015 - 23:41

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...
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://klauspanoramic.comxa.com/index.html
papydall

avatar

Nombre de messages : 5501
Age : 67
Localisation : Moknine (Tunisie) Entre la chaise et le clavier
Date d'inscription : 03/03/2012

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 0:03

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

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.
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://papydall-panoramic.forumarabia.com/
Klaus

avatar

Nombre de messages : 10062
Age : 68
Localisation : Ile de France
Date d'inscription : 29/12/2009

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 0:13

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 !
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://klauspanoramic.comxa.com/index.html
papydall

avatar

Nombre de messages : 5501
Age : 67
Localisation : Moknine (Tunisie) Entre la chaise et le clavier
Date d'inscription : 03/03/2012

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 0:27

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.


Dernière édition par papydall le Lun 11 Mai 2015 - 0:30, édité 1 fois
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://papydall-panoramic.forumarabia.com/
Jicehel

avatar

Nombre de messages : 5849
Age : 45
Localisation : 77500
Date d'inscription : 19/04/2011

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 0:29

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.
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Klaus

avatar

Nombre de messages : 10062
Age : 68
Localisation : Ile de France
Date d'inscription : 29/12/2009

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 0:36

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.
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://klauspanoramic.comxa.com/index.html
papydall

avatar

Nombre de messages : 5501
Age : 67
Localisation : Moknine (Tunisie) Entre la chaise et le clavier
Date d'inscription : 03/03/2012

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 0:53

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.
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://papydall-panoramic.forumarabia.com/
Klaus

avatar

Nombre de messages : 10062
Age : 68
Localisation : Ile de France
Date d'inscription : 29/12/2009

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 2:14

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...
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://klauspanoramic.comxa.com/index.html
Klaus

avatar

Nombre de messages : 10062
Age : 68
Localisation : Ile de France
Date d'inscription : 29/12/2009

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 2:23

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.
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://klauspanoramic.comxa.com/index.html
Klaus

avatar

Nombre de messages : 10062
Age : 68
Localisation : Ile de France
Date d'inscription : 29/12/2009

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 2:43

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)

Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://klauspanoramic.comxa.com/index.html
Klaus

avatar

Nombre de messages : 10062
Age : 68
Localisation : Ile de France
Date d'inscription : 29/12/2009

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 2:53

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.
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://klauspanoramic.comxa.com/index.html
papydall

avatar

Nombre de messages : 5501
Age : 67
Localisation : Moknine (Tunisie) Entre la chaise et le clavier
Date d'inscription : 03/03/2012

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 3:42

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
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://papydall-panoramic.forumarabia.com/
Klaus

avatar

Nombre de messages : 10062
Age : 68
Localisation : Ile de France
Date d'inscription : 29/12/2009

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 4:38

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
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://klauspanoramic.comxa.com/index.html
papydall

avatar

Nombre de messages : 5501
Age : 67
Localisation : Moknine (Tunisie) Entre la chaise et le clavier
Date d'inscription : 03/03/2012

MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    Lun 11 Mai 2015 - 5:18

Testé et adopté !
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://papydall-panoramic.forumarabia.com/
Contenu sponsorisé




MessageSujet: Re: Allouer un bloc de mémoire dans le Heap    

Revenir en haut Aller en bas
 
Allouer un bloc de mémoire dans le Heap
Voir le sujet précédent Voir le sujet suivant Revenir en haut 
Page 1 sur 1
 Sujets similaires
-
» Réduire la largeur du bloc "profil" dans les messages postés
» Etrex 20 - Faut il une carte dans le GPS ou peut-on toutes les mettre sur la carte microSD ?
» Ajout carte sur carte mémoire SD
» Libérer de l'espace mémoire dans un nuvï
» Garder une sprite en mémoire dans une sauvegarde ?

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
FORUM DE DISCUSSION SUR LE LANGAGE PANORAMIC :: PANORAMIC 32 bits :: Les inutilitaires-
Sauter vers: