Aller au contenu principal

Gestion de la mémoire

Raml fournit une gestion manuelle de la mémoire avec allocation sur le tas, types pointeurs et libération explicite. Il n'y a pas de garbage collector.


Aperçu​

Cette section couvre les bases dont vous avez besoin pour allouer, utiliser les pointeurs, et libérer de la mémoire en Raml.

Allocation avec make​

Allocation sur la pile (par défaut) :

node:
value
bs# next

:start:
n = make node 42 // pile, initialisé à zéro puis value=42

make objet args initialise tous les champs à zéro, puis assigne les arguments positionnels aux champs dans l'ordre.

Allocation sur le tas avec auto :

n = make node 42 auto // tas via raml_alloc()

Initialisation vide (sans arguments) :

rpt = make report // tous les champs = 0

Types pointeurs​

TypeSyntaxeExemple
Pointeur bitstreambs#bs# p = @x
Pointeur objet typéname#node# np = @n

Opérations de base​

OpérationSyntaxeFonction
Address-of@varObtenir l'adresse mémoire
Déréférencement#ptrLire la valeur à l'adresse
Affectation d'adresseptr #= @varChanger la cible du pointeur
Égalité d'adressesp =#= qComparer deux pointeurs
Pas élémentptr += nAvancer de n × sizeof(élément)
Pas bit brutptr +#= nAvancer de n octets bruts
Libérationfree varLibérer la mémoire tas

Notes de sécurité​

  • Pas de garbage collector : Toute allocation tas doit être libérée explicitement.
  • Utilisation après libération : Accéder à la mémoire après free est un comportement indéfini.
  • Pile vs tas : Les allocations sur la pile sont automatiquement nettoyées à la sortie du scope.
  • Validité des pointeurs : Le compilateur ne vérifie pas la validité des pointeurs à la compilation.

Plongée Technique​

Cette section couvre les détails internes — modèle mémoire, mapping de code C, détails d'arithmétique des pointeurs, et cas limites.

Modèle mémoire​

Pile : Variables locales, copies de struct (sans auto)
→ Allouées comme variables locales C sur la pile d'appel
→ Durée de vie : scope du bloc englobant

Tas : Copies de struct (avec auto)
→ Allouées via raml_alloc() (wrapper autour de malloc)
→ Durée de vie : jusqu'à l'appel free()

Globales : Variables de premier niveau (hors de tout bloc)
→ Allouées comme variables globales C
→ Durée de vie : toute l'exécution du programme

Mapping de code C​

Opération RamlSortie C
make T argsstruct T_t var = { .field1 = arg1, ... };
make T args autostruct T_t* var = raml_alloc(sizeof(struct T_t)); var->field1 = arg1; ...
@var&var
#ptr*ptr
ptr #= @varptr = &var
p =#= qp == q
ptr += nptr += n
ptr +#= n(void*)((char*)ptr + n)
free varraml_free(var)
node:fieldnode.field (accès direct)
node#:fieldnode->field (accès par pointeur)

Accès aux champs via les pointeurs​

Quand on accède aux champs d'un objet via un pointeur, le générateur de code utilise automatiquement -> au lieu de . :

node# np = @n
np:value // génère np->value
np:next:value // chaînage de pointeurs (np->next->value)

Arithmétique des pointeurs : pas élément vs pas bit brut​

ptr += n (pas par taille d'élément) : Avance le pointeur de n × sizeof(*ptr). C'est l'arithmétique de pointeurs standard en C. Quand ptr est de type bs#, la taille d'élément est de 1 octet.

bs# p = @arr
p += 1 // avance de sizeof(uint8_t) = 1 octet

ptr +#= n (décalage d'octet brut) : Avance le pointeur de n octets bruts (non multiplié par la taille d'élément). Implémenté comme une arithmétique de pointeur void* :

ptr = (typeof(ptr))((void*)((char*)ptr + n))

Utile pour traverser des structures de données au niveau bit quand on veut un contrôle au niveau octet indépendamment du type sous-jacent.

Règles de durée de vie et de possession​

Le vérificateur d'emprunt (analysis/borrow.py) applique ces règles à la compilation :

  1. Les allocations tas doivent être libérées : chaque make ... auto doit avoir un free correspondant dans tous les chemins de contrôle.
  2. Pas de double libération : free sur un pointeur déjà libéré est une erreur à la compilation.
  3. Pas d'utilisation après libération : Lecture/écriture via un pointeur après sa libération est une erreur à la compilation.
  4. Les références de pile ne doivent pas fuir : Un pointeur vers une variable de pile (@local_var) ne peut pas être retourné par une fonction ou assigné à une variable de plus grande durée de vie.
  5. Source du pointeur : On ne peut déréférencer un pointeur bs# que s'il pointe vers de la mémoire vivante valide.

À l'intérieur de l'allocation tas​

raml_alloc et raml_free sont des wrappers minces :

void* raml_alloc(size_t size) {
void* ptr = calloc(1, size); // initialisation à zéro
if (!ptr) { /* erreur */ exit(1); }
return ptr;
}
void raml_free(void* ptr) { free(ptr); }

calloc garantit l'initialisation à zéro, correspondant à la sémantique de Raml où make remet toujours les champs à zéro avant d'assigner les arguments du constructeur.

À l'intérieur de l'allocation pile​

Sans auto, make T args génère :

struct T_t var = {0}; // initialisation à zéro
var.field1 = arg1; // assignation positionnelle
var.field2 = arg2;

La struct est une variable locale, donc elle est automatiquement libérée à la sortie du bloc englobant.

Alignement dans la disposition des structs​

Les champs de struct sont disposés séquentiellement avec les règles d'alignement de l'ABI C. Le générateur de code calcule les décalages de champs en fonction de leurs tailles de type C :

Largeur champ (bits)Type CAlignementMultiple de décalage
0–8uint8_t1 octet1
9–16uint16_t2 octets2
17–32uint32_t4 octets4
33–64uint64_t8 octets8

L'alignement global de la struct est l'alignement maximum de tout champ.

Cas limites​

  • free comme déclaration multiple : free n1 n2 n3 libère plusieurs allocations en une seule instruction.
  • free sur de la mémoire non-tas : Erreur à la compilation détectée par le vérificateur d'emprunt.
  • Pointeur pendant après free : Non détecté à la compilation si le pointeur a été obtenu avant free. Comportement indéfini à l'exécution.
  • Pointeurs nuls : bs# p = 0 crée un pointeur nul. Le déréférencer provoque un crash à l'exécution.