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
| Type | Syntaxe | Exemple |
|---|---|---|
| Pointeur bitstream | bs# | bs# p = @x |
| Pointeur objet typé | name# | node# np = @n |
Opérations de base
| Opération | Syntaxe | Fonction |
|---|---|---|
| Address-of | @var | Obtenir l'adresse mémoire |
| Déréférencement | #ptr | Lire la valeur à l'adresse |
| Affectation d'adresse | ptr #= @var | Changer la cible du pointeur |
| Égalité d'adresses | p =#= q | Comparer deux pointeurs |
| Pas élément | ptr += n | Avancer de n × sizeof(élément) |
| Pas bit brut | ptr +#= n | Avancer de n octets bruts |
| Libération | free var | Libé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
freeest 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 Raml | Sortie C |
|---|---|
make T args | struct T_t var = { .field1 = arg1, ... }; |
make T args auto | struct T_t* var = raml_alloc(sizeof(struct T_t)); var->field1 = arg1; ... |
@var | &var |
#ptr | *ptr |
ptr #= @var | ptr = &var |
p =#= q | p == q |
ptr += n | ptr += n |
ptr +#= n | (void*)((char*)ptr + n) |
free var | raml_free(var) |
node:field | node.field (accès direct) |
node#:field | node->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 :
- Les allocations tas doivent être libérées : chaque
make ... autodoit avoir unfreecorrespondant dans tous les chemins de contrôle. - Pas de double libération :
freesur un pointeur déjà libéré est une erreur à la compilation. - Pas d'utilisation après libération : Lecture/écriture via un pointeur après sa libération est une erreur à la compilation.
- 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. - 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 C | Alignement | Multiple de décalage |
|---|---|---|---|
| 0–8 | uint8_t | 1 octet | 1 |
| 9–16 | uint16_t | 2 octets | 2 |
| 17–32 | uint32_t | 4 octets | 4 |
| 33–64 | uint64_t | 8 octets | 8 |
L'alignement global de la struct est l'alignement maximum de tout champ.
Cas limites
freecomme déclaration multiple :free n1 n2 n3libère plusieurs allocations en une seule instruction.freesur 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 avantfree. Comportement indéfini à l'exécution. - Pointeurs nuls :
bs# p = 0crée un pointeur nul. Le déréférencer provoque un crash à l'exécution.