Warum ist System.arraycopy in Java nativ?

Question

Ich war überrascht, in der Java-Quelle zu sehen, dass System.arraycopy eine native Methode ist.

Natürlich ist der Grund, weil es schneller ist. Aber welche nativen Tricks kann der Code verwenden, der ihn schneller macht?

Warum nicht einfach über das ursprüngliche Array schleifen und jeden Zeiger auf das neue Array kopieren - sicher ist das nicht so langsam und umständlich?

Answer 1

In nativen Code, kann es mit einem einzigen memcpy/memmove erfolgen, da Operationen n deutlicher Kopie gegenüber. Der Leistungsunterschied ist beträchtlich.

Answer 2

Es kann nicht in Java geschrieben werden. Nativer Code ist in der Lage, den Unterschied zwischen Arrays von Object und Arrays von Primitiven zu ignorieren oder zu elimieren. Java kann das nicht, zumindest nicht effizient.

Und es kann nicht mit einem einzigen memcpy() geschrieben werden, wegen der Semantik von überlappenden Arrays erforderlich.

Answer 3

Es gibt ein paar Gründe:

1. Der JIT ist unwahrscheinlich, da effiziente Low Level-Code als manuell geschrieben C-Code zu generieren. Die Verwendung von Low-Level C kann viele Optimierungen ermöglichen, die für einen generischen JIT-Compiler nahezu unmöglich sind.

   Siehe diesen Link für einige Tricks und Geschwindigkeit Vergleiche von Hand geschriebene C-Implementierungen (memcpy, aber das Prinzip ist das gleiche): Aktivieren Sie diese Option Optimizing Memcpy improves speed

2. Die C-Version ziemlich unabhängig von der Art und Größe die Array-Mitglieder. Es ist nicht möglich, dasselbe in Java zu tun, da es keine Möglichkeit gibt, den Array-Inhalt als einen rohen Speicherblock zu erhalten (z. B. Zeiger).

Answer 4

Es ist natürlich implementierungsabhängig.

HotSpot wird es als "intrinsisch" behandeln und Code an der Call-Site einfügen. Das ist Maschinencode, nicht langsamer alter C-Code. Dies bedeutet auch, dass die Probleme mit der Signatur der Methode weitgehend verschwinden.

Eine einfache Kopierschleife ist einfach genug, dass offensichtliche Optimierungen darauf angewendet werden können. Zum Beispiel Loop Enrolling. Was genau passiert, ist wiederum implementierungsabhängig.

Answer 5

In meinen eigenen Tests System.arraycopy() für mehrdimensionale Arrays zu kopieren ist 10 bis 20 mal schneller als Verschachtelung für Schleifen:

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); 
     } 
    } 
} 

Diese Drucke:

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