RISC-V: Added vector and hardware AES support

.github/workflows/c-cpp.yml

@@ -20,7 +20,7 @@ jobs:
           - {arch: armhf, branch: latest-stable}
           - {arch: armv7, branch: latest-stable}
           - {arch: ppc64le, branch: latest-stable}
-          - {arch: riscv64, branch: edge}
+          - {arch: riscv64, branch: latest-stable}
           - {arch: s390x, branch: latest-stable}
 
     steps:
@@ -45,7 +45,7 @@ jobs:
       run: |
         mkdir build
         cd build
-        cmake ..
+        cmake .. -DCMAKE_BUILD_TYPE=Release -DARCH=native
         make -j$(nproc)
 
     - name: Run tests
@@ -61,8 +61,7 @@ jobs:
     strategy:
       matrix:
         config:
-          - {os: ubuntu-20.04, c: gcc-11, cpp: g++-11}
-          - {os: ubuntu-22.04, c: gcc-12, cpp: g++-12}
+          - {os: ubuntu-24.04, c: gcc-14, cpp: g++-14}
 
     steps:
     - name: Install dependencies
@@ -165,7 +164,7 @@ jobs:
 
     strategy:
       matrix:
-        os: [macos-13, macos-14, macos-15]
+        os: [macos-14, macos-15]
 
     steps:
     - name: Checkout repository
@@ -197,13 +196,13 @@ jobs:
         os:
           - name: freebsd
             architecture: x86-64
-            version: '13.2'
-            host: ubuntu-22.04
+            version: '13.3'
+            host: ubuntu-latest
 
           - name: freebsd
             architecture: arm64
-            version: '13.2'
-            host: ubuntu-22.04
+            version: '13.3'
+            host: ubuntu-latest
 
     steps:
     - name: Checkout repository
@@ -212,11 +211,13 @@ jobs:
         submodules: recursive
 
     - name: Build RandomX
-      uses: cross-platform-actions/action@v0.19.0
+      uses: cross-platform-actions/action@v0.24.0
       with:
         operating_system: ${{ matrix.os.name }}
         architecture: ${{ matrix.os.architecture }}
         version: ${{ matrix.os.version }}
+        memory: 12G
+        cpu_count: 4
         shell: bash
         run: |
           sudo pkg install -y cmake

CMakeLists.txt

@@ -176,37 +176,149 @@ endif()
 # RISC-V
 if(ARCH_ID STREQUAL "riscv64")
   list(APPEND randomx_sources
+    src/aes_hash_rv64_vector.cpp
+    src/aes_hash_rv64_zvkned.cpp
     src/jit_compiler_rv64_static.S
-    src/jit_compiler_rv64.cpp)
+    src/jit_compiler_rv64.cpp
+    src/jit_compiler_rv64_vector.cpp
+    src/jit_compiler_rv64_vector_static.S
+    src/cpu_rv64.S)
+
   # cheat because cmake and ccache hate each other
   set_property(SOURCE src/jit_compiler_rv64_static.S PROPERTY LANGUAGE C)
-  set_property(SOURCE src/jit_compiler_rv64_static.S PROPERTY XCODE_EXPLICIT_FILE_TYPE sourcecode.asm)
+  set_property(SOURCE src/jit_compiler_rv64_vector_static.S PROPERTY LANGUAGE C)
+  set_property(SOURCE src/cpu_rv64.S PROPERTY LANGUAGE C)
 
   # default build uses the RV64GC baseline
   set(RVARCH "rv64gc")
 
   # for native builds, enable Zba and Zbb if supported by the CPU
   if(ARCH STREQUAL "native")
     enable_language(ASM)
+
+    try_run(RANDOMX_VECTOR_RUN_FAIL
+        RANDOMX_VECTOR_COMPILE_OK
+        ${CMAKE_CURRENT_BINARY_DIR}/
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/tests/riscv64_vector.s
+        COMPILE_DEFINITIONS "-march=rv64gcv")
+
+    if (RANDOMX_VECTOR_COMPILE_OK AND NOT RANDOMX_VECTOR_RUN_FAIL)
+        set(RVARCH_V ON)
+        message(STATUS "RISC-V vector extension detected")
+    else()
+        set(RVARCH_V OFF)
+    endif()
+
+    try_run(RANDOMX_ZICBOP_RUN_FAIL
+        RANDOMX_ZICBOP_COMPILE_OK
+        ${CMAKE_CURRENT_BINARY_DIR}/
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/tests/riscv64_zicbop.s
+        COMPILE_DEFINITIONS "-march=rv64gc_zicbop")
+
+    if (RANDOMX_ZICBOP_COMPILE_OK AND NOT RANDOMX_ZICBOP_RUN_FAIL)
+        set(RVARCH_ZICBOP ON)
+        message(STATUS "RISC-V zicbop extension detected")
+    else()
+        set(RVARCH_ZICBOP OFF)
+    endif()
+
     try_run(RANDOMX_ZBA_RUN_FAIL
         RANDOMX_ZBA_COMPILE_OK
         ${CMAKE_CURRENT_BINARY_DIR}/
         ${CMAKE_CURRENT_SOURCE_DIR}/src/tests/riscv64_zba.s
         COMPILE_DEFINITIONS "-march=rv64gc_zba")
