Ich entwerfe eine Hochsprache, und ich möchte, dass sie die Geschwindigkeit von C++ hat (sie wird LLVM verwenden), aber sicher und hochrangig wie C# ist. Garbage Collection ist langsam, und new/delete ist unsicher. Ich habe beschlossen, "region based memory management" zu verwenden (es gibt ein paar Abhandlungen darüber im Internet, meist für funktionale Sprachen). Die einzige "nützliche" Sprache, die dies verwendet, ist Cyclone, aber die hat auch GC. Grundsätzlich werden Objekte auf einem lexikalischen Stack alloziert und wieder freigegeben, wenn der Block geschlossen wird. Objekte können nur auf andere Objekte in der gleichen oder einer höheren Region verweisen, um "Dangling References" zu vermeiden. Um dies flexibler zu gestalten, habe ich parallele Regionen hinzugefügt, die auf dem Stack nach oben und unten verschoben werden können und durch Schleifen beibehalten werden können. Das Typsystem wäre in den meisten Fällen in der Lage, Zuweisungen zu verifizieren, aber an einigen Stellen wären Laufzeitprüfungen mit geringem Aufwand erforderlich.
Ex:
region(A) {
Foo@A x=new Foo(); //x is deleted when this region closes.
region(B,C) while(x.Y) {
Bar@B n=new Bar();
n.D=x; //OK, n is in lower region than x.
//x.D=n; would cause error: x is in higher region than n.
n.DoSomething();
Bar@C m=new Bar();
//m.D=n; would cause error: m and n are parallel.
if(m.Y)
retain(C); //On the next iteration, m is retained.
}
}
Ist das praktisch? Müsste ich nicht-lexikalisch skalierte, referenzierte Regionen hinzufügen? Müsste ich schwache Variablen hinzufügen, die auf jedes beliebige Objekt verweisen können, aber mit einer Prüfung beim Löschen von Regionen? Fallen Ihnen Algorithmen ein, die mit diesem System nur schwer zu verwenden wären oder die undicht wären?