From 4b209cb4c74bea1d9a5404600641e8db89d01762 Mon Sep 17 00:00:00 2001 From: Natalia Portillo Date: Tue, 15 Mar 2022 01:37:37 +0000 Subject: [PATCH] Fix naming style. --- Adler32/neon.cs | 64 +++++++++++++++++++++++------------------------ Adler32/ssse3.cs | 38 ++++++++++++++-------------- Adler32Context.cs | 2 +- CRC16Context.cs | 40 ++++++++++++++--------------- 4 files changed, 72 insertions(+), 72 deletions(-) diff --git a/Adler32/neon.cs b/Adler32/neon.cs index 46bf6ee..e25c688 100644 --- a/Adler32/neon.cs +++ b/Adler32/neon.cs @@ -50,7 +50,7 @@ namespace Aaru.Checksums.Adler32; using System.Runtime.Intrinsics; using System.Runtime.Intrinsics.Arm; -static class neon +static class Neon { internal static void Step(ref ushort preSum1, ref ushort preSum2, byte[] buf, uint len) { @@ -65,13 +65,13 @@ static class neon /* * Process the data in blocks. */ - uint BLOCK_SIZE = 1 << 5; - uint blocks = len / BLOCK_SIZE; - len -= blocks * BLOCK_SIZE; + uint blockSize = 1 << 5; + uint blocks = len / blockSize; + len -= blocks * blockSize; while(blocks != 0) { - uint n = Adler32Context.NMAX / BLOCK_SIZE; /* The NMAX constraint. */ + uint n = Adler32Context.NMAX / blockSize; /* The NMAX constraint. */ if(n > blocks) n = blocks; @@ -81,12 +81,12 @@ static class neon * Process n blocks of data. At most NMAX data bytes can be * processed before s2 must be reduced modulo ADLER_MODULE. */ - var v_s2 = Vector128.Create(s1 * n, 0, 0, 0); - var v_s1 = Vector128.Create(0u, 0, 0, 0); - Vector128 v_column_sum_1 = AdvSimd.DuplicateToVector128((ushort)0); - Vector128 v_column_sum_2 = AdvSimd.DuplicateToVector128((ushort)0); - Vector128 v_column_sum_3 = AdvSimd.DuplicateToVector128((ushort)0); - Vector128 v_column_sum_4 = AdvSimd.DuplicateToVector128((ushort)0); + var vS2 = Vector128.Create(s1 * n, 0, 0, 0); + var vS1 = Vector128.Create(0u, 0, 0, 0); + Vector128 vColumnSum1 = AdvSimd.DuplicateToVector128((ushort)0); + Vector128 vColumnSum2 = AdvSimd.DuplicateToVector128((ushort)0); + Vector128 vColumnSum3 = AdvSimd.DuplicateToVector128((ushort)0); + Vector128 vColumnSum4 = AdvSimd.DuplicateToVector128((ushort)0); do { @@ -109,13 +109,13 @@ static class neon /* * Add previous block byte sum to v_s2. */ - v_s2 = AdvSimd.Add(v_s2, v_s1); + vS2 = AdvSimd.Add(vS2, vS1); /* * Horizontally add the bytes for s1. */ - v_s1 = - AdvSimd.AddPairwiseWideningAndAdd(v_s1, + vS1 = + AdvSimd.AddPairwiseWideningAndAdd(vS1, AdvSimd. AddPairwiseWideningAndAdd(AdvSimd.AddPairwiseWidening(bytes1), bytes2)); @@ -123,49 +123,49 @@ static class neon /* * Vertically add the bytes for s2. */ - v_column_sum_1 = AdvSimd.AddWideningLower(v_column_sum_1, bytes1.GetLower()); - v_column_sum_2 = AdvSimd.AddWideningLower(v_column_sum_2, bytes1.GetUpper()); - v_column_sum_3 = AdvSimd.AddWideningLower(v_column_sum_3, bytes2.GetLower()); - v_column_sum_4 = AdvSimd.AddWideningLower(v_column_sum_4, bytes2.GetUpper()); + vColumnSum1 = AdvSimd.AddWideningLower(vColumnSum1, bytes1.GetLower()); + vColumnSum2 = AdvSimd.AddWideningLower(vColumnSum2, bytes1.GetUpper()); + vColumnSum3 = AdvSimd.AddWideningLower(vColumnSum3, bytes2.GetLower()); + vColumnSum4 = AdvSimd.AddWideningLower(vColumnSum4, bytes2.GetUpper()); } while(--n != 0); - v_s2 = AdvSimd.ShiftLeftLogical(v_s2, 5); + vS2 = AdvSimd.ShiftLeftLogical(vS2, 5); /* * Multiply-add bytes by [ 32, 31, 30, ... ] for s2. */ - v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_1.GetLower(), + vS2 = AdvSimd.MultiplyWideningLowerAndAdd(vS2, vColumnSum1.GetLower(), Vector64.Create((ushort)32, 31, 30, 29)); - v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_1.GetUpper(), + vS2 = AdvSimd.MultiplyWideningLowerAndAdd(vS2, vColumnSum1.GetUpper(), Vector64.Create((ushort)28, 27, 26, 25)); - v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_2.GetLower(), + vS2 = AdvSimd.MultiplyWideningLowerAndAdd(vS2, vColumnSum2.GetLower(), Vector64.Create((ushort)24, 23, 22, 21)); - v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_2.GetUpper(), + vS2 = AdvSimd.MultiplyWideningLowerAndAdd(vS2, vColumnSum2.GetUpper(), Vector64.Create((ushort)20, 19, 18, 17)); - v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_3.GetLower(), + vS2 = AdvSimd.MultiplyWideningLowerAndAdd(vS2, vColumnSum3.GetLower(), Vector64.Create((ushort)16, 15, 14, 13)); - v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_3.GetUpper(), + vS2 = AdvSimd.MultiplyWideningLowerAndAdd(vS2, vColumnSum3.GetUpper(), Vector64.Create((ushort)12, 11, 10, 9)); - v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_4.GetLower(), + vS2 = AdvSimd.MultiplyWideningLowerAndAdd(vS2, vColumnSum4.GetLower(), Vector64.Create((ushort)8, 7, 6, 5)); - v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_4.GetUpper(), + vS2 = AdvSimd.MultiplyWideningLowerAndAdd(vS2, vColumnSum4.GetUpper(), Vector64.Create((ushort)4, 3, 2, 1)); /* * Sum epi32 ints v_s1(s2) and accumulate in s1(s2). */ - Vector64 sum1 = AdvSimd.AddPairwise(v_s1.GetLower(), v_s1.GetUpper()); - Vector64 sum2 = AdvSimd.AddPairwise(v_s2.GetLower(), v_s2.GetUpper()); - Vector64 s1s2 = AdvSimd.AddPairwise(sum1, sum2); - s1 += AdvSimd.Extract(s1s2, 0); - s2 += AdvSimd.Extract(s1s2, 1); + Vector64 sum1 = AdvSimd.AddPairwise(vS1.GetLower(), vS1.GetUpper()); + Vector64 sum2 = AdvSimd.AddPairwise(vS2.GetLower(), vS2.GetUpper()); + Vector64 s1S2 = AdvSimd.AddPairwise(sum1, sum2); + s1 += AdvSimd.Extract(s1S2, 0); + s2 += AdvSimd.Extract(s1S2, 1); /* * Reduce. */ diff --git a/Adler32/ssse3.cs b/Adler32/ssse3.cs index 43ba6e6..6cdd9de 100644 --- a/Adler32/ssse3.cs +++ b/Adler32/ssse3.cs @@ -62,13 +62,13 @@ static class Ssse3 /* * Process the data in blocks. */ - uint BLOCK_SIZE = 1 << 5; - uint blocks = len / BLOCK_SIZE; - len -= blocks * BLOCK_SIZE; + uint blockSize = 1 << 5; + uint blocks = len / blockSize; + len -= blocks * blockSize; while(blocks != 0) { - uint n = Adler32Context.NMAX / BLOCK_SIZE; /* The NMAX constraint. */ + uint n = Adler32Context.NMAX / blockSize; /* The NMAX constraint. */ if(n > blocks) n = blocks; @@ -85,9 +85,9 @@ static class Ssse3 * Process n blocks of data. At most NMAX data bytes can be * processed before s2 must be reduced modulo BASE. */ - var v_ps = Vector128.Create(s1 * n, 0, 0, 0); - var v_s2 = Vector128.Create(s2, 0, 0, 0); - var v_s1 = Vector128.Create(0u, 0, 0, 0); + var vPs = Vector128.Create(s1 * n, 0, 0, 0); + var vS2 = Vector128.Create(s2, 0, 0, 0); + var vS1 = Vector128.Create(0u, 0, 0, 0); do { @@ -111,35 +111,35 @@ static class Ssse3 /* * Add previous block byte sum to v_ps. */ - v_ps = Sse2.Add(v_ps, v_s1); + vPs = Sse2.Add(vPs, vS1); /* * Horizontally add the bytes for s1, multiply-adds the * bytes by [ 32, 31, 30, ... ] for s2. */ - v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes1.AsByte(), zero).AsUInt32()); + vS1 = Sse2.Add(vS1, Sse2.SumAbsoluteDifferences(bytes1.AsByte(), zero).AsUInt32()); Vector128 mad1 = System.Runtime.Intrinsics.X86.Ssse3.MultiplyAddAdjacent(bytes1.AsByte(), tap1.AsSByte()); - v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad1.AsInt16(), ones.AsInt16()).AsUInt32()); - v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes2.AsByte(), zero).AsUInt32()); + vS2 = Sse2.Add(vS2, Sse2.MultiplyAddAdjacent(mad1.AsInt16(), ones.AsInt16()).AsUInt32()); + vS1 = Sse2.Add(vS1, Sse2.SumAbsoluteDifferences(bytes2.AsByte(), zero).AsUInt32()); Vector128 mad2 = System.Runtime.Intrinsics.X86.Ssse3.MultiplyAddAdjacent(bytes2.AsByte(), tap2.AsSByte()); - v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad2.AsInt16(), ones.AsInt16()).AsUInt32()); + vS2 = Sse2.Add(vS2, Sse2.MultiplyAddAdjacent(mad2.AsInt16(), ones.AsInt16()).AsUInt32()); } while(--n != 0); - v_s2 = Sse2.Add(v_s2, Sse2.ShiftLeftLogical(v_ps, 5)); + vS2 = Sse2.Add(vS2, Sse2.ShiftLeftLogical(vPs, 5)); /* * Sum epi32 ints v_s1(s2) and accumulate in s1(s2). */ - v_s1 = Sse2.Add(v_s1, Sse2.Shuffle(v_s1, 177)); - v_s1 = Sse2.Add(v_s1, Sse2.Shuffle(v_s1, 78)); - s1 += (uint)Sse2.ConvertToInt32(v_s1.AsInt32()); - v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, 177)); - v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, 78)); - s2 = (uint)Sse2.ConvertToInt32(v_s2.AsInt32()); + vS1 = Sse2.Add(vS1, Sse2.Shuffle(vS1, 177)); + vS1 = Sse2.Add(vS1, Sse2.Shuffle(vS1, 78)); + s1 += (uint)Sse2.ConvertToInt32(vS1.AsInt32()); + vS2 = Sse2.Add(vS2, Sse2.Shuffle(vS2, 177)); + vS2 = Sse2.Add(vS2, Sse2.Shuffle(vS2, 78)); + s2 = (uint)Sse2.ConvertToInt32(vS2.AsInt32()); /* * Reduce. */ diff --git a/Adler32Context.cs b/Adler32Context.cs index 745ca00..109505c 100644 --- a/Adler32Context.cs +++ b/Adler32Context.cs @@ -148,7 +148,7 @@ public sealed class Adler32Context : IChecksum if(AdvSimd.IsSupported) { - neon.Step(ref preSum1, ref preSum2, data, len); + Neon.Step(ref preSum1, ref preSum2, data, len); return; } diff --git a/CRC16Context.cs b/CRC16Context.cs index 1bddd42..6c45454 100644 --- a/CRC16Context.cs +++ b/CRC16Context.cs @@ -217,34 +217,34 @@ public class Crc16Context : IChecksum // http://sourceforge.net/projects/slicing-by-8/ ushort crc; - var current_pos = 0; + var currentPos = 0; const int unroll = 4; - const int bytes_at_once = 8 * unroll; + const int bytesAtOnce = 8 * unroll; crc = previousCrc; - while(len >= bytes_at_once) + while(len >= bytesAtOnce) { int unrolling; for(unrolling = 0; unrolling < unroll; unrolling++) { // TODO: What trick is Microsoft doing here that's faster than arithmetic conversion - uint one = BitConverter.ToUInt32(data, current_pos) ^ crc; - current_pos += 4; - var two = BitConverter.ToUInt32(data, current_pos); - current_pos += 4; + uint one = BitConverter.ToUInt32(data, currentPos) ^ crc; + currentPos += 4; + var two = BitConverter.ToUInt32(data, currentPos); + currentPos += 4; crc = (ushort)(table[0][(two >> 24) & 0xFF] ^ table[1][(two >> 16) & 0xFF] ^ table[2][(two >> 8) & 0xFF] ^ table[3][two & 0xFF] ^ table[4][(one >> 24) & 0xFF] ^ table[5][(one >> 16) & 0xFF] ^ table[6][(one >> 8) & 0xFF] ^ table[7][one & 0xFF]); } - len -= bytes_at_once; + len -= bytesAtOnce; } while(len-- != 0) - crc = (ushort)((crc >> 8) ^ table[0][(crc & 0xFF) ^ data[current_pos++]]); + crc = (ushort)((crc >> 8) ^ table[0][(crc & 0xFF) ^ data[currentPos++]]); previousCrc = crc; } @@ -256,32 +256,32 @@ public class Crc16Context : IChecksum // http://sourceforge.net/projects/slicing-by-8/ ushort crc; - var current_pos = 0; + var currentPos = 0; const int unroll = 4; - const int bytes_at_once = 8 * unroll; + const int bytesAtOnce = 8 * unroll; crc = previousCrc; - while(len >= bytes_at_once) + while(len >= bytesAtOnce) { int unrolling; for(unrolling = 0; unrolling < unroll; unrolling++) { - crc = (ushort)(table[7][data[current_pos + 0] ^ (crc >> 8)] ^ - table[6][data[current_pos + 1] ^ (crc & 0xFF)] ^ table[5][data[current_pos + 2]] ^ - table[4][data[current_pos + 3]] ^ table[3][data[current_pos + 4]] ^ - table[2][data[current_pos + 5]] ^ table[1][data[current_pos + 6]] ^ - table[0][data[current_pos + 7]]); + crc = (ushort)(table[7][data[currentPos + 0] ^ (crc >> 8)] ^ + table[6][data[currentPos + 1] ^ (crc & 0xFF)] ^ table[5][data[currentPos + 2]] ^ + table[4][data[currentPos + 3]] ^ table[3][data[currentPos + 4]] ^ + table[2][data[currentPos + 5]] ^ table[1][data[currentPos + 6]] ^ + table[0][data[currentPos + 7]]); - current_pos += 8; + currentPos += 8; } - len -= bytes_at_once; + len -= bytesAtOnce; } while(len-- != 0) - crc = (ushort)((crc << 8) ^ table[0][(crc >> 8) ^ data[current_pos++]]); + crc = (ushort)((crc << 8) ^ table[0][(crc >> 8) ^ data[currentPos++]]); previousCrc = crc; }