Optimiser la sommation de 2 tableaux d'octets

Vous pouvez utiliser Vector:

static void Add(Span<byte> dst, ReadOnlySpan<byte> src)
{
    Span<Vector<byte>> dstVec = MemoryMarshal.Cast<byte, Vector<byte>>(dst);
    ReadOnlySpan<Vector<byte>> srcVec = MemoryMarshal.Cast<byte, Vector<byte>>(src);

    for (int i = 0; i < dstVec.Length; ++i)
    {
        dstVec[i] += srcVec[i];
    }

    for (int i = dstVec.Length * Vector<byte>.Count; i < dst.Length; ++i)
    {
        dst[i] += src[i];
    }
}

Cela ira encore plus vite si vous utilisez un pointeur ici pour aligner l'un de vos tableaux.

p >

Vous pouvez utiliser tous vos processeurs / cœurs, en supposant que votre machine en possède plusieurs.

using System.Numerics;

/// <summary>Adds each pair of elements in two arrays, and replaces the
/// left array element with the result.</summary>
public static void Add_UsingVector(byte[] left, byte[] right, int start, int length)
{
    int i = start;
    int step = Vector<byte>.Count; // the step is 16
    int end = start + length - step + 1;
    for (; i < end; i += step)
    {
        // Vectorize 16 bytes from each array
        var vector1 = new Vector<byte>(left, i);
        var vector2 = new Vector<byte>(right, i);
        vector1 += vector2; // Vector arithmetic is unchecked only
        vector1.CopyTo(left, i);
    }
    for (; i < start + length; i++) // Process the last few elements
    {
        unchecked { left[i] += right[i]; }
    }
}

Mise à jour: Le Vector classe peut également être utilisé dans .NET Framework. Il nécessite le package System.Numerics.Vectors . Il offre l'avantage de la parallélisation dans un seul cœur, en émettant une seule instruction à plusieurs données ( SIMD ). La plupart des processeurs actuels sont compatibles SIMD. Il n'est activé que pour les processus 64 bits, donc l'indicateur [Préférer 32 bits] doit être décoché. Sur les processus 32 bits, la propriété Vector. IsHardwareAccelerated renvoie false , et les performances sont mauvaises.

Parallel.ForEach(Partitioner.Create(0, bytes.Length), range =>
{
    for (int i = range.Item1; i < range.Item2; i++)
    {
        bytes[i] += bytes2[i];
    }
});

Cela fonctionne 4 à 5 fois plus vite qu'un simple boucle, sans utiliser plus d'un thread (25% de consommation CPU dans un PC à 4 cœurs).

Remplissez la longueur du tableau au prochain multiple le plus élevé de 8. (C'est déjà le cas dans votre exemple.)

Utilisez un contexte non sécurisé pour créer deux tableaux ulong pointant vers le début de l'existant. tableaux d'octets. Utilisez une boucle for pour itérer octets.Longueur / 8 fois en ajoutant 8 octets à la fois.

Sur mon système, cela dure moins de 13 millisecondes . Comparé à 105 millisecondes pour le code d'origine.

Vous devez ajouter l'option / unsafe pour utiliser ce code. Ouvrez les propriétés du projet et sélectionnez "Autoriser le code non sécurisé".

var random = new Random();
byte[] bytes = new byte[20_000_000]; 
byte[] bytes2 = new byte[20_000_000];




int Len = bytes.Length >> 3; // >>3 is the same as / 8

ulong MASK =    0x8080808080808080;
ulong MASKINV = 0x7f7f7f7f7f7f7f7f;

//Sanity check
if((bytes.Length & 7) != 0) throw new Exception("bytes.Length is not a multiple of 8");
if((bytes2.Length & 7) != 0) throw new Exception("bytes2.Length is not a multiple of 8");

unsafe
{
    //Add 8 bytes at a time, taking into account overflow between bytes
   fixed (byte* pbBytes = &bytes[0])
   fixed (byte* pbBytes2 = &bytes2[0])
   {
      ulong* pBytes = (ulong*)pbBytes;
      ulong* pBytes2 = (ulong*)pbBytes2;
      for (int i = 0; i < Len; i++)
      {
        pBytes[i] = ((pBytes2[i] & MASKINV) + (pBytes[i] & MASKINV)) ^ ((pBytes[i] ^ pBytes2[i]) & MASK);
      } 
   }
}