aaru-dps/AaruBenchmark
1
0
Fork 0
mirror of https://github.com/aaru-dps/AaruBenchmark.git synced 2025-12-16 19:24:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement Fletcher-32 using ARM NEON instructions.

Browse Source
This commit is contained in:
Natalia Portillo
2023-09-23 02:53:04 +01:00
parent 98376fb93c
commit b741a2eaf1
3 changed files with 238 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Aaru6.Checksums/Aaru6.Checksums.csproj
View File

@@ -61,6 +61,7 @@
<Compile Include="CRC32\arm_simd.cs"/> <Compile Include="CRC32\arm_simd.cs"/>
<Compile Include="CRC32\vmull.cs"/> <Compile Include="CRC32\vmull.cs"/>
<Compile Include="CRC64\clmul.cs"/> <Compile Include="CRC64\clmul.cs"/>
<Compile Include="Fletcher32\neon.cs" />
<Compile Include="Native.cs"/> <Compile Include="Native.cs"/>
<Compile Include="SpamSumContext.cs"/> <Compile Include="SpamSumContext.cs"/>
<Compile Include="Adler32Context.cs"/> <Compile Include="Adler32Context.cs"/>

223
Aaru6.Checksums/Fletcher32/neon.cs Normal file
View File

@@ -0,0 +1,223 @@
// /***************************************************************************
// Aaru Data Preservation Suite
// ----------------------------------------------------------------------------
//
// Filename : neon.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
// The Chromium Authors
//
// Component : Checksums.
//
// --[ Description ] ----------------------------------------------------------
//
// Compute Fletcher32 checksum using NEON vectorization.
//
// --[ License ] --------------------------------------------------------------
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2023 Natalia Portillo
// Copyright 2017 The Chromium Authors. All rights reserved.
// ****************************************************************************/
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
namespace Aaru6.Checksums.Fletcher32;
internal static class neon
{
internal static void Step(ref ushort preSum1, ref ushort preSum2, byte[] buf, uint len)
{
/*
* Split Fletcher-32 into component sums.
*/
uint s1 = preSum1;
uint s2 = preSum2;
int bufPos = 0;
/*
* Process the data in blocks.
*/
uint BLOCK_SIZE = 1 << 5;
uint blocks = len / BLOCK_SIZE;
len -= blocks * BLOCK_SIZE;
while(blocks != 0)
{
uint n = Fletcher32Context.NMAX / BLOCK_SIZE; /* The NMAX constraint. */
if(n > blocks)
n = blocks;
blocks -= n;
/*
* Process n blocks of data. At most NMAX data bytes can be
* processed before s2 must be reduced modulo FLETCHER_MODULE.
*/
Vector128<uint> v_s2 = Vector128.Create(s1 * n, 0, 0, 0);
Vector128<uint> v_s1 = Vector128.Create(0u, 0, 0, 0);
Vector128<ushort> v_column_sum_1 = AdvSimd.DuplicateToVector128((ushort)0);
Vector128<ushort> v_column_sum_2 = AdvSimd.DuplicateToVector128((ushort)0);
Vector128<ushort> v_column_sum_3 = AdvSimd.DuplicateToVector128((ushort)0);
Vector128<ushort> v_column_sum_4 = AdvSimd.DuplicateToVector128((ushort)0);
do
{
/*
* Load 32 input bytes.
*/
Vector128<byte> bytes1 = Vector128.Create(buf[bufPos], buf[bufPos + 1], buf[bufPos + 2],
buf[bufPos + 3], buf[bufPos + 4], buf[bufPos + 5],
buf[bufPos + 6], buf[bufPos + 7], buf[bufPos + 8],
buf[bufPos + 9], buf[bufPos + 10], buf[bufPos + 11],
buf[bufPos + 12], buf[bufPos + 13], buf[bufPos + 14],
buf[bufPos + 15]);
bufPos += 16;
Vector128<byte> bytes2 = Vector128.Create(buf[bufPos], buf[bufPos + 1], buf[bufPos + 2],
buf[bufPos + 3], buf[bufPos + 4], buf[bufPos + 5],
buf[bufPos + 6], buf[bufPos + 7], buf[bufPos + 8],
buf[bufPos + 9], buf[bufPos + 10], buf[bufPos + 11],
buf[bufPos + 12], buf[bufPos + 13], buf[bufPos + 14],
buf[bufPos + 15]);
bufPos += 16;
/*
* Add previous block byte sum to v_s2.
*/
v_s2 = AdvSimd.Add(v_s2, v_s1);
/*
* Horizontally add the bytes for s1.
*/
v_s1 =
AdvSimd.AddPairwiseWideningAndAdd(v_s1,
AdvSimd.
AddPairwiseWideningAndAdd(AdvSimd.AddPairwiseWidening(bytes1),
bytes2));
/*
* 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());
} while(--n != 0);
v_s2 = AdvSimd.ShiftLeftLogical(v_s2, 5);
/*
* Multiply-add bytes by [ 32, 31, 30, ... ] for s2.
*/
v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_1.GetLower(),
Vector64.Create((ushort)32, 31, 30, 29));
v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_1.GetUpper(),
Vector64.Create((ushort)28, 27, 26, 25));
v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_2.GetLower(),
Vector64.Create((ushort)24, 23, 22, 21));
v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_2.GetUpper(),
Vector64.Create((ushort)20, 19, 18, 17));
v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_3.GetLower(),
Vector64.Create((ushort)16, 15, 14, 13));
v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_3.GetUpper(),
Vector64.Create((ushort)12, 11, 10, 9));
v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_4.GetLower(),
Vector64.Create((ushort)8, 7, 6, 5));
v_s2 = AdvSimd.MultiplyWideningLowerAndAdd(v_s2, v_column_sum_4.GetUpper(),
Vector64.Create((ushort)4, 3, 2, 1));
/*
* Sum epi32 ints v_s1(s2) and accumulate in s1(s2).
*/
Vector64<uint> sum1 = AdvSimd.AddPairwise(v_s1.GetLower(), v_s1.GetUpper());
Vector64<uint> sum2 = AdvSimd.AddPairwise(v_s2.GetLower(), v_s2.GetUpper());
Vector64<uint> s1s2 = AdvSimd.AddPairwise(sum1, sum2);
s1 += AdvSimd.Extract(s1s2, 0);
s2 += AdvSimd.Extract(s1s2, 1);
/*
* Reduce.
*/
s1 %= Fletcher32Context.FLETCHER_MODULE;
s2 %= Fletcher32Context.FLETCHER_MODULE;
}
/*
* Handle leftover data.
*/
if(len != 0)
{
if(len >= 16)
{
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
s2 += s1 += buf[bufPos++];
len -= 16;
}
while(len-- != 0)
{
s2 += s1 += buf[bufPos++];
}
if(s1 >= Fletcher32Context.FLETCHER_MODULE)
s1 -= Fletcher32Context.FLETCHER_MODULE;
s2 %= Fletcher32Context.FLETCHER_MODULE;
}
/*
* Return the recombined sums.
*/
preSum1 = (ushort)(s1 & 0xFFFF);
preSum2 = (ushort)(s2 & 0xFFFF);
}
}

