Zuordnung von Arrays in Chapel

Question

Im Gegensatz zu anderen Sprachen scheint keine allocate oder new Syntax in Chapel für die Zuweisung von Arrays auf dem Heap, sondern verwenden Sie die übliche "Deklaration" -ähnliche Syntax. Zum Beispiel in dem folgenden Code, ich "erklären" zwei Arrays A und B in einer Funktion auf der Grundlage formale (Dummy) Argumente:

proc test(n, D) 
{ 
    var A: [1..n] real; // local array 
    var B: [D] real;  // local array 

    writeln("A.domain = ", A.domain); 
    writeln("B.domain = ", B.domain); 
} 

test(3, {2..5});    // request small arrays 
test(10**7, {-10**7..10**7}); // request large arrays 

Dies ergibt folgendes Ergebnis:

A.domain = {1..3} 
B.domain = {2..5} 
A.domain = {1..10000000} 
B.domain = {-10000000..10000000} 

Da keine Stack-Überlauf tritt auf (trotz der großen Größe von B), ist es in Ordnung, davon auszugehen, dass die obige Syntax immer A und B auf dem Heap unabhängig von ihrer Größe zuweist?

Auch die Zuweisung (oder Neuzuweisung) einer Domänenvariable scheint die Rolle der Zuweisung (oder Neuzuordnung) eines Arrays zu spielen. Der folgende Code funktioniert beispielsweise wie erwartet. Findet die Zuordnung in diesem Fall immer wieder auf dem Heap statt?

var domC: domain(1); 
var C: [domC] real; 
writeln("C = ", C); 

domC = { 1..3 };  // assign a domain 
C = 7.0;    // assign some value to the array 
writeln("C = ", C); 

domC = { -1..5 };  // re-assign a domain 
writeln("C = ", C); 

Ergebnis:

C = 
C = 7.0 7.0 7.0 
C = 0.0 0.0 7.0 7.0 7.0 0.0 0.0 

Schließlich ist es nicht notwendig für den Benutzer zu deallocate oder delete diese Arrays manuell, sondern das System plant sie bei Bedarf automatisch?

Answer 1

Ist es OK anzunehmen, dass die obige Syntax immer A und B auf dem Heap unabhängig von ihrer Größe zuweist?

Bei Chapel 1.15.0 werden Chapel-Array-Elemente immer auf dem Heap zugewiesen. Wir haben das Hinzufügen von Mechanismen (z. B. benutzerdefinierte Domänenzuordnungen) oder möglicherweise Optimierungen, die zum Speichern von Array-Elementen auf dem Stack verwendet werden können, wenn dies angebracht ist, besprochen, aber diese Funktionen noch nicht verfolgt. Beachten Sie, dass während die Elemente des Arrays auf dem Heap zugeordnet sind, Arrays auch unter Verwendung eines Laufzeitdeskriptors implementiert werden, der "in-place" zugeordnet ist (z. B. auf dem Stapel in Ihren Beispielen) --- dieser Deskriptor bezieht sich auf die Heap-allokierten Elemente .

Auch die Zuweisung (oder Neuzuweisung) einer Domänenvariable scheint die Rolle der Zuweisung (oder Neuzuweisung) eines Arrays zu spielen.

Das ist richtig, und es ist Betonung wert, dass dies ein logisch statt physisch orientierte Begriff der Umverteilung. Wenn die Domäne eines Arrays neu zugewiesen wird, speichert A[i] weiterhin den gleichen Wert, wenn sich i sowohl in den Indexsätzen der alten als auch der neuen Domäne befand. Aus diesem Grund wurde domC von {1..3} zu {-1..5} in Ihrem Code oben A[1..3] beibehalten, da es die Schnittmenge der beiden Sätze darstellt.

tritt die Zuweisung immer auf dem Heap (wieder) auf?

Ja, wie bei einer anfänglichen Array-Zuweisung.

Muss der Benutzer diese Arrays nicht manuell freigeben oder löschen, sondern das System automatisch nach Bedarf freigeben?

Das ist richtig, Array-Speicherverwaltung wird in der Regel von der Implementierung behandelt. Eine Möglichkeit, Array-Speicher manuell zu verwalten, wäre eine Klassenvariable mit einem Array-Feld (da Klassen manuell verwaltet werden).