Cappella: Matrice di array contro matrice 2-dim in memoria - array, cappella

In Chapel, sembra possibile dichiarare un array usando la notazione [][]. Questo sembra molto simile a "array di array" inaltri linguaggi, quindi mi chiedo se si tratta di un cosiddetto "array frastagliato" con ogni sub-array allocato indipendentemente nella memoria? Ad esempio, nel seguente codice, lo sono a[0][..] e a[1][..] non necessariamente contiguo in memoria? (Il mio interesse qui è se l'uso di tale [][] potrebbe essere meno efficiente di [,] a causa della memoria non contigua.)

proc test( D1, D2 )
{
var a: [D1][D2] int;   // "jagged" array?
var b: [D1, D2] int;   // I assume this is a rectanguar (contiguous) array

for i in D1 do
for j in D2 do
a[i][j] = i * 100 + j;

for (i, j) in b.domain do
b[i, j] = i * 100 + j;

var lo = D1.low, hi = D1.high;

writeln( "a = ", a );
writeln( "a[ lo ] = ", a[ lo ] );
writeln( "a[ hi ] = ", a[ hi ] );
writeln();
writeln( "b = ", b );
writeln( "b[ lo, .. ] = ", b[ lo, .. ] );
writeln( "b[ hi, .. ] = ", b[ hi, .. ] );
}

test( 0..1, 1..3 );

$ chpl test.chpl
$ ./a.out

a = 1 2 3 101 102 103
a[ lo ] = 1 2 3
a[ hi ] = 101 102 103

b = 1 2 3
101 102 103
b[ lo, .. ] = 1 2 3
b[ hi, .. ] = 101 102 103

Una domanda correlata è: Esiste un modo o un comando per conoscere la posizione di memoria (indirizzo) di una determinata variabile o elemento di matrice (per ottenere informazioni sull'allocazione della memoria)?

risposte:

Sei corretto per una serie di array in Chapel (var A: […][…] …) ciascuno dei sotto-array sarà memorizzatoindipendentemente e quindi potrebbero non essere contigui in memoria (anche se potrebbero esserlo, a seconda di dove li colloca l'allocatore). Indipendentemente dal fatto che siano contigui, è necessaria un'ulteriore indiretta per raggiungere i sotto-array.

L'implementazione di una matrice multidimensionale (var A: […, …] …) è governato dalla sua mappa di dominio che controlla il modo in cui gli elementi sono memorizzati nella memoria. La mappa di dominio predefinita memorizza gli array multidimensionali in modo contiguo nella memoria.

Probabilmente la forma dell'array sarà più efficientedipende dallo stile di calcolo che scrivi e dal sistema su cui stai lavorando. Ma, come esempio specifico, se si dovesse accedere in serie agli elementi dell'array, l'array multidimensionale normalmente sovraperformerebbe l'array di array a causa delle sue posizioni di memoria contigue, come si nota.

A Chapel non piace esporre molto gli indirizzi, ma se ti affidi ad alcune delle funzionalità di interoperabilità, puoi determinare dove vivono le cose. Ad esempio, utilizza il seguente programma c_ptrTo() per ottenere un puntatore C su alcuni elementi dell'array e poi printf() per stampare quei luoghi fuori:

use CPtr;

config const n = 3;

var A: [1..n][1..n] real;

var a11 = c_ptrTo(A[1][1]),
a12 = c_ptrTo(A[1][2]),
a21 = c_ptrTo(A[2][1]);

var B: [1..n, 1..n] real;

var b11 = c_ptrTo(B[1,1]),
b12 = c_ptrTo(B[1,2]),
b21 = c_ptrTo(B[2,1]);

extern proc printf(x...);

printf("%p %p %pn", a11, a12, a21);
printf("%p %p %pn", b11, b12, b21);