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
» KGF_dll - nouvelles versions
par Klaus Aujourd'hui à 23:33

» KGF.dll - demandes ou suggestions de modifications ou ajouts
par Pedro Alvarez Aujourd'hui à 22:45

» StratégoV8
par Jean Claude Aujourd'hui à 19:55

» probleme de touche (verr num)
par pascal10000 Aujourd'hui à 16:20

» Mah-Jong européen new-look
par jjn4 Aujourd'hui à 15:58

» track_bar circulaire
par Klaus Hier à 21:41

» Gestionnaire de Projets Panoramic
par Jean Claude Hier à 20:41

» Gestion de l'Unicode
par jean_debord Hier à 11:21

» Button_picture
par pascal10000 Jeu 14 Déc 2017 - 11:41

» Pourquoi le compilateur stagne
par Minibug Jeu 14 Déc 2017 - 11:09

» 4 (en analyse): SYNEDIT_TARGET_IS_OBJECT devient inactif
par Jack Jeu 14 Déc 2017 - 10:09

» 3 (en analyse): Mauvaise interprétation du string "THEN"
par Jack Jeu 14 Déc 2017 - 10:03

» API Windows
par Klaus Mar 12 Déc 2017 - 3:21

» Cartes de voeux, menus, etc.
par JL35 Lun 11 Déc 2017 - 17:48

» a l'aide klaus
par Minibug Lun 11 Déc 2017 - 11:42

Navigation
 Portail
 Index
 Membres
 Profil
 FAQ
 Rechercher
Rechercher
 
 

Résultats par :
 
Rechercher Recherche avancée
Décembre 2017
LunMarMerJeuVenSamDim
    123
45678910
11121314151617
18192021222324
25262728293031
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 : 5613
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 : 5865
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 : 10275
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 En ligne
papydall

avatar

Nombre de messages : 5613
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 : 10275
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 En ligne
papydall

avatar

Nombre de messages : 5613
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 : 5865
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 : 10275
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 En ligne
papydall

avatar

Nombre de messages : 5613
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 : 10275
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 En ligne
Klaus

avatar

Nombre de messages : 10275
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 En ligne
Klaus

avatar

Nombre de messages : 10275
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 En ligne
Klaus

avatar

Nombre de messages : 10275
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 En ligne
papydall

avatar

Nombre de messages : 5613
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 : 10275
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 En ligne
papydall

avatar

Nombre de messages : 5613
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
-
» 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 ?
» GPS embarqué sur Goldwing 2012 (Garmin)

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