perf: use simdutf for idna (#960)

Author: CarlosEduR

.github/workflows/ubuntu.yml

@@ -28,13 +28,14 @@ jobs:
         shared: [ON, OFF]
         cxx: [g++-12, clang++-15]
         runs-on: [ubuntu-22.04, ubuntu-22.04-arm]
+        simdutf: [OFF, ON]
     runs-on: ${{matrix.runs-on}}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       - name: Setup Ninja
         run: sudo apt-get install ninja-build
       - name: Prepare
-        run: cmake -D ADA_TESTING=ON -D ADA_BENCHMARKS=ON -DBUILD_SHARED_LIBS=${{matrix.shared}} -G Ninja -B build
+        run: cmake -D ADA_TESTING=ON -D ADA_BENCHMARKS=ON -DBUILD_SHARED_LIBS=${{matrix.shared}} -D ADA_USE_SIMDUTF=${{matrix.simdutf}} -G Ninja -B build
         env:
           CXX: ${{matrix.cxx}}
       - name: Build

CMakeLists.txt

@@ -20,6 +20,7 @@ option(ADA_TESTING "Whether to build tests." OFF)
 option(ADA_BENCHMARKS "Whether to build benchmarks." OFF)
 option(ADA_TOOLS "Whether to build tools." OFF)
 option(ADA_BUILD_SINGLE_HEADER_LIB "Whether to build the lib from the single-header files" OFF)
+option(ADA_USE_SIMDUTF "Whether to use SIMDUTF for IDNA" OFF)
 # There are cases where when embedding ada as a dependency for other CMake
 # projects as submodules or subdirectories (via FetchContent) can lead to
 # errors due to CPM, so this is here to support disabling all the testing
@@ -78,6 +79,14 @@ if(ADA_TESTING OR ADA_BENCHMARKS OR ADA_TOOLS)
   endif(ADA_TESTING AND EMSCRIPTEN)
 endif()
 
+if(ADA_USE_SIMDUTF)
+  CPMAddPackage(
+    NAME simdutf
+    GITHUB_REPOSITORY simdutf/simdutf
+    VERSION 7.3.2
+    OPTIONS "SIMDUTF_TESTS OFF" "SIMDUTF_TOOLS OFF"
+  )
+endif()
 
 add_library(ada::ada ALIAS ada)
 

README.md

@@ -319,6 +319,12 @@ With tests (requires available local packages):
 - **Build**: `cmake -B build -DADA_TESTING=ON -D CPM_USE_LOCAL_PACKAGES=ON && cmake --build build`
 - **Test**: `ctest --output-on-failure --test-dir build`
 
+### Build options
+
+Ada provides several CMake options to customize the build:
+
+- `ADA_USE_SIMDUTF`: Enables SIMD-accelerated Unicode processing via simdutf (default: OFF)
+
 Windows users need additional flags to specify the build configuration, e.g. `--config Release`.
 
 The project can also be built via docker using default docker file of repository with following commands.

singleheader/CMakeLists.txt

@@ -44,21 +44,38 @@ if (Python3_Interpreter_FOUND)
   #
   add_library(ada-singleheader-include-source INTERFACE)
   target_include_directories(ada-singleheader-include-source INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
+  if (ADA_USE_SIMDUTF)
+    target_include_directories(ada-singleheader-include-source INTERFACE ${simdutf_SOURCE_DIR}/include)
+  endif()
   add_dependencies(ada-singleheader-include-source ada-singleheader-files)
 
   add_library(ada-singleheader-source INTERFACE)
   target_sources(ada-singleheader-source INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/ada.cpp>)
   target_link_libraries(ada-singleheader-source INTERFACE ada-singleheader-include-source)
+  if (ADA_USE_SIMDUTF)
+    target_link_libraries(ada-singleheader-source INTERFACE simdutf)
+  endif()
+
   if (ADA_TESTING OR ADA_BUILD_SINGLE_HEADER_LIB)
     add_library(ada-singleheader-lib STATIC $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/ada.cpp>)
+    if (ADA_USE_SIMDUTF)
+      target_link_libraries(ada-singleheader-lib simdutf)
+      target_include_directories(ada-singleheader-lib PRIVATE ${simdutf_SOURCE_DIR}/include)
+    endif()
   endif(ADA_TESTING OR ADA_BUILD_SINGLE_HEADER_LIB)
 
   if (ADA_TESTING)
     add_executable(demo $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/demo.cpp>)
     target_link_libraries(demo ada-singleheader-include-source)
+    if (ADA_USE_SIMDUTF)
+      target_link_libraries(demo simdutf)
+    endif()
 
     add_executable(demo_no_url_pattern $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/demo.cpp>)
     target_link_libraries(demo_no_url_pattern ada-singleheader-include-source)
+    if (ADA_USE_SIMDUTF)
+      target_link_libraries(demo_no_url_pattern simdutf)
+    endif()
     target_compile_definitions(demo_no_url_pattern PRIVATE ADA_INCLUDE_URL_PATTERN=0)
 
     add_test(demo_no_url_pattern demo_no_url_pattern)

src/CMakeLists.txt

@@ -65,3 +65,8 @@ if(ADA_INCLUDE_URL_PATTERN)
 else()
   target_compile_definitions(ada PRIVATE ADA_INCLUDE_URL_PATTERN=0)
 endif()
+
+if (ADA_USE_SIMDUTF)
+  target_link_libraries(ada PRIVATE simdutf)
+  target_compile_definitions(ada PRIVATE ADA_USE_SIMDUTF)
+endif()

src/ada_idna.cpp

@@ -1,4 +1,4 @@
-/* auto-generated on 2025-03-08 13:17:11 -0500. Do not edit! */
+/* auto-generated on 2025-06-26 23:04:30 -0300. Do not edit! */
 /* begin file src/idna.cpp */
 /* begin file src/unicode_transcoding.cpp */
 
@@ -8021,7 +8021,7 @@ bool utf32_to_punycode(std::u32string_view input, std::string &out) {
       ++h;
       out.push_back(char(c));
     }
-    if (c > 0x10ffff || (c >= 0xd880 && c < 0xe000)) {
+    if (c > 0x10ffff || (c >= 0xd800 && c < 0xe000)) {
       return false;
     }
   }
@@ -9411,6 +9411,10 @@ bool is_label_valid(const std::u32string_view label) {
 #include <ranges>
 
 
+#ifdef ADA_USE_SIMDUTF
+#include "simdutf.h"
+#endif
+
 namespace ada::idna {
 
 bool constexpr is_ascii(std::u32string_view view) {
@@ -9523,11 +9527,20 @@ std::string to_ascii(std::string_view ut8_string) {
   }
   static const std::string error = "";
   // We convert to UTF-32
+
+#ifdef ADA_USE_SIMDUTF
+  size_t utf32_length =
+      simdutf::utf32_length_from_utf8(ut8_string.data(), ut8_string.size());
+  std::u32string utf32(utf32_length, '\0');
+  size_t actual_utf32_length = simdutf::convert_utf8_to_utf32(
+      ut8_string.data(), ut8_string.size(), utf32.data());
+#else
   size_t utf32_length =
       ada::idna::utf32_length_from_utf8(ut8_string.data(), ut8_string.size());
   std::u32string utf32(utf32_length, '\0');
   size_t actual_utf32_length = ada::idna::utf8_to_utf32(
       ut8_string.data(), ut8_string.size(), utf32.data());
+#endif
   if (actual_utf32_length == 0) {
     return error;
   }
@@ -9619,6 +9632,10 @@ std::string to_ascii(std::string_view ut8_string) {
 #include <string>
 
 
+#ifdef ADA_USE_SIMDUTF
+#include "simdutf.h"
+#endif
+
 namespace ada::idna {
 std::string to_unicode(std::string_view input) {
   std::string output;
@@ -9637,11 +9654,19 @@ std::string to_unicode(std::string_view input) {
       if (ada::idna::verify_punycode(label_view)) {
         std::u32string tmp_buffer;
         if (ada::idna::punycode_to_utf32(label_view, tmp_buffer)) {
+#ifdef ADA_USE_SIMDUTF
+          auto utf8_size = simdutf::utf8_length_from_utf32(tmp_buffer.data(),
+                                                           tmp_buffer.size());
+          std::string final_utf8(utf8_size, '\0');
+          simdutf::convert_utf32_to_utf8(tmp_buffer.data(), tmp_buffer.size(),
+                                         final_utf8.data());
+#else
           auto utf8_size = ada::idna::utf8_length_from_utf32(tmp_buffer.data(),
                                                              tmp_buffer.size());
           std::string final_utf8(utf8_size, '\0');
           ada::idna::utf32_to_utf8(tmp_buffer.data(), tmp_buffer.size(),
                                    final_utf8.data());
+#endif
           output.append(final_utf8);
         } else {
           // ToUnicode never fails.  If any step fails, then the original input