Pourquoi System.arraycopy est-il natif en Java?

Question

J'ai été surpris de voir dans la source Java que System.arraycopy est une méthode native.

Bien sûr, la raison en est que c'est plus rapide. Mais quelles astuces natives est le code capable d'employer qui le rendent plus rapide? Pourquoi ne pas simplement boucler sur la matrice d'origine et copier chaque pointeur sur la nouvelle matrice - ce n'est pas si lent et encombrant?

Answer 1

Dans le code natif, il peut être fait avec un seul memcpy/memmove, par opposition à n opérations de copie distinctes. La différence de performance est substantielle.

Answer 2

Il ne peut pas être écrit en Java. Le code natif est capable d'ignorer ou d'élider la différence entre les tableaux d'objets et les tableaux de primitives. Java ne peut pas faire cela, du moins pas efficacement.

Et il ne peut pas être écrit avec un seul memcpy(), en raison de la sémantique requise par les tableaux se chevauchant.

Answer 3

Il y a quelques raisons:

1. Le JIT est peu susceptible de générer le code de bas niveau efficace en tant que code C écrit manuellement. L'utilisation d'un niveau bas C peut permettre de nombreuses optimisations presque impossibles à faire pour un compilateur JIT générique.

   Voir ce lien pour quelques trucs et des comparaisons de vitesse de mise en oeuvre de C écrites à la main (memcpy, mais le principe est le même): Cochez cette case Optimizing Memcpy improves speed

2. La version C est à peu près indépendante du type et la taille de les membres du tableau. Il n'est pas possible de faire la même chose dans Java car il n'y a aucun moyen d'obtenir le contenu du tableau comme un bloc de mémoire brut (par exemple, pointeur).

Answer 4

Il est, bien sûr, la mise en œuvre dépend.

HotSpot le traitera comme un code «intrinsèque» et insérera du code sur le site d'appel. C'est le code machine, pas le vieux code C lent. Cela signifie également que les problèmes liés à la signature de la méthode disparaissent en grande partie. Une simple boucle de copie est assez simple pour que des optimisations évidentes puissent lui être appliquées. Par exemple, dérouler la boucle. Ce qui se passe exactement dépend de l'implémentation.

Answer 5

Dans mes propres tests System.arraycopy() pour copier des tableaux de dimensions multiples est 10 à 20 fois plus rapide que pour les boucles entrelacer:

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

Cette impression:

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