+
     if (RANDOMX_ZBA_COMPILE_OK AND NOT RANDOMX_ZBA_RUN_FAIL)
-      set(RVARCH "${RVARCH}_zba")
+        set(RVARCH_ZBA ON)
+        message(STATUS "RISC-V zba extension detected")
+    else()
+        set(RVARCH_ZBA OFF)
     endif()
+
     try_run(RANDOMX_ZBB_RUN_FAIL
         RANDOMX_ZBB_COMPILE_OK
         ${CMAKE_CURRENT_BINARY_DIR}/
         ${CMAKE_CURRENT_SOURCE_DIR}/src/tests/riscv64_zbb.s
         COMPILE_DEFINITIONS "-march=rv64gc_zbb")
+
     if (RANDOMX_ZBB_COMPILE_OK AND NOT RANDOMX_ZBB_RUN_FAIL)
-      set(RVARCH "${RVARCH}_zbb")
+        set(RVARCH_ZBB ON)
+        message(STATUS "RISC-V zbb extension detected")
+    else()
+        set(RVARCH_ZBB OFF)
+    endif()
+
+    try_run(RANDOMX_ZVKB_RUN_FAIL
+        RANDOMX_ZVKB_COMPILE_OK
+        ${CMAKE_CURRENT_BINARY_DIR}/
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/tests/riscv64_zvkb.s
+        COMPILE_DEFINITIONS "-march=rv64gcv_zvkb")
+
+    if (RANDOMX_ZVKB_COMPILE_OK AND NOT RANDOMX_ZVKB_RUN_FAIL)
+        set(RVARCH_ZVKB ON)
+        message(STATUS "RISC-V zvkb extension detected")
+    else()
+        set(RVARCH_ZVKB OFF)
+    endif()
+
+    try_run(RANDOMX_ZVKNED_RUN_FAIL
+        RANDOMX_ZVKNED_COMPILE_OK
+        ${CMAKE_CURRENT_BINARY_DIR}/
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/tests/riscv64_zvkned.s
+        COMPILE_DEFINITIONS "-march=rv64gcv_zvkned")
+
+    if (RANDOMX_ZVKNED_COMPILE_OK AND NOT RANDOMX_ZVKNED_RUN_FAIL)
+        set(RVARCH_ZVKNED ON)
+        message(STATUS "RISC-V zvkned extension detected")
+    else()
+        set(RVARCH_ZVKNED OFF)
+    endif()
+
+    # for native builds, enable Zba and Zbb if supported by the CPU
+    if (ARCH STREQUAL "native")
+        if (RVARCH_V)
+            set(RVARCH "${RVARCH}v")
+        endif()
+        if (RVARCH_ZICBOP)
+            set(RVARCH "${RVARCH}_zicbop")
+        endif()
+        if (RVARCH_ZBA)
+            set(RVARCH "${RVARCH}_zba")
+        endif()
+        if (RVARCH_ZBB)
+            set(RVARCH "${RVARCH}_zbb")
+        endif()
+        if (RVARCH_ZVKB)
+            set(RVARCH "${RVARCH}_zvkb")
+        endif()
+        if (RVARCH_ZVKNED)
+            set(RVARCH "${RVARCH}_zvkned")
+        endif()
     endif()
   endif()
 
   add_flag("-march=${RVARCH}")
