Come sarebbe un linguaggio in cui GC preciso fosse implementabile come libreria?

Supponiamo di avere un linguaggio di programmazione con la gestione manuale della memoria. Quali caratteristiche deve avere questo linguaggio per poter implementare la garbage collection precisa come libreria e non come costrutto linguistico fondamentale?

Per GC preciso intendo uno in cui vengono attraversati solo i puntatori all'heap per accertare quali variabili sono o non sono attive.

Alcune considerazioni aggiuntive:

• C e C ++ hanno il Gare Collector Boehm, ma non lo conto poiché non è un GC preciso. Il raccoglitore Boehm presume che qualsiasi cosa nello stack che potrebbe essere un puntatore, basato esclusivamente sui requisiti di allineamento della memoria, sia un puntatore. Ad esempio, qualsiasi numero intero kche (k % 4) == 0assomigli a un livello di bit come un puntatore, poiché i puntatori devono essere allineati a 4 byte.
• magpie trasforma il codice C esistente per utilizzare un preciso garbage collector. Il codice C generato ha molti stub per la garbage collection, vale a dire cose per la registrazione di qualsiasi puntatore dello stack nell'heap con il raccoglitore. Non lo conto perché non ci si può aspettare che nessuno scriva codice in quel modo; è più un obiettivo di compilazione per altre lingue.

Immagino che una tale lingua dovrebbe avere:

1. Macro o qualche forma di metaprogrammazione, per incapsulare tutto il codice aggiuntivo necessario per fare cose come il registro delle radici GC.
2. Qualche meccanismo riflettente che consente di ispezionare strutture o sindacati; devi determinare quali membri sono puntatori.
3. Qualche meccanismo riflettente che ti consente di esaminare il layout della cornice dello stack. Sembra molto più difficile di 2.

Spero che questo non sia troppo vago o basato sull'opinione ma mi sto chiedendo da un po 'di tempo.

Credo che ciò sia possibile, o almeno quasi possibile, in una lingua come Rust, anche se forse non necessariamente nel senso che stai pensando.

Rust in realtà ha una libreria GC , anche se non posso dire quanto sia precisa. Ma l'idea è che esiste un tipo specifico Gc<T>per i puntatori raccolti in modo inutile a valori di tipo T. Quindi la metaprogrammazione di cui stai parlando non accade

Ciò che rende possibile che ciò sia preciso è il sistema di proprietà di Rust: a causa della tipizzazione lineare affine, ogni posizione in memoria ha al massimo un puntatore ad essa, a meno che non sia dichiarata usando un unsafeblocco (che viene utilizzato per implementare cose come il Garbage Collector) . Quindi, se hai un puntatore che non è racchiuso in un Gctipo, viene deallocato non appena esce dall'ambito. Quindi non è possibile considerare qualcosa come un puntatore che non lo è: o è racchiuso nel Gctipo o è di proprietà singola e automaticamente deallocato.

Ogni tipo ha un dropmetodo implicito che viene chiamato quando esce dal campo di applicazione, che disloca le cose a cui punta. Questo dropmetodo è consapevole di ciò che è e non è un puntatore, il che aiuta anche con precisione.

Il linguaggio è fortemente tipizzato staticamente e, a meno che non ci si trovi specificamente in un unsafeblocco, non è possibile trasmettere cose ad altri tipi, quindi si può sapere staticamente che tipo ha un dato blocco di memoria.

Questo non è un trasformatore drop-in che ti consente di trattare il codice non GC come Garbage Collection. Il programmatore specifica specificamente quali valori vengono raccolti. Ma dato ciò, penso che abbia il potenziale per soddisfare i tuoi criteri.

Penso che sia possibile implementare un garbage collector in C ++ senza cambiare la lingua stessa. Ma per usare il Garbage Collector, si deve impedire al programmatore di usare costrutti di linguaggio arbitrari. In particolare, tutte le richieste di allocazione della memoria devono essere eseguite tramite le API di allocazione fornite dal Garbage Collector e tutto l'accesso deve essere eseguito tramite riferimenti gestiti dal Garbage Collector.