Pourquoi est-ce Système.arraycopy natif de Java?

Question

J'ai été surpris de voir dans le source Java de ce Système.arraycopy est une méthode native.

Bien sûr, la raison en est parce que c'est plus rapide. Mais ce natif de tours est le code pu l'employer le rendre plus rapide?

Pourquoi ne pas simplement une boucle sur le tableau original et copie de chaque pointeur vers le nouveau tableau - sûrement, ce n'est pas la lenteur et la lourdeur?

Answer 1

En code natif, il peut être fait avec un seul memcpy / memmove, par opposition à la n distincte les opérations de copie. La différence de performance est importante.

Answer 2

Il ne peut pas être écrit en Java. Code natif est capable d'ignorer ou éluder la différence entre les tableaux d'Objets et de tableaux de primitives. Java ne peut pas le faire, du moins pas de manière efficace.

Et il ne peut pas être écrit avec un seul memcpy, en raison de la sémantique requise par le chevauchement des tableaux.

Answer 3

Il est, bien sûr, dépendant de l'implémentation.

HotSpot le traitera comme un "intrinsèque" et insérez le code sur le site d'appel. C'est du code machine, ne pas ralentir vieux C code. Cela signifie également que les problèmes avec la signature de la méthode en grande partie disparaître.

Une simple copie de la boucle est assez simple qu'évidente des optimisations peuvent être appliquées. Par exemple le déroulement de la boucle. Exactement ce qui se passe est de nouveau dépendant de l'implémentation.

Answer 4

De mon point de vue est que la raison qu' System.arraycopy est originaire , au moins en partie historique.

Dans les premiers jours lorsque Java est seulement interprété, un code natif de la mise en œuvre de l' arraycopy aurait été nettement plus rapide que son équivalent de la boucle écrit en Java. L' arraycopy méthode aurait été essentiel dans la fabrication (par exemple) d'e/S et des performances graphiques supportable.

Bien sûr, les choses ont changé. Java est maintenant JIT compilé, et le code natif compilateur peut faire toutes sortes de choses intelligentes à faire de simples boucles d'aller vite. Donc, il n'est pas évident qu'un natif de la mise en œuvre de l' arraycopy fait une grande différence, "intrinsèque" d'un traitement non-résister. Toutefois, le nom, la signature et la sémantique d' arraycopy sont tellement ancrées qu'elles sont susceptibles de rester inchangé tant que Java (que nous connaissons) est utilisé.

Answer 5

Dans mes propres tests Système.arraycopy() pour copier plusieurs dimension des tableaux est de 10 à 20 fois plus rapide que l'entrelacement de boucles:

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 affiche:

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