Perché System.arraycopy è nativo in Java?

Sono stato sorpreso di vedere nel codice sorgente Java che System.arraycopy è un metodo nativo.

Ovviamente il motivo è perché è più veloce. Ma quali trucchi nativi è in grado di utilizzare il codice per renderlo più veloce?

Perché non eseguire il ciclo sull'array originale e copiare ogni puntatore nel nuovo array - sicuramente questo non è così lento e macchinoso?

Nel codice nativo, può essere eseguito con una singola memcpy/ memmove, invece di n distinte operazioni di copia. La differenza di prestazioni è sostanziale.

Non può essere scritto in Java. Il codice nativo è in grado di ignorare o elidere la differenza tra array di Object e array di primitive. Java non può farlo, almeno non in modo efficiente.

E non può essere scritto con un singolo memcpy(), a causa della semantica richiesta dalla sovrapposizione di array.

Ovviamente dipende dall'implementazione.

HotSpot lo tratterà come un "intrinseco" e inserirà il codice nel sito della chiamata. Questo è il codice macchina, non il vecchio codice C. lento. Ciò significa anche che i problemi con la firma del metodo in gran parte scompaiono.

Un semplice ciclo di copia è abbastanza semplice da poter essere applicato a ovvie ottimizzazioni. Ad esempio lo svolgimento del ciclo. Ciò che accade esattamente dipende ancora dall'implementazione.

Nei miei test System.arraycopy () per la copia di array a più dimensioni è da 10 a 20 volte più veloce dell'interleaving per i loop:

float[][] foo = mLoadMillionsOfPoints(); // result is a float[1200000][9]
float[][] fooCpy = new float[foo.length][foo[0].length];
long lTime = System.currentTimeMillis();
System.arraycopy(foo, 0, fooCpy, 0, foo.length);
System.out.println("native duration: " + (System.currentTimeMillis() - lTime) + " ms");
lTime = System.currentTimeMillis();

for (int i = 0; i < foo.length; i++)
{
    for (int j = 0; j < foo[0].length; j++)
    {
        fooCpy[i][j] = foo[i][j];
    }
}
System.out.println("System.arraycopy() duration: " + (System.currentTimeMillis() - lTime) + " ms");
for (int i = 0; i < foo.length; i++)
{
    for (int j = 0; j < foo[0].length; j++)
    {
        if (fooCpy[i][j] != foo[i][j])
        {
            System.err.println("ERROR at " + i + ", " + j);
        }
    }
}

Questo stampa:

System.arraycopy() duration: 1 ms
loop duration: 16 ms

Ci sono alcuni motivi:

1. È improbabile che JIT generi un codice di basso livello efficiente come un codice C scritto manualmente. L'utilizzo di C di basso livello può consentire molte ottimizzazioni che sono quasi impossibili da eseguire per un compilatore JIT generico.

   Vedi questo collegamento per alcuni trucchi e confronti di velocità di implementazioni C scritte a mano (memcpy, ma il principio è lo stesso): Controlla questo Ottimizzare Memcpy migliora la velocità

2. La versione C è praticamente indipendente dal tipo e dalla dimensione dei membri dell'array. Non è possibile fare lo stesso in java poiché non c'è modo di ottenere il contenuto dell'array come un blocco di memoria grezzo (es. Puntatore).