19
Aaru6.Checksums/FletcherContext.cs
View File

@@ -35,20 +35,22 @@
using System; using System;
using System.IO; using System.IO;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Runtime.Intrinsics.Arm;
using System.Text; using System.Text;
using Aaru.CommonTypes.Interfaces; using Aaru.CommonTypes.Interfaces;
using Aaru.Helpers; using Aaru.Helpers;
using Aaru6.Checksums.Fletcher32;
namespace Aaru6.Checksums; namespace Aaru6.Checksums;
/// <summary>Implements the Fletcher-32 algorithm</summary> /// <summary>Implements the Fletcher-32 algorithm</summary>
public sealed class Fletcher32Context : IChecksum public sealed class Fletcher32Context : IChecksum
{ {
const ushort FLETCHER_MODULE = 0xFFFF; internal const ushort FLETCHER_MODULE = 0xFFFF;
const uint NMAX = 5552; internal const uint NMAX = 5552;
readonly IntPtr _nativeContext; readonly IntPtr _nativeContext;
readonly bool _useNative; readonly bool _useNative;
ushort _sum1, _sum2; ushort _sum1, _sum2;
/// <summary>Initializes the Fletcher-32 sums</summary> /// <summary>Initializes the Fletcher-32 sums</summary>
public Fletcher32Context() public Fletcher32Context()
@@ -131,6 +133,13 @@ public sealed class Fletcher32Context : IChecksum
return; return;
} }
if(AdvSimd.IsSupported)
{
neon.Step(ref previousSum1, ref previousSum2, data, len);
return;
}
uint sum1 = previousSum1; uint sum1 = previousSum1;
uint sum2 = previousSum2; uint sum2 = previousSum2;
uint n; uint n;