Neon implementation (#5)

* Add NEON boilerplate

* Add mul_add_mat_x_m_mat for neon

* Add mul_add_mat_trans_x_m_mat for neon

* Add mul_add_m_upper_triangular_mat_x_mat for neon

* Add mul_add_m_upper_triangular_mat_x_mat_trans for neon

* -O^t * (P1*O + P2) with AVX2 technique

* Improve V*P1*V^t & V*L

* Add mayo_12_P1P1t_times_O_neon

* Add S*P*S^t

* Remove old neon implementation

* Adapt AVX's EF ot Neon

* Adapt Christer Knorborg's Neon AES

* Finish Mayo3 for Neon

* Finish Mayo5 for Neon

* Remove accidentally added neon header dependency

* Add Neon to README

* Add m1cycles

* Uses vsliq_n_u8 when accumulating odd/even results

* Remove useless old matrix code

* Make it work with RPi4

* Fix license issues

* add action for macos-latest

---------

Co-authored-by: Basil Hess <[email protected]>

Author: ilway25

.cmake/target.cmake

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
 
-if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64")
+if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm64" OR ${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64")
     add_definitions(-DTARGET_ARM64)
 elseif(${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm")
     add_definitions(-DTARGET_ARM)
@@ -15,7 +15,9 @@ else()
     add_definitions(-DTARGET_OTHER)
 endif()
 
-if (UNIX)
+if (APPLE)
+    add_definitions(-DTARGET_OS_MAC)
+elseif (UNIX)
     add_definitions(-DTARGET_OS_UNIX)
 else()
     add_definitions(-DTARGET_OS_OTHER)
@@ -47,6 +49,7 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
       -mcpu=apple-m1)
   endif()
   option(ENABLE_AESNI "Use AESni" OFF)
+  option(ENABLE_AESNEON "Use AES-NEON" ON)
 endif()
 
 
@@ -60,6 +63,9 @@ elseif(${MAYO_BUILD_TYPE} MATCHES "opt")
 elseif(${MAYO_BUILD_TYPE} MATCHES "avx2")
   add_definitions(-DMAYO_BUILD_TYPE_AVX2)
   option(ENABLE_PARAMS_DYNAMIC "Use dynamic parameters" OFF)
+  elseif(${MAYO_BUILD_TYPE} MATCHES "neon")
+  add_definitions(-DMAYO_BUILD_TYPE_NEON)
+  option(ENABLE_PARAMS_DYNAMIC "Use dynamic parameters" OFF)
 endif()
 
 separate_arguments(C_OPT_FLAGS UNIX_COMMAND "${G_C_OPT_FLAGS}")

.github/workflows/macos_m1.yml

@@ -0,0 +1,68 @@
+name: CMake (macos-neon)
+
+on:
+  push:
+    branches: [ '*' ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Debug
+
+jobs:
+  build_test:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        mayo_build_type: [neon]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.10"
+
+    # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
+    # You can convert this to a matrix build if you need cross-platform coverage.
+    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DMAYO_BUILD_TYPE=${{ matrix.mayo_build_type }}
+
+    - name: Build
+      # Build your program with the given configuration
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+
+    - name: Test
+      working-directory: ${{github.workspace}}/build
+      # Execute tests defined by the CMake configuration.
+      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+      run: ctest -C ${{env.BUILD_TYPE}}
+
+    - name: Examples (neon)
+      working-directory: ${{github.workspace}}/build/apps
+      run: |
+          ./PQCgenKAT_sign_mayo_1
+          ./PQCgenKAT_sign_mayo_2
+          ./PQCgenKAT_sign_mayo_3
+          ./PQCgenKAT_sign_mayo_5
+          ./example_mayo_1
+          ./example_mayo_2
+          ./example_mayo_3
+          ./example_mayo_5
+          ./example_nistapi_mayo_1
+          ./example_nistapi_mayo_2
+          ./example_nistapi_mayo_3
+          ./example_nistapi_mayo_5
+      if: matrix.mayo_build_type == 'neon'
+
+    - name: Address Sanitizer ASAN
+      run: |
+          rm -rf build
+          cmake -Bbuild -DCMAKE_BUILD_TYPE=ASAN -DMAYO_BUILD_TYPE=${{ matrix.mayo_build_type }} -DCMAKE_C_COMPILER=clang
+          cmake --build build
+          ctest -V --test-dir build

README.md

@@ -36,6 +36,8 @@ The following build options have been used to report performance numbers in the
 2. Optimized (AES-NI enabled): `cmake -DMAYO_BUILD_TYPE=opt -DENABLE_AESNI=ON ..`
 3. Optimized (AES-NI disabled): `cmake -DMAYO_BUILD_TYPE=opt -DENABLE_AESNI=OFF ..`
 4. AVX2: `cmake -DMAYO_BUILD_TYPE=avx2 -DENABLE_AESNI=ON ..`
+5. A64 M1 NEON: `cmake -DMAYO_BUILD_TYPE=neon -DENABLE_AESNI=ON ..`
+6. A64 RPi4 Cortex-A72 NEON: `cmake -DMAYO_BUILD_TYPE=neon -DENABLE_AESNI=OFF ..`
 
 ## Build options
 
@@ -64,6 +66,7 @@ Specifies the build type for which Mayo is built. The options are `ref`, `opt` a
 - `ref` builds MAYO implemented with portable C code for native target architecture, using run-time parameters.
 - `opt` builds MAYO implemented with optimized portable C code, compiled with `-march=native` (if available) and AES acceleration (if available)
 - `avx2` builds MAYO implemented with optimized AVX2 code, compiled with `-march=native` (if available) and AES acceleration (if available)
+- `neon` builds MAYO implemented with optimized NEON code, compiled with `-march=native` (if available) and AES acceleration (if available)
 
 The default build type if none is specified is `opt`.
 
@@ -89,10 +92,10 @@ The following artifacts are built:
 - `libmayo_<level>_nistapi.a`: library for `MAYO_<level>` against the NIST API.
 - `libmayo_<level>_nistapi_test.a`: library for `MAYO_<level>` against the NIST API. Only for test, using the deterministic CTR-DRBG as backend.
 - `mayo_bench_<param>`: Benchmarking suites.
-- `mayo_test_kat_<param>` (`opt` and `avx2`), `mayo_test_kat` (`ref`): KAT test suites.
-- `mayo_test_scheme_<param>` (`opt` and `avx2`), `mayo_test_scheme` (`ref`): Self-test suites.
+- `mayo_test_kat_<param>` (`opt`, `avx2` and `neon`), `mayo_test_kat` (`ref`): KAT test suites.
+- `mayo_test_scheme_<param>` (`opt`, `avx2` and `neon`), `mayo_test_scheme` (`ref`): Self-test suites.
 - `PQCgenKAT_sign_<param>`: App for generating NIST KAT.
-- `example_<param>` (`opt` and `avx2`), `example_mayo` (`ref`): Example app using the MAYO API.
+- `example_<param>` (`opt`, `avx2` and `neon`), `example_mayo` (`ref`): Example app using the MAYO API.
 - `example_nistapi_<param>`: Example app using the NIST API.
 
 ## Test
@@ -121,8 +124,9 @@ KAT verification is done as part of the test harness (see previous section).
 
 A benchmarking suite is built and runs with the following command, where `params` specifies the MAYO parameter set and `runs` the number of benchmark runs:
 
-If `MAYO_BUILD_TYPE` is `opt` or `avx2`:
+If `MAYO_BUILD_TYPE` is `opt`, `avx2` or `neon`:
 - `test/mayo_bench_<param> <runs>`,
+- On Apple M1 chips, this must be run with root permission.
 
 If `MAYO_BUILD_TYPE` is `ref`:
 - `test/mayo_bench <param> <runs>`,
@@ -156,9 +160,11 @@ Third party code is used in some test and common code files:
 
 - `common/aes_c.c`; MIT: "Copyright (c) 2016 Thomas Pornin <[email protected]>"
 - `common/aes128ctr.c`: MIT: "Copyright (c) 2016-2021 Open Quantum Safe project" and Public Domain
+- `common/aes_neon.c`: MIT: "Copyright (c) 2024 ChristerKnorborg" and Public Domain
 - `common/fips202.c`: Public Domain
 - `common/randombytes_system.c`: MIT: Copyright (c) 2017 Daan Sprenkels <[email protected]>
 - `apps/PQCgenKAT_sign.c`, `common/randombytes_ctrdrbg.c`, `test/test_kat.c`: by NIST (Public Domain)
+- `test/m1cycles.{c,h}`, Apache 2.0 or Public Domain
 
 See also the SPDX License Identifiers in the respective files.
 

include/mayo.h

@@ -137,6 +137,8 @@
 #define MAYO_NAMESPACE(s) PARAM_NAME3(opt, s)
 #elif defined(MAYO_BUILD_TYPE_AVX2)
 #define MAYO_NAMESPACE(s) PARAM_NAME3(avx2, s)
+#elif defined(MAYO_BUILD_TYPE_NEON)
+#define MAYO_NAMESPACE(s) PARAM_NAME3(neon, s)
 #else
 #error "Build type not known"
 #endif
@@ -370,7 +372,7 @@ int mayo_open(const mayo_params_t *p, unsigned char *m,
  *
  * The implementation corresponds to Mayo.CompactKeyGen() in the Mayo spec.
  * The caller is responsible to allocate sufficient memory to hold pk and sk.
- * 
+ *
  * outputs a pair (csk, cpk) \in B^{csk_bytes} x B^{cpk_bytes}, where csk and
  * cpk are compact representations of a Mayo secret key and public key
  *

src/CMakeLists.txt

@@ -1,10 +1,10 @@
-set(SOURCE_FILES_COMMON_SYS common/randombytes_system.c common/aes_c.c common/aes128ctr.c common/fips202.c common/mem.c)
+set(SOURCE_FILES_COMMON_SYS common/randombytes_system.c common/aes_c.c common/aes128ctr.c common/aes_neon.c common/fips202.c common/mem.c)
 
 add_library(mayo_common_sys ${SOURCE_FILES_COMMON_SYS})
 target_include_directories(mayo_common_sys PRIVATE common ../include)
 target_compile_options(mayo_common_sys PUBLIC ${C_OPT_FLAGS})
 
-set(SOURCE_FILES_COMMON_TEST common/randombytes_ctrdrbg.c common/aes_c.c common/aes128ctr.c common/fips202.c common/mem.c)
+set(SOURCE_FILES_COMMON_TEST common/randombytes_ctrdrbg.c common/aes_c.c common/aes128ctr.c common/aes_neon.c common/fips202.c common/mem.c)
 
 add_library(mayo_common_test ${SOURCE_FILES_COMMON_TEST})
 target_include_directories(mayo_common_test PRIVATE common ../include)
@@ -21,12 +21,22 @@ if (ENABLE_AESNI)
     target_compile_definitions(mayo_common_test PUBLIC ENABLE_AESNI)
 endif()
 
+if (ENABLE_AESNEON)
+    message("AES-NEON enabled")
+    target_compile_definitions(mayo_common_sys PUBLIC ENABLE_AESNEON)
+    target_compile_definitions(mayo_common_test PUBLIC ENABLE_AESNEON)
+endif()
+
 set(SOURCE_FILES_MAYO mayo.c params.c arithmetic.c)
 
 if (${MAYO_BUILD_TYPE} MATCHES "avx2")
     message("Building for avx2")
     set(INC_PLATFORM ${PROJECT_SOURCE_DIR}/src/AVX2)
     add_definitions(-DMAYO_AVX)
+elseif (${MAYO_BUILD_TYPE} MATCHES "neon")
+    message("Building for neon")
+    set(INC_PLATFORM ${PROJECT_SOURCE_DIR}/src/neon)
+    add_definitions(-DMAYO_NEON)
 else()
     set(INC_PLATFORM ${PROJECT_SOURCE_DIR}/src/generic)
 endif()