Comment Buffer.BlockCopy peut-il améliorer les performances lors de la copie de plusieurs tableaux dans un tableau 3D en C# ?

Amélioration des performances de copie de tableaux en C

Dans le but d'améliorer l'efficacité de la copie de plusieurs tableaux dans un seul tableau tridimensionnel, un développeur a rencontré des problèmes de performances lorsque en exécutant le code suivant :

for (int i = 0; i < sortedIndex.Length; i++) {
    if (i < num_in_left)
    {    
        // add instance to the left child
        leftnode[i, 0] = sortedIndex[i];
        leftnode[i, 1] = sortedInstances[i];
        leftnode[i, 2] = sortedLabels[i];
    }
    else
    { 
        // add instance to the right child
        rightnode[i-num_in_left, 0] = sortedIndex[i];
        rightnode[i-num_in_left, 1] = sortedInstances[i];
        rightnode[i-num_in_left, 2] = sortedLabels[i];
    }                    
}

Solution plus rapide à l'aide de Buffer.BlockCopy

Pour adresser En raison des problèmes de performances, Buffer.BlockCopy a été introduit comme une alternative plus rapide. Son objectif principal est de faciliter les opérations à grande vitesse, comme indiqué dans la documentation :

Cette classe offre de meilleures performances pour manipuler les types primitifs que les méthodes similaires de la classe System.Array.

Buffer. BlockCopy est capable de fonctionner sur des tableaux multidimensionnels. Pour garantir des performances optimales, il est crucial de spécifier le nombre d'octets à copier plutôt que le nombre d'éléments et de travailler avec des tableaux primitifs.

Méthode de combinaison de tableaux dans un tableau 3D

En réponse à la question mise à jour, qui visait à combiner trois tableaux 1D en un tableau 3D, la magie suivante pourrait être appliqué :

double[] sortedIndex, sortedInstances, sortedLabels;
// copy them over to a 3d array
double[] leftnode = new double[sortedIndex.Length, 3];
// magic happens here
leftnode = {sortedIndex, sortedInstances, sortedLabels};

Comparaison d'analyse comparative

Pour déterminer l'approche optimale, des tests d'analyse comparative ont été effectués à l'aide de trois méthodes : Array.Copy, Buffer.BlockCopy et Buffer.memcpyimpl. Les résultats ont révélé que les méthodes sont très compétitives, Buffer.memcpyimpl étant généralement la plus rapide. Cependant, la différence de performances est marginale, ce qui rend inutile de trop se concentrer sur la sélection d'une méthode plutôt que sur les autres.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!