¿Por qué System.arraycopy es nativo en Java?

Me sorprendió ver en la fuente de Java que System.arraycopy es un método nativo.

Por supuesto, la razón es porque es más rápido. Pero, ¿qué trucos nativos puede emplear el código que lo hacen más rápido?

¿Por qué no simplemente recorrer la matriz original y copiar cada puntero a la nueva matriz? Seguramente esto no es tan lento y engorroso.

En código nativo, se puede hacer con un solo memcpy/ memmove, a diferencia de n operaciones de copia distintas. La diferencia de rendimiento es sustancial.

No se puede escribir en Java. El código nativo puede ignorar o eludir la diferencia entre matrices de Object y matrices de primitivas. Java no puede hacer eso, al menos no de manera eficiente.

Y no se puede escribir con un solo memcpy(), debido a la semántica requerida por las matrices superpuestas.

Por supuesto, depende de la implementación.

HotSpot lo tratará como un código "intrínseco" e insertará en el sitio de la llamada. Eso es código máquina, no código C antiguo lento. Esto también significa que los problemas con la firma del método desaparecen en gran medida.

Un bucle de copia simple es lo suficientemente simple como para que se le puedan aplicar optimizaciones obvias. Por ejemplo, desenrollado de bucle. Exactamente lo que sucede depende nuevamente de la implementación.

En mis propias pruebas, System.arraycopy () para copiar matrices de múltiples dimensiones es de 10 a 20 veces más rápido que intercalar para bucles:

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

Esto imprime:

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

Hay unas pocas razones:

1. Es poco probable que el JIT genere un código de bajo nivel tan eficiente como un código C escrito manualmente. El uso de C de bajo nivel puede permitir muchas optimizaciones que son casi imposibles de realizar para un compilador JIT genérico.

   Consulte este enlace para ver algunos trucos y comparaciones de velocidad de implementaciones de C escritas a mano (memcpy, pero el principio es el mismo): marque esto Optimizing Memcpy mejora la velocidad

2. La versión C es prácticamente independiente del tipo y tamaño de los miembros de la matriz. No es posible hacer lo mismo en Java, ya que no hay forma de obtener el contenido de la matriz como un bloque de memoria sin formato (por ejemplo, puntero).