Warum ist System.arraycopy in Java nativ?

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

Der Grund ist natürlich, dass es schneller ist. Aber welche nativen Tricks kann der Code anwenden, um ihn schneller zu machen?

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

Im nativen Code kann dies mit einem einzelnen memcpy/ erfolgen memmove, im Gegensatz zu n verschiedenen Kopiervorgängen. Der Leistungsunterschied ist erheblich.

Es kann nicht in Java geschrieben werden. Native Code kann den Unterschied zwischen Arrays von Object und Arrays von Primitiven ignorieren oder beseitigen. Java kann das nicht, zumindest nicht effizient.

Und es kannmemcpy() aufgrund der Semantik, die überlappende Arrays erfordern, nicht mit einem einzigen geschrieben werden .

Dies hängt natürlich von der Implementierung ab.

HotSpot behandelt es als "intrinsisch" und fügt Code an der Anrufstelle ein. Das ist Maschinencode, kein langsamer alter C-Code. Dies bedeutet auch, dass die Probleme mit der Signatur der Methode weitgehend verschwinden.

Eine einfache Kopierschleife ist so einfach, dass offensichtliche Optimierungen darauf angewendet werden können. Zum Beispiel das Abrollen der Schleife. Was genau passiert, hängt wiederum von der Implementierung ab.

In meinen eigenen Tests ist System.arraycopy () zum Kopieren von Arrays mit mehreren Dimensionen 10 bis 20 Mal schneller als das Verschachteln von 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);
        }
    }
}

Dies druckt:

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

Es gibt einige Gründe:

1. Es ist unwahrscheinlich, dass die JIT so effizienten Low-Level-Code generiert wie ein manuell geschriebener C-Code. Die Verwendung von Low Level C kann viele Optimierungen ermöglichen, die für einen generischen JIT-Compiler nahezu unmöglich sind.

   Unter diesem Link finden Sie einige Tricks und Geschwindigkeitsvergleiche von handgeschriebenen C-Implementierungen (memcpy, aber das Prinzip ist dasselbe): Aktivieren Sie dieses Kontrollkästchen Optimieren von Memcpy verbessert die Geschwindigkeit

2. Die C-Version ist weitgehend unabhängig von Typ und Größe der Array-Mitglieder. In Java ist dies nicht möglich, da es keine Möglichkeit gibt, den Array-Inhalt als unformatierten Speicherblock (z. B. Zeiger) abzurufen.