c # Применение 64-битного XOR к байтовому массиву - PullRequest
Новая
       8

c # Применение 64-битного XOR к байтовому массиву

0 голосов
/ 09 мая 2018

Я хочу применить 64 операции XOR двухбайтового массива. Правильный ли это подход с использованием unsafe

Я попробовал следующий подход без использования unsafe. но я хочу немного быстрее, чем это 

for (int i=0; i< oldBlock.Length;i++)
{
{
 oldblock[i] ^= (newblock[i]);
}

Ниже операции XOR пропустить последние байты, как показано ниже, код XOR 8 байтов каждый раз.

Как это сделать. 

static void Main(string[] args)
        {


            byte[] a = new byte[10];
            byte[] b = new byte[10];
            Random r = new Random();
            r.NextBytes(a);
            a.CopyTo(b, 0);
            XOr64(a, b);
            foreach (byte c in a)
            {
                Console.WriteLine(c);
            }


            Console.ReadKey();



        }    

public static unsafe void XOr64(byte[] oldBlock, byte[] newblock)
                {
                    try
                    {
                        fixed (byte* byteA = oldBlock)
                        fixed (byte* byteB = newblock)
                        {
                            long* ppA = (long*)byteA;
                            long* ppB = (long*)byteB;

                            for (int p = 0; p < oldBlock.Length/8; p++)
                            {
                                *ppA ^= *ppB;

                                ppA++;
                                ppB++;
                            }
                        }
                    }
                    catch
                    {

                    }



                }

1 Ответ

0 голосов
/ 09 мая 2018

Если аспект 8 байтов за раз работает хорошо для вас, и вы уверены, что вам нужна дополнительная производительность, вы можете просто расширить этот метод, чтобы охватить оставшиеся байты индивидуально - что будет не более 7 байт: 

public static unsafe void XOr64(byte[] oldBlock, byte[] newBlock)
{
    // First XOR as many 64-bit blocks as possible, for the sake of speed
    fixed (byte* byteA = oldBlock)
    fixed (byte* byteB = newBlock)
    {
        long* ppA = (long*) byteA;
        long* ppB = (long*) byteB;

        int chunks = oldBlock.Length / 8;
        for (int p = 0; p < chunks; p++)
        {
            *ppA ^= *ppB;

            ppA++;
            ppB++;
        }
    }

    // Now cover any remaining bytes one byte at a time. We've
    // already handled chunks * 8 bytes, so start there.
    for (int index = chunks * 8; index < oldBlock.Length; index++)
    {
        oldBlock[index] ^= newBlock[index];
    }
}
...