add RVV support (#1000)

Author: camel-cdr

.github/workflows/ubuntu-riscv64-rvv.yml

@@ -0,0 +1,50 @@
+name: Ubuntu RISC-V Vector Extension
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+    paths-ignore:
+      - '**.md'
+      - 'docs/**'
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+      - 'docs/**'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  ubuntu-build:
+    strategy:
+      fail-fast: false
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - name: Setup ENV
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y cmake curl ninja-build \
+                                  g++-riscv64-linux-gnu \
+                                  gcc-riscv64-linux-gnu \
+                                  qemu-user-static  qemu-user
+      - name: Build
+        run: |
+          export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
+          export QEMU_CPU="rv64,vlen=128"
+          cmake -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains-dev/riscv64-rvv.cmake \
+                -DADA_TESTING=ON \
+                -DADA_USE_SIMDUTF=ON \
+                -DCMAKE_BUILD_TYPE=Release \
+                -G Ninja -B build
+          cmake --build build -j=4
+      - name: Test
+        run: |
+          export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
+          export QEMU_CPU="rv64,v=on,vlen=128"
+          ctest --output-on-failure --test-dir build

cmake/toolchains-dev/README.md

@@ -27,3 +27,22 @@ $ ctest --output-on-failure --test-dir build
 or
 $ qemu-loongarch64 build/singleheader/cdemo
 ```
+
+# RISC-V Vector Extension
+
+The RISC-V Vector optimizations are supported by GCC-13, CLANG-16 and above.
+
+Native builds will use the RVV code, if the specified `-march` ISA string or default target ISA supports the V extension.
+
+For cross compilation, you may need to adjust the cross compiler target prefix in the toolchain file from `riscv64-linux-gnu` to e.g. `riscv64-unknown-linux-gnu` when using https://github.com/riscv-collab/riscv-gnu-toolchain.
+
+```
+# For Debian/Ubuntu
+$ sudo apt install g++-riscv64-linux-gnu qemu-system-riscv qemu-user
+$ mkdir build; cd build
+$ export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
+$ export QEMU_CPU="rv64,v=on"
+$ mkdir build && cd build
+$ cmake -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains-dev/riscv64-rvv.cmake -DADA_TESTING=ON ..
+$ cmake --build -j $(nproc)
+```

cmake/toolchains-dev/riscv64-rvv.cmake

@@ -0,0 +1,19 @@
+# Usage:
+# $ cmake -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains-dev/riscv64-rvv.cmake
+set(CMAKE_SYSTEM_NAME Generic)
+
+set(target       riscv64-linux-gnu)
+set(c_compiler   gcc)
+set(cxx_compiler g++)
+
+set(CMAKE_C_COMPILER   "${target}-${c_compiler}")
+set(CMAKE_CXX_COMPILER "${target}-${cxx_compiler}")
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+
+set(CMAKE_CROSSCOMPILING_EMULATOR "qemu-riscv64")
+
+set(CMAKE_CXX_FLAGS "-march=rv64gcv")

include/ada/common_defs.h

@@ -247,6 +247,11 @@ namespace ada {
 #define ADA_LSX 1
 #endif
 
+#if defined(__riscv_v) && __riscv_v_intrinsic >= 11000
+// Support RVV intrinsics v0.11 and above
+#define ADA_RVV 1
+#endif
+
 #ifndef __has_cpp_attribute
 #define ada_lifetime_bound
 #elif __has_cpp_attribute(msvc::lifetimebound)

src/helpers.cpp

@@ -1,10 +1,10 @@
+#include <cstring>
+#include <sstream>
+
 #include "ada/checkers-inl.h"
 #include "ada/common_defs.h"
 #include "ada/scheme.h"
 
-#include <cstring>
-#include <sstream>
-
 namespace ada::helpers {
 
 template <typename out_iter>
@@ -355,6 +355,42 @@ ada_really_inline size_t find_next_host_delimiter_special(
   }
   return size_t(view.length());
 }
+#elif ADA_RVV
+ada_really_inline size_t find_next_host_delimiter_special(
+    std::string_view view, size_t location) noexcept {
+  // The LUT approach was a bit slower on the SpacemiT X60, but I could see it
+  // beeing faster on future hardware.
+#if 0
+  // LUT generated using: s=":/\\?["; list(zip([((ord(c)>>2)&0xF)for c in s],s))
+  static const uint8_t tbl[16] = {
+    0xF, 0, 0, 0, 0, 0, '[', '\\', 0, 0, 0, '/', 0, 0, ':', '?'
+  };
+  vuint8m1_t vtbl = __riscv_vle8_v_u8m1(tbl, 16);
+#endif
+  uint8_t* src = (uint8_t*)view.data() + location;
+  for (size_t vl, n = view.size() - location; n > 0;
+       n -= vl, src += vl, location += vl) {
+    vl = __riscv_vsetvl_e8m1(n);
+    vuint8m1_t v = __riscv_vle8_v_u8m1(src, vl);
+#if 0
+    vuint8m1_t vidx = __riscv_vand(__riscv_vsrl(v, 2, vl), 0xF, vl);
+    vuint8m1_t vlut = __riscv_vrgather(vtbl, vidx, vl);
+    vbool8_t m = __riscv_vmseq(v, vlut, vl);
+#else
+    vbool8_t m1 = __riscv_vmseq(v, ':', vl);
+    vbool8_t m2 = __riscv_vmseq(v, '/', vl);
+    vbool8_t m3 = __riscv_vmseq(v, '?', vl);
+    vbool8_t m4 = __riscv_vmseq(v, '[', vl);
+    vbool8_t m5 = __riscv_vmseq(v, '\\', vl);
+    vbool8_t m = __riscv_vmor(
+        __riscv_vmor(__riscv_vmor(m1, m2, vl), __riscv_vmor(m3, m4, vl), vl),
+        m5, vl);
+#endif
+    long idx = __riscv_vfirst(m, vl);
+    if (idx >= 0) return location + idx;
+  }
+  return size_t(view.size());
+}
 #else
 // : / [ \\ ?
 static constexpr std::array<uint8_t, 256> special_host_delimiters =
@@ -535,6 +571,25 @@ ada_really_inline size_t find_next_host_delimiter(std::string_view view,
   }
   return size_t(view.length());
 }
+#elif ADA_RVV
+ada_really_inline size_t find_next_host_delimiter(std::string_view view,
+                                                  size_t location) noexcept {
+  uint8_t* src = (uint8_t*)view.data() + location;
+  for (size_t vl, n = view.size() - location; n > 0;
+       n -= vl, src += vl, location += vl) {
+    vl = __riscv_vsetvl_e8m1(n);
+    vuint8m1_t v = __riscv_vle8_v_u8m1(src, vl);
+    vbool8_t m1 = __riscv_vmseq(v, ':', vl);
+    vbool8_t m2 = __riscv_vmseq(v, '/', vl);
+    vbool8_t m3 = __riscv_vmseq(v, '?', vl);
+    vbool8_t m4 = __riscv_vmseq(v, '[', vl);
+    vbool8_t m =
+        __riscv_vmor(__riscv_vmor(m1, m2, vl), __riscv_vmor(m3, m4, vl), vl);
+    long idx = __riscv_vfirst(m, vl);
+    if (idx >= 0) return location + idx;
+  }
+  return size_t(view.size());
+}
 #else
 // : / [ ?
 static constexpr std::array<uint8_t, 256> host_delimiters = []() consteval {

src/unicode.cpp

@@ -1,7 +1,8 @@
-#include "ada/common_defs.h"
+#include "ada/unicode.h"
+
 #include "ada/character_sets-inl.h"
 #include "ada/character_sets.h"
-#include "ada/unicode.h"
+#include "ada/common_defs.h"
 #include "ada/log.h"
 
 ADA_PUSH_DISABLE_ALL_WARNINGS
@@ -15,6 +16,8 @@ ADA_POP_DISABLE_WARNINGS
 #include <emmintrin.h>
 #elif ADA_LSX
 #include <lsxintrin.h>
+#elif ADA_RVV
+#include <riscv_vector.h>
 #endif
 
 #include <ranges>
@@ -155,6 +158,22 @@ ada_really_inline bool has_tabs_or_newline(
   if (__lsx_bz_v(running)) return false;
   return true;
 }
+#elif ADA_RVV
+ada_really_inline bool has_tabs_or_newline(
+    std::string_view user_input) noexcept {
+  uint8_t* src = (uint8_t*)user_input.data();
+  for (size_t vl, n = user_input.size(); n > 0; n -= vl, src += vl) {
+    vl = __riscv_vsetvl_e8m1(n);
+    vuint8m1_t v = __riscv_vle8_v_u8m1(src, vl);
+    vbool8_t m1 = __riscv_vmseq(v, '\r', vl);
+    vbool8_t m2 = __riscv_vmseq(v, '\n', vl);
+    vbool8_t m3 = __riscv_vmseq(v, '\t', vl);
+    vbool8_t m = __riscv_vmor(__riscv_vmor(m1, m2, vl), m3, vl);
+    long idx = __riscv_vfirst(m, vl);
+    if (idx >= 0) return true;
+  }
+  return false;
+}
 #else
 ada_really_inline bool has_tabs_or_newline(
     std::string_view user_input) noexcept {