+
+  set(RV64_VECTOR_FILE_ARCH "rv64gcv")
+
+  if (ARCH STREQUAL "native")
+    if (RVARCH_ZICBOP)
+      set(RV64_VECTOR_FILE_ARCH "${RV64_VECTOR_FILE_ARCH}_zicbop")
+    endif()
+    if (RVARCH_ZBA)
+      set(RV64_VECTOR_FILE_ARCH "${RV64_VECTOR_FILE_ARCH}_zba")
+    endif()
+    if (RVARCH_ZBB)
+      set(RV64_VECTOR_FILE_ARCH "${RV64_VECTOR_FILE_ARCH}_zbb")
+    endif()
+    if (RVARCH_ZVKB)
+      set(RV64_VECTOR_FILE_ARCH "${RV64_VECTOR_FILE_ARCH}_zvkb")
+    endif()
+  endif()
+
+  set_source_files_properties(src/jit_compiler_rv64_vector_static.S PROPERTIES COMPILE_FLAGS "-march=${RV64_VECTOR_FILE_ARCH}")
+  set_source_files_properties(src/aes_hash_rv64_vector.cpp PROPERTIES COMPILE_FLAGS "-O3 -march=${RV64_VECTOR_FILE_ARCH}")
+  set_source_files_properties(src/aes_hash_rv64_zvkned.cpp PROPERTIES COMPILE_FLAGS "-O3 -march=${RV64_VECTOR_FILE_ARCH}_zvkned")
 endif()
 
 set(RANDOMX_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/src" CACHE STRING "RandomX Include path")

src/aes_hash.cpp

@@ -27,8 +27,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "soft_aes.h"
+#include "cpu.hpp"
 #include <cassert>
 
+#ifdef __riscv
+#include "aes_hash_rv64_zvkned.hpp"
+#include "aes_hash_rv64_vector.hpp"
+#endif
+
 //NOTE: The functions below were tuned for maximum performance
 //and are not cryptographically secure outside of the scope of RandomX.
 //It's not recommended to use them as general hash functions and PRNGs.
@@ -60,6 +66,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 template<bool softAes>
 void hashAes1Rx4(const void *input, size_t inputSize, void *hash) {
 	assert(inputSize % 64 == 0);
+
+#ifdef __riscv
+	if (randomx::cpu.hasAes()) {
+		hashAes1Rx4_zvkned(input, inputSize, hash);
+		return;
+	}
+
+	if (randomx::cpu.hasRVV() && (randomx::cpu.getRVV_Length() >= 256)) {
+		hashAes1Rx4_RVV(input, inputSize, hash);
+		return;
+	}
+#endif
+
 	const uint8_t* inptr = (uint8_t*)input;
 	const uint8_t* inputEnd = inptr + inputSize;
 
@@ -132,6 +151,19 @@ template void hashAes1Rx4<true>(const void *input, size_t inputSize, void *hash)
 template<bool softAes>
 void fillAes1Rx4(void *state, size_t outputSize, void *buffer) {
 	assert(outputSize % 64 == 0);
+
+#ifdef __riscv
+	if (randomx::cpu.hasAes()) {
+		fillAes1Rx4_zvkned(state, outputSize, buffer);
+		return;
+	}
+
+	if (randomx::cpu.hasRVV() && (randomx::cpu.getRVV_Length() >= 256)) {
+		fillAes1Rx4_RVV(state, outputSize, buffer);
+		return;
+	}
+#endif
+
 	const uint8_t* outptr = (uint8_t*)buffer;
 	const uint8_t* outputEnd = outptr + outputSize;
 
@@ -187,6 +219,19 @@ template void fillAes1Rx4<false>(void *state, size_t outputSize, void *buffer);
 template<bool softAes>
 void fillAes4Rx4(void *state, size_t outputSize, void *buffer) {
 	assert(outputSize % 64 == 0);
+
+#ifdef __riscv
+	if (randomx::cpu.hasAes()) {
+		fillAes4Rx4_zvkned(state, outputSize, buffer);
+		return;
+	}
+
+	if (randomx::cpu.hasRVV() && (randomx::cpu.getRVV_Length() >= 256)) {
+		fillAes4Rx4_RVV(state, outputSize, buffer);
+		return;
+	}
+#endif
+
 	const uint8_t* outptr = (uint8_t*)buffer;
 	const uint8_t* outputEnd = outptr + outputSize;
 
@@ -242,6 +287,18 @@ template void fillAes4Rx4<false>(void *state, size_t outputSize, void *buffer);
 
 template<bool softAes>
 void hashAndFillAes1Rx4(void *scratchpad, size_t scratchpadSize, void *hash, void* fill_state) {
+#ifdef __riscv
+	if (randomx::cpu.hasAes()) {
+		hashAndFillAes1Rx4_zvkned(scratchpad, scratchpadSize, hash, fill_state);
+		return;
+	}
+
+	if (randomx::cpu.hasRVV() && (randomx::cpu.getRVV_Length() >= 256)) {
+		hashAndFillAes1Rx4_RVV(scratchpad, scratchpadSize, hash, fill_state);
+		return;
+	}
+#endif
+
 	uint8_t* scratchpadPtr = (uint8_t*)scratchpad;
 	const uint8_t* scratchpadEnd = scratchpadPtr + scratchpadSize;