Uploading flame-graphs + guide on how to call perf and demingle.

.circleci/config.yml

@@ -0,0 +1,316 @@
+version: 2.1
+
+
+# We constantly run out of memory so please do not use parallelism (-j, -j4).
+
+# Reusable image / compiler definitions
+executors:
+  gcc8:
+    docker:
+      - image: conanio/gcc8
+        environment:
+          CXX: g++-8
+          CC: gcc-8
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  gcc9:
+    docker:
+      - image: conanio/gcc9
+        environment:
+          CXX: g++-9
+          CC: gcc-9
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  gcc10:
+    docker:
+      - image: conanio/gcc10
+        environment:
+          CXX: g++-10
+          CC: gcc-10
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  clang10:
+    docker:
+      - image: conanio/clang10
+        environment:
+          CXX: clang++-10
+          CC: clang-10
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  clang9:
+    docker:
+      - image: conanio/clang9
+        environment:
+          CXX: clang++-9
+          CC: clang-9
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  clang6:
+    docker:
+      - image: conanio/clang60
+        environment:
+          CXX: clang++-6.0
+          CC: clang-6.0
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+# Reusable test commands (and initializer for clang 6)
+commands:
+  dependency_restore:
+    steps:
+      - restore_cache:
+          keys:
+            - cmake-cache-{{ checksum "dependencies/CMakeLists.txt" }}
+
+  dependency_cache:
+    steps:
+      - save_cache:
+          key: cmake-cache-{{ checksum "dependencies/CMakeLists.txt" }}
+          paths:
+            - dependencies/.cache
+
+  install_cmake:
+    steps:
+      - run: apt-get update -qq
+      - run: apt-get install -y cmake
+
+  cmake_prep:
+    steps:
+      - checkout
+      - run: mkdir -p build
+
+  cmake_build_cache:
+    steps:
+      - cmake_prep
+      - dependency_restore
+      - run: cmake  -DSIMDJSON_DEVELOPER_MODE=ON $CMAKE_FLAGS -DCMAKE_INSTALL_PREFIX:PATH=destination -B build .
+      - dependency_cache # dependencies are produced in the configure step
+
+  cmake_build:
+    steps:
+      - cmake_build_cache
+      - run: cmake  --build build
+
+  cmake_test:
+    steps:
+      - cmake_build
+      - run: |
+          cd build &&
+          tools/json2json -h &&
+          ctest $CTEST_FLAGS -L acceptance &&
+          ctest $CTEST_FLAGS -LE acceptance -LE explicitonly
+
+  cmake_assert_test:
+    steps:
+      - run: |
+          cd build &&
+          tools/json2json -h &&
+          ctest $CTEST_FLAGS -L assert
+
+  cmake_test_all:
+    steps:
+      - cmake_build
+      - run: |
+          cd build &&
+          tools/json2json -h &&
+          ctest $CTEST_FLAGS -DSIMDJSON_IMPLEMENTATION="haswell;westmere;fallback" -L acceptance -LE per_implementation &&
+          SIMDJSON_FORCE_IMPLEMENTATION=haswell ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
+          SIMDJSON_FORCE_IMPLEMENTATION=westmere ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
+          SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
+          ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
+
+
+  cmake_perftest:
+    steps:
+      - cmake_build_cache
+      - run: |
+          cmake -DSIMDJSON_ENABLE_DOM_CHECKPERF=ON --build  build --target checkperf &&
+          cd build &&
+          ctest --output-on-failure -R checkperf
+
+  # we not only want cmake to build and run tests, but we want also a successful installation from which we can build, link and run programs
+  cmake_install_test: # this version builds, install, test and then verify from the installation
+    steps:
+      - run: cd build && make install
+      - run: echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Ibuild/destination/include -Lbuild/destination/lib -std=c++17 -Wl,-rpath,build/destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json
+
+  cmake_installed_test_cxx20: # assuming that it was installed, this tries to build using C++20
+    steps:
+      - run: echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Ibuild/destination/include -Lbuild/destination/lib -std=c++20 -Wl,-rpath,build/destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json
+
+jobs:
+
+  # static
+  justlib-gcc10:
+    description: Build just the library, install it and do a basic test
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_JUST_LIBRARY=ON }
+    steps: [ cmake_build, cmake_install_test, cmake_installed_test_cxx20 ]
+  assert-gcc10:
+    description: Build the library with asserts on, install it and run tests
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DCMAKE_CXX_FLAGS_RELEASE=-O3 }
+    steps: [ cmake_test, cmake_assert_test ]
+  assert-clang10:
+    description: Build just the library, install it and do a basic test
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DCMAKE_CXX_FLAGS_RELEASE=-O3 }
+    steps: [ cmake_test, cmake_assert_test ]
+  gcc10-perftest:
+    description: Build and run performance tests on GCC 10 and AVX 2 with a cmake static build, this test performance regression
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_perftest ]
+  gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake static build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
+  clang6:
+    description: Build and run tests on clang 6 and AVX 2 with a cmake static build
+    executor: clang6
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+  clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake static build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON  -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
+  # libcpp
+  libcpp-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake static build and libc++
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_USE_LIBCPP=ON  -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
+  # sanitize
+  sanitize-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  sanitize-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  threadsanitize-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE_THREADS=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  threadsanitize-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON  -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE_THREADS=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  # dynamic
+  dynamic-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake dynamic build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON }
+    steps: [ cmake_test, cmake_install_test ]
+  dynamic-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake dynamic build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON }
+    steps: [ cmake_test, cmake_install_test ]
+
+  # unthreaded
+  unthreaded-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 *without* threads
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+  unthreaded-clang10:
+    description: Build and run tests on Clang 10 and AVX 2 *without* threads
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+
+  # noexcept
+  noexcept-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with exceptions off
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+  noexcept-clang10:
+    description: Build and run tests on Clang 10 and AVX 2 with exceptions off
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+
+  #
+  # Misc.
+  #
+
+  # make (test and checkperf)
+  arch-haswell-gcc10:
+    description: Build, run tests and check performance on GCC 10 with -march=haswell
+    executor: gcc10
+    environment: { CXXFLAGS: -march=haswell }
+    steps: [ cmake_test ]
+  arch-nehalem-gcc10:
+    description: Build, run tests and check performance on GCC 10 with -march=nehalem
+    executor: gcc10
+    environment: { CXXFLAGS: -march=nehalem }
+    steps: [ cmake_test ]
+  sanitize-haswell-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
+    executor: gcc10
+    environment: {  CXXFLAGS: -march=haswell, CMAKE_FLAGS: -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  sanitize-haswell-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
+    executor: clang10
+    environment: { CXXFLAGS: -march=haswell, CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON  -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+
+workflows:
+  version: 2.1
+  build_and_test:
+    jobs:
+      # full multi-implementation tests
+      #- gcc7 tested on GitHub actions
+      - gcc10 # do not delete this as it tests our performance
+      - clang6
+      #- clang10 # this gets tested a lot below
+
+      # libc++
+      - libcpp-clang10
+
+      # full single-implementation tests
+      - sanitize-gcc10
+      - sanitize-clang10
+      - threadsanitize-gcc10
+      - threadsanitize-clang10
+      - dynamic-gcc10
+      - dynamic-clang10
+      - unthreaded-gcc10
+      - unthreaded-clang10
+
+      # no exceptions
+      - noexcept-gcc10
+      - noexcept-clang10
+
+      # quicker make single-implementation tests
+      - arch-haswell-gcc10
+      - arch-nehalem-gcc10
+
+
+      # sanitized single-implementation tests
+      - sanitize-haswell-gcc10
+      - sanitize-haswell-clang10
+
+      # testing "just the library"
+      - justlib-gcc10
+
+      # testing asserts
+      - assert-gcc10
+      - assert-clang10
+
+      # TODO add windows: https://circleci.com/docs/2.0/configuration-reference/#windows

.github/ISSUE_TEMPLATE/bug_report.md

@@ -38,7 +38,7 @@ If we cannot reproduce the issue, then we cannot address it. Note that a stack t
 
 It should be possible to trigger the bug by using solely simdjson with our default build setup. If you can only observe the bug within some specific context, with some other software, please reduce the issue first.
 
-**simdjson release**
+**simjson release**
 
 Unless you plan to contribute to simdjson, you should only work from releases. Please be mindful that our main branch may have additional features, bugs and documentation items.
 

.github/pull_request_template.md

@@ -1,53 +1,8 @@
-Short title (summary):
-
-Description
-- What did you change and why? (1-3 sentences)
-- Issue reproduced / related issue: link the issue if relevant (e.g. #123)
-
-Type of change
-- [ ] Bug fix
-- [ ] New feature
-- [ ] Refactor / cleanup
-- [ ] Documentation / tests
-- [ ] Other (please describe):
-
-How to verify / test
-- Add additional tests to verify bugs or new features.
-- If you claim performance gains, you should provide benchmark numbers using high quality benchmarking code.
 
 
-Please read before contributing:
-- CONTRIBUTING: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
-- HACKING: https://github.com/simdjson/simdjson/blob/master/HACKING.md
+Our tests check whether you have introduced trailing white space. If such a test fails, please check the "artifacts button" above, which if you click it gives a link to a downloadable file to help you identify the issue. You can also run scripts/remove_trailing_whitespace.sh locally if you have a bash shell and the sed command available on your system.
 
+If you plan to contribute to simdjson, please read our
 
-
-If you can, we recommend running our tests with the sanitizers turned on.
-For non-Visual Studio users, it is as easy as doing:
-
-
-
-```bash
-cmake -B build -D SIMDJSON_SANITIZE=ON -D SIMDJSON_DEVELOPER_MODE=ON
-cmake --build build
-ctest --test-dir build
-```
-
-
-Our CI checks, among other things, for trailing whitespace. If a test fails for that reason,
-use the "artifacts" button to download the artifact and inspect the problematic lines,
-or run `scripts/remove_trailing_whitespace.sh` locally if you have a bash shell and `sed`.
-
-
-Checklist before submitting
-- [ ] I added/updated tests covering my change (if applicable)
-- [ ] Code builds locally and passes my check
-- [ ] Documentation / README updated if needed
-- [ ] Commits are atomic and messages are clear
-- [ ] I linked the related issue (if applicable)
-
-Final notes
-- For large PRs, prefer smaller incremental PRs or request staged review.
-
-Thanks for the contribution!
-
+CONTRIBUTING guide: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md and our
+HACKING guide: https://github.com/simdjson/simdjson/blob/master/HACKING.md

.github/workflows/aarch64.yml

@@ -1,4 +1,4 @@
-name: Ubuntu aarch64 (GCC 13)
+name: Ubuntu ppc64le (GCC 11)
 
 on:
   push:

.github/workflows/documentation.yml

@@ -2,13 +2,7 @@ name: Doxygen GitHub Pages
 
 on:
   release:
-    # Trigger when a release object is created and when it's published.
-    # Some GitHub flows create a release object then publish it later; include both.
-    types: [created, published]
-  # Also trigger on tag creation pushes so releasing via Git tags still runs the workflow
-  push:
-    tags:
-      - "v*"  # common release tag pattern like v1.2.3
+    types: [created]
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 
@@ -33,7 +27,7 @@ jobs:
       - name: Generate Doxygen Documentation
         run: doxygen
       - name: Deploy to GitHub Pages
-        uses: peaceiris/actions-gh-pages@v4
+        uses: peaceiris/actions-gh-pages@v3
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           publish_dir: doc/api/html

.github/workflows/rvv-1024-clang-18.yml

@@ -1,29 +0,0 @@
-name: Ubuntu rvv VLEN=1024 (clang 18)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-18
-    - name: Build
-      run: |
-        CXX=clang++-18 CXXFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvbb" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
-        cmake --build build/ -j$(nproc)
-    - name: Test VLEN=1024
-      run: |
-        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
-        export QEMU_CPU="rv64,v=on,zvbb=on,vlen=1024,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)

.github/workflows/rvv-128-clang-17.yml

@@ -1,29 +0,0 @@
-name: Ubuntu rvv VLEN=128 (clang 17)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-17
-    - name: Build
-      run: |
-        CXX=clang++-17 CXXFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
-        cmake --build build/ -j$(nproc)
-    - name: Test VLEN=128
-      run: |
-        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
-        export QEMU_CPU="rv64,v=on,vlen=128,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)

.github/workflows/rvv-256-gcc-14.yml

@@ -1,29 +0,0 @@
-name: Ubuntu rvv VLEN=256 (gcc 14)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-14-riscv64-linux-gnu qemu-user-static
-    - name: Build
-      run: |
-        CXX=riscv64-linux-gnu-g++-14 CXXFLAGS=-march=rv64gcv \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
-        cmake --build build/ -j$(nproc)
-    - name: Test VLEN=256
-      run: |
-        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
-        export QEMU_CPU="rv64,v=on,zvbb=on,vlen=256,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)

.github/workflows/ubuntu24-cxx20-noexcept.yml

@@ -1,22 +0,0 @@
-name: Ubuntu 24.04 CI (CXX 20, noexcept)
-
-on: [push, pull_request]
-jobs:
-  ubuntu-build:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-24.04
-    strategy:
-      matrix:
-        cxx: [g++-13, clang++-16]
-    steps:
-      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
-      - name: Prepare
-        run: cmake -DSIMDJSON_CXX_STANDARD=20 -DSIMDJSON_EXCEPTIONS=OFF -DSIMDJSON_DEVELOPER_MODE=ON  -B build
-        env:
-          CXX: ${{matrix.cxx}}
-      - name: Build
-        run: cmake --build build -j=2
-      - name: Test
-        run: ctest --output-on-failure --test-dir build

.github/workflows/ubuntu24-noexcept.yml

@@ -31,4 +31,4 @@ jobs:
           echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
           mkdir testfindpackage &&
           cd testfindpackage &&
-          echo -e 'cmake_minimum_required(VERSION 3.14)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .
+          echo -e 'cmake_minimum_required(VERSION 3.1)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .

.github/workflows/ubuntu24-nothread.yml

@@ -31,4 +31,4 @@ jobs:
           echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
           mkdir testfindpackage &&
           cd testfindpackage &&
-          echo -e 'cmake_minimum_required(VERSION 3.14)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .
+          echo -e 'cmake_minimum_required(VERSION 3.1)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .

.github/workflows/vs17-ci-sani.yml

@@ -1,30 +0,0 @@
-name: VS17-CI-SANITIZE
-
-on: [push, pull_request]
-
-jobs:
-  ci:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    name: windows-vs17
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Debug}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Release}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: RelWithDebInfo}
-    steps:
-    - name: checkout
-      uses: actions/checkout@v4
-    - name: Configure
-      run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSANITIZE=ON -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
-    - name: Build
-      run: cmake --build build --config ${{matrix.build_type}} --verbose
-    - name: Run tests
-      run: |
-        cd build
-        ctest -C ${{matrix.build_type}}  -LE explicitonly  --output-on-failure

.gitignore

@@ -9,14 +9,6 @@
 # vim temp files
 .*.swp
 
-# Build directories
-build/
-build_*/
-buildreflect/
-
-# Ablation study results
-ablation/results/
-
 # XCode
 ^build/
 *.pbxuser

.vscode/settings.json

@@ -3,9 +3,6 @@
         {"column": 95 },
         {"column": 120 }
     ],
-    "cmake.configureArgs": [
-        "-DSIMDJSON_DEVELOPER_MODE=ON"
-    ],
     "files.trimTrailingWhitespace": true,
     "files.associations": {
         ".clangd": "yaml",

BENCHMARK_METHODOLOGY.md

@@ -23,7 +23,7 @@ Tests were run on Linux (aarch64) with results measured in MB/s throughput.
 - **Characteristics**: String-heavy (92%), moderate integer content (15%), minimal floats (<0.05%)
 
 ### CITM Catalog Dataset
-- **File**: `jsonexamples/citm_catalog.json`
+- **File**: `jsonexamples/citm_catalog.json`  
 - **Size**: 1,727,204 bytes
 - **Content**: Event catalog with performances, venues, and pricing
 - **Characteristics**: Complex nested structure with maps and arrays
@@ -64,7 +64,7 @@ Tests were run on Linux (aarch64) with results measured in MB/s throughput.
 - No lazy evaluation or partial parsing
 - Validates that all expected fields are present
 
-### Serialization Benchmarks
+### Serialization Benchmarks  
 - Serializes complete C++ structures to JSON strings
 - Measures only the serialization time, not structure population
 - Output validation ensures correctness

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14)
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 4.2.3
+    VERSION 4.0.0
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -20,8 +20,8 @@ string(
 # ---- Options, variables ----
 
 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "29.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "29" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_VERSION "28.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "28" CACHE STRING "simdjson library soversion")
 
 option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson (only makes sense if BUILD_SHARED_LIBS=ON)" OFF)
 if(SIMDJSON_BUILD_STATIC_LIB AND NOT BUILD_SHARED_LIBS)

Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = simdjson
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "4.2.3"
+PROJECT_NUMBER         = "4.0.0"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

HACKING.md

@@ -20,54 +20,13 @@ If you plan to contribute to simdjson, please read our [CONTRIBUTING](https://gi
 Build Quickstart
 ------------------------------
 
-For non-Windows system,
-
 ```bash
-cmake -B -D SIMDJSON_DEVELOPER_MODE=ON ..
-cmake --build build
-ctest --test-dir build
+mkdir build
+cd build
+cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
+cmake --build .
 ```
 
-It is similar for Visual Studio users, please see the CMake or Visual Studio documentation.
-
-By default the library is built in Release mode.
-
-
-Assertions and development checks
-------------------------------
-
-We do not use conventional `assert` in simdjson. Instead we use the macro
-`SIMDJSON_ASSUME`:
-
-```cpp
-SIMDJSON_ASSUME(something_that_is_true());
-```
-
-Sometimes, you need to do a bit more work that a simple check.
-The `SIMDJSON_DEVELOPMENT_CHECKS` macro is true only in Debug mode unless manually set.
-It is acceptable to add checks that you would not do in Release mode as long as
-they are guarded:
-
-```cpp
-#if SIMDJSON_DEVELOPMENT_CHECKS
-// do sanity checks here
-```
-
-
-Working with sanitizers
-------------------------------
-
-The simdjson library must be memory-safe. We cannot allow buffer overruns.
-During development, if you system supports it, we recommend configuring
-the project with `-D SIMDJSON_SANITIZE=ON`.
-
-```bash
-cmake -B -D SIMDJSON_SANITIZE=ON -D SIMDJSON_DEVELOPER_MODE=ON ..
-cmake --build build
-ctest --test-dir build
-```
-
-
 Design notes
 ------------------------------
 
@@ -144,9 +103,12 @@ simdjson's source structure, from the top level, looks like this:
     * generic/stage2/*.h: `simdjson::<implementation>::stage2` namespace. Generic implementation of the tape creator, which consumes the index from stage 1 and actually parses numbers and string and such. Used for the DOM interface.
 
 Other important files and directories:
+* **.drone.yml:** Definitions for Drone CI.
+* **.appveyor.yml:** Definitions for Appveyor CI (Windows).
+* **.circleci:** Definitions for Circle CI.
 * **.github/workflows:** Definitions for GitHub Actions (CI).
 * **singleheader:** Contains generated `simdjson.h` and `simdjson.cpp` that we release. The files `singleheader/simdjson.h` and `singleheader/simdjson.cpp` should never be edited by hand.
-* **singleheader/amalgamate.py:** Generates `singleheader/simdjson.h` and `singleheader/simdjson.cpp` for release (python script). If you add a new implementation (e.g., rvv), you need to edit this file (IMPLEMENTATIONS).
+* **singleheader/amalgamate.py:** Generates `singleheader/simdjson.h` and `singleheader/simdjson.cpp` for release (python script).
 * **benchmark:** This is where we do benchmarking. Benchmarking is core to every change we make; the
   cardinal rule is don't regress performance without knowing exactly why, and what you're trading
   for it. Many of our benchmarks are microbenchmarks. We are effectively doing controlled scientific experiments for the purpose of understanding what affects our performance. So we simplify as much as possible. We try to avoid irrelevant factors such as page faults, interrupts, unnecessary system calls. We recommend checking the performance as follows:

PARSING_BENCHMARK_RESULTS.md

@@ -4,81 +4,53 @@
 Comprehensive benchmarks comparing JSON parsing performance across multiple libraries using two real-world datasets.
 
 ## Test Environment
-- **Date**: September 2025
-- **Compiler**: Clang 21.0.0 with C++26 support
-- **Platform**: Linux (aarch64 and x64)
+- **Date**: January 2025
+- **Compiler**: Clang 21.0.0 with C++26 support  
+- **Platform**: Linux (aarch64)
 - **Optimization**: `-O3`
 - **Datasets**: Twitter (631KB), CITM Catalog (1.7MB)
 - **Reflection**: Using C++26 static reflection (P2996) with consteval optimization
 
-
-**Hardware remarks**: The Intel Ice Lake processor has powerful SIMD support (AVX-512, two 512-bit execution units). The Apple processor runs at higher frequency and cna retire more instructions per cycle, while having weaker SIMD support (ARM NEON, four 128-bit execution units).
-
 ## Twitter Dataset Results (631KB)
-### Intel Ice Lake
-| Library/Method | Throughput | Time/iter | Notes |
-|----------------|------------|-----------|-------|
-| **simdjson::from()** | 3.90 GB/s | 154.59 μs  | High-level API, uses C++26 reflection |
-| **simdjson (reflection)** | 3.75 GB/s | 160.60 μs | C++26 static reflection |
-| **simdjson (manual)** | 2.67 GB/s | 225.82 μs | Hand-written parsing code |
-| **yyjson** | 1.82 GB/s | 330.94 μs  | C library |
-| **Serde (Rust)** | 1.09 GB/s | 551.83 μs    | Via FFI |
-| **RapidJSON** | 387 MB/s | 1557.00 μs  | Full extraction |
-| **nlohmann/json** | 117 MB/s | 5346.73 μs  | Full extraction |
 
-### Apple Silicon
 | Library/Method | Throughput | Time/iter | Notes |
 |----------------|------------|-----------|-------|
-| **simdjson (manual)** | 4.36 GB/s | 138.04 μs | Hand-written parsing code |
-| **simdjson::from()** | 4.17 GB/s | 144.45 μs | High-level API, uses C++26 reflection |
-| **simdjson (reflection)** | 4.09 GB/s | 147.19 μs | C++26 static reflection |
-| **yyjson** | 2.23 GB/s | 269.71 μs | C library |
-| **Serde (Rust)** | 1.72 GB/s | 349.75 μs | Via FFI |
-| **RapidJSON** | 658 MB/s | 915.14 μs | Full extraction |
-| **nlohmann/json** | 172 MB/s | 3501.02 μs | Full extraction |
+| **simdjson (manual)** | 3.83 GB/s | 157.43 μs | Hand-written parsing code |
+| **simdjson (reflection)** | 3.62 GB/s | 166.30 μs | C++26 static reflection |
+| **simdjson::from()** | 3.61 GB/s | 166.93 μs | High-level API |
+| **yyjson** | 3.15 GB/s | 191.07 μs | C library |
+| **Serde (Rust)** | 1.71 GB/s | 352.45 μs | Via FFI |
+| **RapidJSON** | 659 MB/s | 913.41 μs | Full extraction |
+| **nlohmann/json** | 172 MB/s | 3507.81 μs | Full extraction |
 
 ## CITM Catalog Results (1.7MB)
-### Intel Ice Lake
 
 | Library/Method | Throughput | Time/iter | Notes |
 |----------------|------------|-----------|-------|
-| **simdjson (manual)** | 2.32 GB/s | 709.51 μs  | Manual parsing |
-| **simdjson (reflection)** | 1.85 GB/s | 890.34 μs  | C++26 static reflection |
-| **simdjson::from()** | 1.76 GB/s | 890.34 μs | Convenient API, uses C++26 reflection |
-| **yyjson** | 1.46 GB/s | 1130.75 μs | Full extraction |
-| **RapidJSON** | 552 GB/s | 2986.10 μs | Full extraction |
-| **Serde (Rust)** | 279 MB/s | 5903.36 μs  | Cross-language overhead |
-| **nlohmann/json** | 107187 MB/s |  15378.63 μs  | Full extraction |
-
-### Apple Silicon
-
-| Library/Method | Throughput | Time/iter | Notes |
-|----------------|------------|-----------|-------|
-| **simdjson (manual)** | 3.01 GB/s | 546.57 μs | Manual parsing |
-| **yyjson** | 2.68 GB/s | 614.32 μs | Full extraction |
-| **simdjson::from()** | 2.67 GB/s | 617.03 μs | Convenient API, uses C++26 reflection |
-| **simdjson (reflection)** | 2.66 GB/s | 620.07 μs | C++26 static reflection |
-| **RapidJSON** | 1.22 GB/s | 1354.62 μs | Full extraction |
-| **Serde (Rust)** | 535 MB/s | 3081.24 μs | Cross-language overhead |
-| **nlohmann/json** | 186 MB/s | 8874.02 μs | Full extraction |
+| **yyjson** | 2.67 GB/s | 616.14 μs | Full extraction |
+| **simdjson (reflection)** | 2.19 GB/s | 753.16 μs | Reflection-based |
+| **simdjson::from()** | 2.14 GB/s | 769.66 μs | Convenient API |
+| **simdjson (manual)** | 1.89 GB/s | 873.39 μs | Manual parsing |
+| **RapidJSON** | 1.17 GB/s | 1409.37 μs | Full extraction |
+| **Serde (Rust)** | 590 MB/s | 2793.82 μs | Cross-language overhead |
+| **nlohmann/json** | 187 MB/s | 8815.76 μs | Full extraction |
 
 ## Key Findings
 
-
 ### Performance Leaders
-- On Apple Silicon, **simdjson (manual)** tops both datasets: 4.36 GB/s for Twitter and 3.01 GB/s for CITM.
-- On Intel Ice Lake, **simdjson::from()** leads Twitter at 3.90 GB/s, while **simdjson (manual)** leads CITM at 2.32 GB/s.
-- simdjson variants consistently dominate the top positions across platforms and datasets, with yyjson as a strong contender especially on Apple Silicon for CITM (2.68 GB/s, nearly matching simdjson::from() at 2.67 GB/s).
-
+- **simdjson (manual)** leads in Twitter parsing at 3.83 GB/s
+- **yyjson** leads in CITM parsing at 2.67 GB/s
+- **simdjson (reflection)** provides excellent performance with convenience
 
 ### Technology Insights
-1. **C++26 Reflection**: simdjson's reflection approach shows variability by platform and dataset, achieving 140% of manual performance on Intel for Twitter (3.75 GB/s vs. 2.67 GB/s) and 94% on Apple Silicon (4.09 GB/s vs. 4.36 GB/s), averaging about 111%; for CITM, it reaches 80% on Intel (1.85 GB/s vs. 2.32 GB/s) and 88% on Apple Silicon (2.66 GB/s vs. 3.01 GB/s), averaging 84%.
-2. **Native Performance**: C/C++ libraries (simdjson, yyjson, RapidJSON, nlohmann/json) significantly outperform Rust's Serde, whichranks near the bottom in all cases.
-3. **API Trade-offs**: High-level APIs like simdjson::from() incur minimal overhead, often matching or exceeding reflection and manual methods (e.g., leading on Intel Twitter with 3.90 GB/s).
+1. **C++26 Reflection**: simdjson's reflection approach achieves 95% of manual performance on Twitter
+2. **Native Performance**: C/C++ libraries significantly outperform cross-language solutions
+3. **API Trade-offs**: High-level APIs (simdjson::from) have minimal overhead (<1% vs reflection)
 4. **Fair Comparison**: All libraries now extract complete data structures including nested objects
 
 ## Methodology
-- 3000 iterations for Twitter and CITM dataset
+- 1000 iterations for Twitter dataset
+- 500 iterations for CITM dataset  
 - Fresh parser instance per iteration (realistic usage)
 - Full field extraction (no lazy evaluation)
 - Warmup phase before timing

README.md

@@ -1,3 +1,5 @@
+
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/simdjson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:simdjson)
 [![][license img]][license] [![][licensemit img]][licensemit]
 
 
@@ -62,14 +64,10 @@ Real-world usage
 - [WasmEdge](https://wasmedge.org)
 - [RonDB](https://github.com/logicalclocks/rondb)
 - [GreptimeDB](https://github.com/GreptimeTeam/greptimedb)
-- [mamba](https://github.com/mamba-org/mamba)
 
 
 If you are planning to use simdjson in a product, please work from one of our releases.
 
-
-
-
 Quick Start
 -----------
 
@@ -86,7 +84,7 @@ The simdjson library is easily consumable with a single .h and .cpp file.
    ```
 2. Create `quickstart.cpp`:
 
-```cpp
+```c++
 #include <iostream>
 #include "simdjson.h"
 using namespace simdjson;
@@ -116,14 +114,11 @@ Usage documentation is available:
 * [Implementation Selection](doc/implementation-selection.md) describes runtime CPU detection and
   how you can work with it.
 * [API](https://simdjson.github.io/simdjson/) contains the automatically generated API documentation.
-* [Compile-Time Parsing](doc/compile_time.md) presents our compile-time parsing function (C++26 only).
-
 
 Godbolt
 -------------
 
 Some users may want to browse code along with the compiled assembly. You want to check out the following lists of examples:
-* [C++26 reflection example](https://godbolt.org/z/K3Px64TqK)
 * [simdjson examples with errors handled through exceptions](https://godbolt.org/z/7G5qE4sr9)
 * [simdjson examples with errors without exceptions](https://godbolt.org/z/e9dWb9E4v)
 
@@ -232,13 +227,6 @@ Contributing to simdjson
 Head over to [CONTRIBUTING.md](CONTRIBUTING.md) for information on contributing to simdjson, and
 [HACKING.md](HACKING.md) for information on source, building, and architecture/design.
 
-
-Stars
-------
-
-[![Star History Chart](https://api.star-history.com/svg?repos=simdjson/simdjson&type=Date)](https://www.star-history.com/#simdjson/simdjson&Date)
-
-
 License
 -------
 

SERIALIZATION_BENCHMARK_RESULTS.md

@@ -4,21 +4,15 @@
 Performance comparison of JSON serialization (C++ structs → JSON) across multiple libraries.
 
 ## Test Environment
-- **Date**: September 2025
+- **Date**: January 2025
 - **Compiler**: Clang 21.0.0 with C++26 support
-- **Platform**: Linux (aarch64 and x64)
-- **Optimization**: `-O3` (we do not use `-march=native` or other flags)
+- **Platform**: Linux (aarch64)
+- **Optimization**: `-O3`
 - **Datasets**: Twitter (631KB), CITM Catalog (1.7MB)
 - **Consteval**: Enabled with `std::define_static_string` for compile-time key generation
 
-**Software remarks**: The simdjson library makes little use of SIMD instructions when serializing.
-
-**Hardware remarks**: The Intel Ice Lake processor has powerful SIMD support (AVX-512, two 512-bit execution units). The Apple processor runs at higher frequency and cna retire more instructions per cycle, while having weaker SIMD support (ARM NEON, four 128-bit execution units).
-
-
 ## Twitter Dataset Results (631KB)
 
-### Intel Ice Lake
 | Library/Method | Throughput | Time/iter | Notes |
 |----------------|------------|-----------|-------|
 | **simdjson (reflection)** | 3.48 GB/s | 23.24 μs | C++26 static reflection with consteval |
@@ -28,19 +22,8 @@ Performance comparison of JSON serialization (C++ structs → JSON) across multi
 | **RapidJSON** | 494 MB/s | 163.86 μs | DOM-based |
 | **nlohmann/json** | 243 MB/s | 333.51 μs | Slowest |
 
-### Apple Silicon
-| Library/Method | Throughput | Time/iter | Notes |
-|----------------|------------|-----------|-------|
-| **simdjson (reflection)** | 3.52 GB/s | 23.00 μs | C++26 static reflection with consteval |
-| **yyjson** | 2.08 GB/s | 38.94 μs | C library |
-| **simdjson (DOM)** | 1.67 GB/s | 48.36 μs | Manual DOM serialization |
-| **Serde (Rust)** | 1.32 GB/s | 61.28 μs | Via FFI |
-| **RapidJSON** | 861 MB/s | 94.04 μs | DOM-based |
-| **nlohmann/json** | 242 MB/s | 334.18 μs | Slowest |
-
 ## CITM Catalog Results (1.7MB)
 
-### Intel Ice Lake
 | Library/Method | Throughput | Time/iter | Notes |
 |----------------|------------|-----------|-------|
 | **simdjson (reflection)** | 2.10 GB/s | 226.78 μs | Fastest with consteval optimization |
@@ -50,34 +33,21 @@ Performance comparison of JSON serialization (C++ structs → JSON) across multi
 | **RapidJSON** | 571 MB/s | 835.23 μs | DOM-based |
 | **nlohmann/json** | 127 MB/s | 3747.76 μs | Slowest |
 
-### Apple Silicon
-| Library/Method | Throughput | Time/iter | Notes |
-|----------------|------------|-----------|-------|
-| **simdjson (reflection)** | 2.25 GB/s | 212.06 μs | Fastest with consteval optimization |
-| **yyjson** | 1.67 GB/s | 286.43 μs | C library |
-| **Serde (Rust)** | 1.17 GB/s | 408.82 μs | Strong performance |
-| **simdjson (DOM)** | 780 MB/s | 612.03 μs | Manual implementation |
-| **RapidJSON** | 354 MB/s | 1349.76 μs | DOM-based |
-| **nlohmann/json** | 125 MB/s | 3831.37 μs | Slowest |
-
 ## Key Findings
 
 ### Performance Leaders
-- **simdjson (reflection)**  leads across all tests, peaking at 3.52 GB/s on Twitter (Apple Silicon) and 2.25 GB/s on CITM (Apple Silicon), showcasing best-in-class serialization performance.
-- **yyjson** consistently ranks second, achieving 2.08 GB/s on Twitter (Apple Silicon) and 1.68 GB/s on CITM (Intel Ice Lake), competitive but trailing simdjson by 1.5-1.7x.
-- Traditional libraries (RapidJSON, nlohmann/json) lag significantly, with nlohmann/json being the slowest at 242-243 MB/s on Twitter and 125-127 MB/s on CITM, roughly 14-30x slower than simdjson (reflection).
+- **simdjson (reflection)** dominates with 3.48 GB/s on Twitter (best-in-class)
+- **simdjson (reflection)** achieves 2.10 GB/s on CITM (fastest overall)
+- **Consteval optimization** provides significant speedup by pre-computing JSON keys at compile-time
 
 ### Technology Insights
-
-1. **Consteval Impact**: Using `std::define_static_string` for compile-time JSON key generation significantly boosts performance, enabling simdjson (reflection) to achieve up to 3.52 GB/s on Twitter, a 1.7-2.1x improvement over non-consteval methods like yyjson.
-2. **Memory Management**: String builder reuse combined with consteval key generation optimizes memory allocation, contributing to simdjson (reflection)'s superior performance across datasets and platforms.
-3. **Platform Differences**: Apple Silicon slightly edges out Intel Ice Lake for simdjson (reflection) on both datasets (3.52 GB/s vs. 3.48 GB/s on Twitter, 2.25 GB/s vs. 2.10 GB/s on CITM), likely due to higher frequency and instruction retirement, despite weaker SIMD support (ARM NEON vs. AVX-512).
-4. **Serde (Rust)** trails C/C++ libraries by 1.8-3x.
-5. **Reflection Performance**: C++26 reflection with consteval outperforms all alternatives
-
+1. **Consteval Impact**: Pre-computing JSON keys at compile-time provides major performance gains
+2. **Reflection Performance**: C++26 reflection with consteval outperforms all alternatives
+3. **Memory Management**: String builder reuse + consteval keys = optimal performance
 
 ## Methodology
-- 3000 iterations for Twitter and CITM dataset
+- 1000 iterations for Twitter dataset
+- 500 iterations for CITM dataset
 - String builder reuse for simdjson (realistic optimization)
 - Full serialization with proper JSON escaping
 - Warmup phase before timing

ablation/ABLATION_RESULTS.md

@@ -17,7 +17,7 @@ The ablation study systematically disables individual optimizations to measure t
 5. **no_branch_hints** - Disables CPU branch prediction hints
 6. **linear_growth** - Uses linear instead of exponential buffer growth
 
-## Current Results (September 2025)
+## Current Results (August 2025)
 
 ### Parsing Performance (JSON → C++ Structs)
 
@@ -43,30 +43,30 @@ The ablation study systematically disables individual optimizations to measure t
 
 ### Serialization Performance (C++ Structs → JSON)
 
-#### Twitter Serialization (631KB, String-Heavy) - Apple Silicon
+#### Twitter Serialization (631KB, String-Heavy)
 | Optimization | Throughput | Impact When Disabled | Contribution |
 |--------------|------------|---------------------|--------------|
-| **Baseline** | 3211 MB/s | - | All optimizations |
-| No Consteval | 1607 MB/s | -50.0% | **+100% performance** |
-| No SIMD Escaping | 2269 MB/s | -29.3% | **+42% performance** |
-| No Fast Digits | 3035 MB/s | -5.5% | +6% performance |
-| No Branch Hints | 3182 MB/s | -0.9% | +1% performance |
-| Linear Growth | 3225 MB/s | +0.4% | -0.4% performance |
+| **Baseline** | 3236 MB/s | - | All optimizations |
+| No Consteval | 1605 MB/s | -50.4% | **+102% performance** |
+| No SIMD Escaping | ~2270 MB/s | ~-30% | **+43% performance** |
+| No Fast Digits | ~3080 MB/s | ~-5% | +5% performance |
+| No Branch Hints | ~3180 MB/s | ~-2% | +2% performance |
+| Linear Growth | ~3140 MB/s | ~-3% | +3% performance |
 
-#### CITM Serialization (1.7MB, Complex Objects) - Apple Silicon
+#### CITM Serialization (1.7MB, Complex Objects)
 | Optimization | Throughput | Impact When Disabled | Contribution |
 |--------------|------------|---------------------|--------------|
-| **Baseline** | 2360 MB/s | - | All optimizations |
-| No Consteval | 978 MB/s | -58.6% | **+141% performance** |
-| No SIMD Escaping | 2259 MB/s | -4.3% | +4% performance |
-| No Fast Digits | 1767 MB/s | -25.1% | **+34% performance** |
-| No Branch Hints | 2247 MB/s | -4.8% | +5% performance |
-| Linear Growth | 2290 MB/s | -3.0% | +3% performance |
+| **Baseline** | 2285 MB/s | - | All optimizations |
+| No Consteval | 984 MB/s | -57.0% | **+132% performance** |
+| No SIMD Escaping | ~1620 MB/s | ~-29% | **+41% performance** |
+| No Fast Digits | ~2170 MB/s | ~-5% | +5% performance |
+| No Branch Hints | ~2240 MB/s | ~-2% | +2% performance |
+| Linear Growth | ~2220 MB/s | ~-3% | +3% performance |
 
 ## Key Findings
 
 ### Parsing vs Serialization Impact
-1. **Consteval affects ONLY serialization**:
+1. **Consteval affects ONLY serialization**: 
    - Parsing: No impact (runtime data, can't be optimized at compile-time)
    - Serialization: 100-130% improvement (field names known at compile-time)
 
@@ -78,10 +78,10 @@ The ablation study systematically disables individual optimizations to measure t
    - Parsing is already near-optimal with simdjson's core SIMD algorithms
    - Serialization benefits from compile-time and runtime optimizations
 
-### Overall Performance (Apple Silicon)
-- **Parsing**: 4.1 GB/s (Twitter), 2.7 GB/s (CITM) - consistent across variants
-- **Serialization**: 3.2 GB/s (Twitter), 2.4 GB/s (CITM) - heavily optimization-dependent
-- **Combined optimizations**: Provide 2-2.4x performance for serialization
+### Overall Performance
+- **Parsing**: 3.7 GB/s (Twitter), 2.2 GB/s (CITM) - consistent across variants
+- **Serialization**: 3.2 GB/s (Twitter), 2.3 GB/s (CITM) - heavily optimization-dependent
+- **Combined optimizations**: Provide 2x performance for serialization
 
 ## Code Snippets for Each Optimization
 
@@ -130,7 +130,7 @@ simdjson_inline bool fast_needs_escaping(std::string_view view) {
   const uint8_t* data = reinterpret_cast<const uint8_t*>(view.data());
   size_t len = view.length();
   size_t i = 0;
-
+  
   for (; i + 16 <= len; i += 16) {
     __m128i chunk = _mm_loadu_si128((__m128i*)(data + i));
     // Check for characters that need escaping: ", \, control chars

ablation/run_serialization_ablation.sh

@@ -0,0 +1,114 @@
+#!/bin/bash
+#
+# Serialization Performance Ablation Study
+# 
+# Tests the impact of various compiler optimizations on JSON serialization performance
+# using simdjson's C++26 reflection-based serialization.
+#
+# Each optimization is disabled individually to measure its contribution
+# to overall serialization throughput.
+#
+
+set -e
+
+# Configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT_DIR="$(dirname "$SCRIPT_DIR")"
+BUILD_DIR="$ROOT_DIR/build"
+ABLATION_DIR="$ROOT_DIR/ablation"
+RESULTS_DIR="$ABLATION_DIR/results"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}========================================${NC}"
+echo -e "${BLUE}  JSON Serialization Ablation Study${NC}"
+echo -e "${BLUE}========================================${NC}"
+echo ""
+
+# Create results directory
+mkdir -p "$RESULTS_DIR"
+
+# Define ablation variants
+declare -A variants=(
+    ["baseline"]=""
+    ["no_consteval"]="-DSIMDJSON_ABLATION_NO_CONSTEVAL"
+    ["no_simd_escaping"]="-DSIMDJSON_ABLATION_NO_SIMD_ESCAPING"
+    ["no_fast_digits"]="-DSIMDJSON_ABLATION_NO_FAST_DIGITS"
+    ["no_branch_hints"]="-DSIMDJSON_ABLATION_NO_BRANCH_HINTS"
+    ["linear_growth"]="-DSIMDJSON_ABLATION_LINEAR_GROWTH"
+)
+
+# Function to build and test serialization
+test_serialization_variant() {
+    local variant_name=$1
+    local flags=$2
+    
+    echo -e "${YELLOW}Testing variant: $variant_name${NC}"
+    
+    # Configure and build with CMake
+    cd "$BUILD_DIR"
+    
+    echo "  Configuring CMake..."
+    rm -f CMakeCache.txt
+    if ! env CXX=/usr/local/bin/clang++ CC=/usr/local/bin/clang cmake .. \
+         -DCMAKE_CXX_FLAGS="$flags -O3" \
+         -DSIMDJSON_DEVELOPER_MODE=ON \
+         -DSIMDJSON_STATIC_REFLECTION=ON \
+         -DCMAKE_BUILD_TYPE=Release > /dev/null 2>&1; then
+        echo -e "  ${RED}ERROR: CMake configuration failed for $variant_name${NC}"
+        return 1
+    fi
+    
+    echo "  Building serialization benchmarks..."
+    if ! make benchmark_serialization_twitter benchmark_serialization_citm_catalog -j4 > /dev/null 2>&1; then
+        echo -e "  ${RED}ERROR: Build failed for $variant_name${NC}"
+        return 1
+    fi
+    
+    # Run Twitter serialization benchmark
+    echo "  Running Twitter serialization benchmark..."
+    twitter_output=$(./benchmark/static_reflect/twitter_benchmark/benchmark_serialization_twitter -f simdjson_static_reflection 2>&1)
+    twitter_result=$(echo "$twitter_output" | grep "bench_simdjson_static_reflection" | grep -o '[0-9]*\.[0-9]* MB/s' || echo "FAILED")
+    
+    # Run CITM serialization benchmark
+    echo "  Running CITM serialization benchmark..."
+    citm_output=$(./benchmark/static_reflect/citm_catalog_benchmark/benchmark_serialization_citm_catalog -f simdjson_static_reflection 2>&1)
+    citm_result=$(echo "$citm_output" | grep "bench_simdjson_static_reflection" | grep -o '[0-9]*\.[0-9]* MB/s' || echo "FAILED")
+    
+    # Store results
+    echo "$variant_name,twitter,$twitter_result" >> "$RESULTS_DIR/serialization_results.csv"
+    echo "$variant_name,citm,$citm_result" >> "$RESULTS_DIR/serialization_results.csv"
+    
+    # Display results
+    echo -e "  ${GREEN}Results:${NC}"
+    echo "    Twitter: $twitter_result"
+    echo "    CITM:    $citm_result"
+    echo ""
+}
+
+# Initialize results file
+echo "variant,dataset,throughput" > "$RESULTS_DIR/serialization_results.csv"
+
+# Run tests for each variant
+for variant in baseline no_consteval no_simd_escaping no_fast_digits no_branch_hints linear_growth; do
+    test_serialization_variant "$variant" "${variants[$variant]}"
+done
+
+echo -e "${BLUE}========================================${NC}"
+echo -e "${BLUE} Serialization Ablation Study Complete${NC}"
+echo -e "${BLUE}========================================${NC}"
+echo ""
+
+# Display summary
+echo "Results saved to: $RESULTS_DIR/serialization_results.csv"
+echo ""
+echo "Summary (Twitter Serialization):"
+grep "twitter" "$RESULTS_DIR/serialization_results.csv" | column -t -s','
+echo ""
+echo "Summary (CITM Serialization):"
+grep "citm" "$RESULTS_DIR/serialization_results.csv" | column -t -s','

ablation/serialization_test.cpp

@@ -17,18 +17,18 @@ double benchmark_twitter(int iterations = 1000) {
     for (int i = 0; i < 100; i++) {
         tweets.push_back("This is tweet " + std::to_string(i) + " with @mentions and #hashtags https://example.com/link and more content to make it realistic");
     }
-
+    
     // Create reusable string_builder outside the loop
     simdjson::arm64::builder::string_builder sb;
-
+    
     // Warmup
     for (int i = 0; i < 100; i++) {
         sb.clear();
         sb.append("{\"statuses\":[");
-
+        
         for (size_t j = 0; j < tweets.size(); j++) {
             if (j > 0) sb.append(',');
-
+            
             sb.append("{\"created_at\":\"Mon Sep 24 03:35:21 +0000 2012\",");
             sb.append("\"id\":");
             sb.append(uint64_t(505874924095815700ULL + j));
@@ -51,23 +51,23 @@ double benchmark_twitter(int iterations = 1000) {
             sb.append(uint64_t(j * 5));
             sb.append("}");
         }
-
+        
         sb.append("]}");
         std::string_view result;
         sb.view().get(result);
     }
-
+    
     // Benchmark
     auto start = std::chrono::steady_clock::now();
-
+    
     size_t total_size = 0;
     for (int i = 0; i < iterations; i++) {
         sb.clear();  // Clear and reuse the builder
         sb.append("{\"statuses\":[");
-
+        
         for (size_t j = 0; j < tweets.size(); j++) {
             if (j > 0) sb.append(',');
-
+            
             sb.append("{\"created_at\":\"Mon Sep 24 03:35:21 +0000 2012\",");
             sb.append("\"id\":");
             sb.append(uint64_t(505874924095815700ULL + j));
@@ -90,19 +90,19 @@ double benchmark_twitter(int iterations = 1000) {
             sb.append(uint64_t(j * 5));
             sb.append("}");
         }
-
+        
         sb.append("]}");
         std::string_view result;
         sb.view().get(result);
         total_size = result.size();
     }
-
+    
     auto end = std::chrono::steady_clock::now();
     auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
-
+    
     double seconds = duration.count() / 1000000.0;
     double mb_per_sec = (total_size * iterations / 1024.0 / 1024.0) / seconds;
-
+    
     return mb_per_sec;
 }
 
@@ -111,15 +111,15 @@ double benchmark_citm(int iterations = 500) {
     // Create CITM-like data with nested structures
     std::vector<std::string> names;
     std::vector<std::string> descriptions;
-
+    
     for (int i = 0; i < 200; i++) {
         names.push_back("Event " + std::to_string(i) + " - Concert Series");
         descriptions.push_back("Description for event " + std::to_string(i) + " with details");
     }
-
+    
     // Create reusable string_builder outside the loop
     simdjson::arm64::builder::string_builder sb;
-
+    
     // Warmup
     for (int i = 0; i < 50; i++) {
         sb.clear();
@@ -127,15 +127,15 @@ double benchmark_citm(int iterations = 500) {
         std::string_view result;
         sb.view().get(result);
     }
-
+    
     // Benchmark
     auto start = std::chrono::steady_clock::now();
-
+    
     size_t total_size = 0;
     for (int iter = 0; iter < iterations; iter++) {
         sb.clear();  // Clear and reuse the builder
         sb.append("{\"events\":[");
-
+        
         for (size_t i = 0; i < names.size(); i++) {
             if (i > 0) sb.append(',');
             sb.append("{\"id\":");
@@ -150,9 +150,9 @@ double benchmark_citm(int iterations = 500) {
             sb.append(uint64_t(107888604 + i));
             sb.append("]}");
         }
-
+        
         sb.append("],\"performances\":[");
-
+        
         for (int i = 0; i < 500; i++) {
             if (i > 0) sb.append(',');
             sb.append("{\"id\":");
@@ -165,9 +165,9 @@ double benchmark_citm(int iterations = 500) {
             sb.append(uint64_t(i % 10));
             sb.append("\"}");
         }
-
+        
         sb.append("],\"venues\":[");
-
+        
         for (int i = 0; i < 50; i++) {
             if (i > 0) sb.append(',');
             sb.append("{\"id\":");
@@ -178,19 +178,19 @@ double benchmark_citm(int iterations = 500) {
             sb.append(uint64_t(5000 + i * 100));
             sb.append("}");
         }
-
+        
         sb.append("]}");
         std::string_view result;
         sb.view().get(result);
         total_size = result.size();
     }
-
+    
     auto end = std::chrono::steady_clock::now();
     auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
-
+    
     double seconds = duration.count() / 1000000.0;
     double mb_per_sec = (total_size * iterations / 1024.0 / 1024.0) / seconds;
-
+    
     return mb_per_sec;
 }
 
@@ -199,9 +199,9 @@ int main(int argc, char* argv[]) {
         std::cerr << "Usage: " << argv[0] << " <twitter|citm>" << std::endl;
         return 1;
     }
-
+    
     std::string test_type = argv[1];
-
+    
     if (test_type == "twitter") {
         double mb_per_sec = benchmark_twitter();
         std::cout << mb_per_sec << std::endl;
@@ -212,6 +212,6 @@ int main(int argc, char* argv[]) {
         std::cerr << "Unknown test type: " << test_type << std::endl;
         return 1;
     }
-
+    
     return 0;
 }

benchmark/CMakeLists.txt

@@ -35,16 +35,13 @@ if (TARGET benchmark::benchmark)
   endif()
 endif()
 
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-std=c++20" SIMDJSON_COMPILER_SUPPORTS_CXX20)
 if(SIMDJSON_STATIC_REFLECTION)
   add_subdirectory(static_reflect)
-else()
-  if(SIMDJSON_EXCEPTIONS AND SIMDJSON_COMPILER_SUPPORTS_CXX20)
-    add_subdirectory(from)
-    add_subdirectory(car_builder)
-  endif()
 endif(SIMDJSON_STATIC_REFLECTION)
 
 
+include(CheckCXXCompilerFlag)
+check_cxx_compiler_flag("-std=c++20" SIMDJSON_COMPILER_SUPPORTS_CXX20)
+if(SIMDJSON_EXCEPTIONS AND SIMDJSON_COMPILER_SUPPORTS_CXX20)
+  add_subdirectory(from)
+endif()

benchmark/UNIFIED_RESULTS.md

@@ -10,7 +10,7 @@ Comparison of simdjson's C++26 static reflection implementation against traditio
 - **Platform**: Linux aarch64
 - **Build Type**: Release with -O3
 - **Methodology**: Conservative approach - fresh parser instance per iteration
-- **Date**: September 2025
+- **Date**: August 2025
 
 ## Parsing Performance Results
 
@@ -18,30 +18,26 @@ Comparison of simdjson's C++26 static reflection implementation against traditio
 
 | Library/Method | Throughput | Latency | Speedup vs nlohmann |
 |----------------|------------|---------|-------------------|
-| **simdjson (manual)** | 4362.9 MB/s | 138.04 μs | 25.4x |
-| **simdjson (reflection)** | 4091.7 MB/s | 147.19 μs | 23.8x |
-| **simdjson::from()** | 4169.3 MB/s | 144.45 μs | 24.2x |
-| nlohmann (extraction) | 172.0 MB/s | 3501.02 μs | 1.0x (baseline) |
-| RapidJSON (extraction) | 658.1 MB/s | 915.14 μs | 3.8x |
-| Serde (Rust) | 1722.0 MB/s | 349.75 μs | 10.0x |
-| yyjson | 2233.0 MB/s | 269.71 μs | 13.0x |
+| **simdjson (manual)** | 3879.9 MB/s | 155.23 μs | 22.7x |
+| **simdjson (reflection)** | 3708.9 MB/s | 162.38 μs | 21.7x |
+| **simdjson::from()** | 3708.8 MB/s | 162.38 μs | 21.7x |
+| nlohmann (extraction) | 170.7 MB/s | 3528.11 μs | 1.0x (baseline) |
+| RapidJSON (extraction) | 663.1 MB/s | 908.26 μs | 3.9x |
 
 ### CITM Catalog Parsing Benchmark (1.7MB, Complex Objects)
 
 | Library/Method | Throughput | Latency | Speedup vs nlohmann |
 |----------------|------------|---------|-------------------|
-| **simdjson (manual)** | 3013.7 MB/s | 546.57 μs | 16.2x |
-| **simdjson (reflection)** | 2656.4 MB/s | 620.07 μs | 14.3x |
-| **simdjson::from()** | 2669.5 MB/s | 617.03 μs | 14.4x |
-| nlohmann (extraction) | 185.6 MB/s | 8874.02 μs | 1.0x (baseline) |
-| RapidJSON (extraction) | 1216.0 MB/s | 1354.62 μs | 6.5x |
-| Serde (Rust) | 534.6 MB/s | 3081.24 μs | 2.9x |
-| yyjson | 2681.3 MB/s | 614.32 μs | 14.4x |
+| **simdjson (manual)** | 2848.8 MB/s | 578.21 μs | 14.5x |
+| **simdjson (reflection)** | 2183.4 MB/s | 754.42 μs | 11.1x |
+| **simdjson::from()** | 2169.8 MB/s | 759.16 μs | 11.0x |
+| nlohmann (extraction) | 197.1 MB/s | 8357.74 μs | 1.0x (baseline) |
+| RapidJSON (extraction) | 1355.6 MB/s | 1215.13 μs | 6.9x |
 
 ## Key Findings
 
-1. **Reflection performs excellently**: Only 6-13% slower than manual implementation
-2. **Massive speedup over traditional libraries**: 14-25x faster than nlohmann::json
+1. **Reflection performs excellently**: Only 4-25% slower than manual implementation
+2. **Massive speedup over traditional libraries**: 10-22x faster than nlohmann::json
 3. **Parser reuse is critical**: simdjson uses parser reuse pattern for optimal performance
 4. **String-heavy workloads favor simdjson**: Twitter shows better relative performance
 
@@ -54,11 +50,9 @@ Comparison of simdjson's C++26 static reflection implementation against traditio
 - **Parser reuse**: Amortizes allocation costs across iterations
 
 ### Library Comparison
-- **simdjson**: 2.7-4.4 GB/s throughput (conservative approach)
-- **yyjson**: 2.2-2.7 GB/s throughput (comparable performance)
-- **Serde (Rust)**: 0.5-1.7 GB/s throughput (2.4-5.6x slower)
-- **RapidJSON**: 0.7-1.2 GB/s throughput (3.6-6.5x slower)
-- **nlohmann**: 172-186 MB/s throughput (14-25x slower)
+- **simdjson**: 2.2-3.9 GB/s throughput (conservative approach)
+- **RapidJSON**: 0.7-1.4 GB/s throughput (3-7x slower)
+- **nlohmann**: 170-200 MB/s throughput (11-23x slower)
 
 ## Implementation Notes
 
@@ -79,74 +73,13 @@ Both measurements are valid - unified shows optimized build performance, ablatio
 ## Conclusion
 
 simdjson's C++26 static reflection provides:
-- **Near-manual performance** (within 6-13%)
-- **14-25x speedup** over nlohmann::json
-- **2.4-5.6x speedup** over Serde (Rust)
-- **3.6-6.5x speedup** over RapidJSON
+- **Near-manual performance** (within 4-25%)
+- **10-22x speedup** over nlohmann::json
+- **3-7x speedup** over RapidJSON
 - **Automatic code generation** with reflection
 
 This demonstrates that C++26 reflection can provide zero-cost abstractions for JSON parsing.
 
-## Serialization Performance Results
-
-### Twitter Serialization Benchmark (631KB, String-Heavy)
-
-| Library/Method | Throughput | Latency | Speedup vs nlohmann |
-|----------------|------------|---------|-------------------|
-| **simdjson (reflection)** | 3521.5 MB/s | 23.00 μs | 14.5x |
-| **simdjson (DOM)** | 1674.3 MB/s | 48.36 μs | 6.9x |
-| nlohmann::json | 242.3 MB/s | 334.18 μs | 1.0x (baseline) |
-| RapidJSON | 861.1 MB/s | 94.04 μs | 3.6x |
-| yyjson | 2079.4 MB/s | 38.94 μs | 8.6x |
-| Serde (Rust) | 1321.5 MB/s | 61.28 μs | 5.5x |
-
-### CITM Catalog Serialization Benchmark (1.7MB, Complex Objects)
-
-| Library/Method | Throughput | Latency | Speedup vs nlohmann |
-|----------------|------------|---------|-------------------|
-| **simdjson (reflection)** | 2250.0 MB/s | 212.06 μs | 18.1x |
-| **simdjson (DOM)** | 779.6 MB/s | 612.03 μs | 6.3x |
-| nlohmann::json | 124.5 MB/s | 3831.37 μs | 1.0x (baseline) |
-| RapidJSON | 353.5 MB/s | 1349.76 μs | 2.8x |
-| yyjson | 1665.7 MB/s | 286.43 μs | 13.4x |
-| Serde (Rust) | 1167.1 MB/s | 408.82 μs | 9.4x |
-
-## Serialization Ablation Study Results
-
-### Impact of Compiler Optimizations on Serialization Performance
-
-The ablation study disabled individual optimizations to measure their contribution:
-
-#### Twitter Dataset (631KB)
-
-| Variant | Throughput | Performance Impact |
-|---------|------------|-----------------|
-| **Baseline** | 3211.1 MB/s | 100% (reference) |
-| No consteval | 1607.4 MB/s | -50.0% |
-| No SIMD escaping | 2269.2 MB/s | -29.3% |
-| No fast digits | 3034.8 MB/s | -5.5% |
-| No branch hints | 3182.5 MB/s | -0.9% |
-| Linear growth | 3225.4 MB/s | +0.4% |
-
-#### CITM Dataset (1.7MB)
-
-| Variant | Throughput | Performance Impact |
-|---------|------------|-----------------|
-| **Baseline** | 2360.1 MB/s | 100% (reference) |
-| No consteval | 978.3 MB/s | -58.6% |
-| No SIMD escaping | 2259.0 MB/s | -4.3% |
-| No fast digits | 1766.8 MB/s | -25.1% |
-| No branch hints | 2247.4 MB/s | -4.8% |
-| Linear growth | 2289.9 MB/s | -3.0% |
-
-### Key Findings from Ablation Study
-
-1. **consteval is critical**: Disabling compile-time evaluation reduces performance by 50-59%
-2. **SIMD escaping provides significant boost**: 4-29% performance improvement for string escaping
-3. **Fast digit conversion matters**: Especially for number-heavy datasets (25% improvement on CITM)
-4. **Branch hints have minimal impact**: Less than 5% difference in most cases
-5. **Exponential growth strategy**: Shows slight benefit over linear (3-4% improvement)
-
 ## Running Benchmarks with Serde Comparison
 
 ### Serialization Benchmarks (Including Serde)
@@ -170,7 +103,7 @@ make benchmark_serialization_twitter benchmark_serialization_citm_catalog -j4
 # Run Twitter serialization benchmark (all libraries)
 ./benchmark/static_reflect/twitter_benchmark/benchmark_serialization_twitter
 
-# Run CITM serialization benchmark (all libraries)
+# Run CITM serialization benchmark (all libraries)  
 ./benchmark/static_reflect/citm_catalog_benchmark/benchmark_serialization_citm_catalog
 
 # Run specific library comparison (comma-separated filters now supported!)
@@ -182,22 +115,20 @@ make benchmark_serialization_twitter benchmark_serialization_citm_catalog -j4
 
 #### Expected Results
 
-**Twitter Dataset (631KB) - Latest Results**
-- simdjson (reflection): 3.52 GB/s
-- yyjson: 2.08 GB/s
-- simdjson (DOM): 1.67 GB/s
-- Serde (Rust): 1.32 GB/s
-- RapidJSON: 0.86 GB/s
-- nlohmann: 0.24 GB/s
+**Twitter Dataset (631KB)**
+- simdjson (builder API): ~3.21 GB/s
+- simdjson::to API: ~2.85 GB/s  
+- Serde (Rust): ~1.73 GB/s
+- reflect-cpp: ~1.49 GB/s
+- nlohmann: ~0.18 GB/s
 
-**CITM Dataset (1.7MB) - Latest Results**
-- simdjson (reflection): 2.25 GB/s
-- yyjson: 1.67 GB/s
-- Serde (Rust): 1.17 GB/s
-- simdjson (DOM): 0.78 GB/s
-- RapidJSON: 0.35 GB/s
-- nlohmann: 0.12 GB/s
+**CITM Dataset (1.7MB)**
+- simdjson (builder API): ~2.37 GB/s
+- simdjson::to API: ~2.15 GB/s
+- reflect-cpp: ~1.19 GB/s
+- Serde (Rust): ~1.17 GB/s
+- nlohmann: ~0.10 GB/s
 
 **Key Finding**: simdjson with C++26 reflection achieves 1.8-1.9x faster serialization than Serde.
 
-Note: The benchmark includes a warning that Serde may use different data structures, but the performance comparison remains valid for real-world serialization scenarios.
+Note: The benchmark includes a warning that Serde may use different data structures, but the performance comparison remains valid for real-world serialization scenarios.

benchmark/accessor_performance/README.md

@@ -1,46 +0,0 @@
-# Accessor Performance Benchmarks (C++26)
-
-These benchmarks compare the performance of runtime vs compile-time JSON accessors.
-For the comparison to be meaningful, you must build simdjson with support for
-C++26 reflexion. See the `p2996` repository in the main project directory.
-
-## Files
-
-- `accessor_benchmark.h` - Common benchmark framework and test data
-- `runtime_accessors.h` - Runtime `at_path()` benchmarks
-- `compile_time_accessors.h` - Compile-time `at_path_compiled()` benchmarks (requires C++26 reflection)
-
-## Benchmarks
-
-Each benchmark measures parsing + single field access:
-
-1. **accessor_simple** - Simple field: `.name`
-2. **accessor_nested** - Nested field: `.address.city`
-3. **accessor_deep** - Deep nested field: `.address.coordinates.lat`
-
-## Building (Linux/macOS)
-
-```bash
-cmake -B build -D SIMDJSON_STATIC_REFLECTION=ON -DSIMDJSON_DEVELOPER_MODE=ON
-cmake --build build --target=bench_ondemand
-```
-
-The `SIMDJSON_STATIC_REFLECTION` will be made unnecessary once mainstream compilers
-begin supporting C++26 sufficiently well.
-
-## Running (Linux/macOS)
-
-
-```bash
-# Run all accessor benchmarks
-./build/bench_ondemand --benchmark_filter="accessor"
-```
-
-## Results
-
-We find that compile-time accessors show performance improvements that scale with path depth:
-- Simple fields: ~1.2x faster
-- Nested fields: ~1.5x faster
-- Deep nested fields: ~1.8x faster
-
-The speedup comes from eliminating runtime path parsing and conversion overhead.

benchmark/accessor_performance/accessor_benchmark.h

@@ -1,132 +0,0 @@
-#pragma once
-
-#include "json_benchmark/file_runner.h"
-#include <string>
-
-namespace accessor_performance {
-
-using namespace json_benchmark;
-
-// Test JSON for accessor benchmarks
-static const char* TEST_JSON = R"({
-  "name": "Alice",
-  "age": 30,
-  "email": "alice@example.com",
-  "address": {
-    "street": "123 Main St",
-    "city": "Boston",
-    "state": "MA",
-    "zip": 12345,
-    "coordinates": {
-      "lat": 42.3601,
-      "lon": -71.0589
-    }
-  },
-  "scores": [95, 87, 92, 88, 91],
-  "preferences": {
-    "theme": "dark",
-    "notifications": {
-      "email": true,
-      "push": false,
-      "sms": true
-    }
-  }
-})";
-
-// Struct definitions for compile-time validation
-#if SIMDJSON_STATIC_REFLECTION
-struct Coordinates {
-  double lat;
-  double lon;
-};
-
-struct Address {
-  std::string street;
-  std::string city;
-  std::string state;
-  int64_t zip;
-  Coordinates coordinates;
-};
-
-struct Notifications {
-  bool email;
-  bool push;
-  bool sms;
-};
-
-struct Preferences {
-  std::string theme;
-  Notifications notifications;
-};
-
-struct TestData {
-  std::string name;
-  int64_t age;
-  std::string email;
-  Address address;
-  std::vector<int64_t> scores;
-  Preferences preferences;
-};
-#endif // SIMDJSON_STATIC_REFLECTION
-
-// Single-access benchmark runner: measures ONE field access per iteration
-template<typename I>
-struct single_access_runner : public file_runner<I> {
-  std::string result_string;
-  int64_t result_int{};
-  double result_double{};
-  bool result_bool{};
-
-  bool setup(benchmark::State &state) {
-    this->json = simdjson::padded_string(TEST_JSON, strlen(TEST_JSON));
-    state.SetBytesProcessed(int64_t(state.iterations()) * int64_t(this->json.size()));
-    return true;
-  }
-
-  bool before_run(benchmark::State &state) {
-    if (!file_runner<I>::before_run(state)) { return false; }
-    result_string.clear();
-    result_int = 0;
-    result_double = 0.0;
-    result_bool = false;
-    return true;
-  }
-
-  bool run(benchmark::State &) {
-    return this->implementation.run(this->json, result_string, result_int, result_double, result_bool);
-  }
-
-  template<typename R>
-  bool diff(benchmark::State &state, single_access_runner<R> &reference) {
-    if (result_string != reference.result_string ||
-        result_int != reference.result_int ||
-        result_double != reference.result_double ||
-        result_bool != reference.result_bool) {
-      std::cerr << "Accessor benchmark results differ!" << std::endl;
-      return false;
-    }
-    return true;
-  }
-
-  size_t items_per_iteration() {
-    return 1;
-  }
-};
-
-// Benchmark template definitions
-struct runtime_at_path_simple;
-template<typename I> simdjson_inline static void accessor_simple(benchmark::State &state) {
-  run_json_benchmark<single_access_runner<I>, single_access_runner<runtime_at_path_simple>>(state);
-}
-
-struct runtime_at_path_nested;
-template<typename I> simdjson_inline static void accessor_nested(benchmark::State &state) {
-  run_json_benchmark<single_access_runner<I>, single_access_runner<runtime_at_path_nested>>(state);
-}
-
-struct runtime_at_path_deep;
-template<typename I> simdjson_inline static void accessor_deep(benchmark::State &state) {
-  run_json_benchmark<single_access_runner<I>, single_access_runner<runtime_at_path_deep>>(state);
-}
-
-} // namespace accessor_performance

benchmark/accessor_performance/compile_time_accessors.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#if SIMDJSON_EXCEPTIONS && SIMDJSON_STATIC_REFLECTION
-
-#include "accessor_benchmark.h"
-
-namespace accessor_performance {
-
-using namespace simdjson;
-
-struct compile_time_at_path_simple {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
-    auto doc = parser.iterate(json);
-    std::string_view name;
-    auto r = ondemand::json_path::at_path_compiled<TestData, ".name">(doc);
-    if (r.get(name) != SUCCESS) return false;
-    result_str = name;
-    return true;
-  }
-};
-
-struct compile_time_at_path_nested {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
-    auto doc = parser.iterate(json);
-    std::string_view city;
-    auto r = ondemand::json_path::at_path_compiled<TestData, ".address.city">(doc);
-    if (r.get(city) != SUCCESS) return false;
-    result_str = city;
-    return true;
-  }
-};
-
-struct compile_time_at_path_deep {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string&, int64_t&, double &result_dbl, bool&) {
-    auto doc = parser.iterate(json);
-    double lat;
-    auto r = ondemand::json_path::at_path_compiled<TestData, ".address.coordinates.lat">(doc);
-    if (r.get(lat) != SUCCESS) return false;
-    result_dbl = lat;
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(accessor_simple, compile_time_at_path_simple)->UseManualTime();
-BENCHMARK_TEMPLATE(accessor_nested, compile_time_at_path_nested)->UseManualTime();
-BENCHMARK_TEMPLATE(accessor_deep, compile_time_at_path_deep)->UseManualTime();
-
-} // namespace accessor_performance
-
-#endif // SIMDJSON_EXCEPTIONS && SIMDJSON_STATIC_REFLECTION

benchmark/accessor_performance/runtime_accessors.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#if SIMDJSON_EXCEPTIONS
-
-#include "accessor_benchmark.h"
-
-namespace accessor_performance {
-
-using namespace simdjson;
-
-struct runtime_at_path_simple {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
-    auto doc = parser.iterate(json);
-    std::string_view name;
-    if (doc.at_path(".name").get(name) != SUCCESS) return false;
-    result_str = name;
-    return true;
-  }
-};
-
-struct runtime_at_path_nested {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
-    auto doc = parser.iterate(json);
-    std::string_view city;
-    if (doc.at_path(".address.city").get(city) != SUCCESS) return false;
-    result_str = city;
-    return true;
-  }
-};
-
-struct runtime_at_path_deep {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string&, int64_t&, double &result_dbl, bool&) {
-    auto doc = parser.iterate(json);
-    double lat;
-    if (doc.at_path(".address.coordinates.lat").get(lat) != SUCCESS) return false;
-    result_dbl = lat;
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(accessor_simple, runtime_at_path_simple)->UseManualTime();
-BENCHMARK_TEMPLATE(accessor_nested, runtime_at_path_nested)->UseManualTime();
-BENCHMARK_TEMPLATE(accessor_deep, runtime_at_path_deep)->UseManualTime();
-
-} // namespace accessor_performance
-
-#endif // SIMDJSON_EXCEPTIONS

benchmark/bench_ondemand.cpp

@@ -148,9 +148,4 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #include "large_amazon_cellphones/simdjson_dom.h"
 #include "large_amazon_cellphones/simdjson_ondemand.h"
 
-#include "accessor_performance/runtime_accessors.h"
-#if SIMDJSON_STATIC_REFLECTION
-#include "accessor_performance/compile_time_accessors.h"
-#endif
-
 BENCHMARK_MAIN();

benchmark/build_unified_benchmark.sh

@@ -71,11 +71,11 @@ if [ $? -eq 0 ]; then
     echo "Running benchmark..."
     echo "==================="
     echo ""
-
+    
     # Run the benchmark from the correct directory
     cd "$ROOT_DIR"
     "$SCRIPT_DIR/unified_benchmark"
-
+    
     if [ $? -eq 0 ]; then
         echo ""
         echo "✓ Benchmark completed successfully!"

benchmark/car_builder/CMakeLists.txt

@@ -1,14 +0,0 @@
-# Executable
-add_executable(benchmark_car_builder benchmark_car_builder.cpp)
-
-# Compile for C++20.
-target_compile_features(benchmark_car_builder PRIVATE cxx_std_20)
-
-# Check if -march=native is supported
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-march=native" SIMDJSON_SUPPORTS_MARCH_NATIVE)
-if(SIMDJSON_SUPPORTS_MARCH_NATIVE)
-  target_compile_options(benchmark_car_builder PRIVATE -march=native)
-endif()
-
-target_include_directories(benchmark_car_builder PRIVATE ${CMAKE_CURRENT_LIST_DIR}/..)

benchmark/car_builder/benchmark_car_builder.cpp

@@ -1,127 +0,0 @@
-#include "event_counter.h"
-#include <random>
-#include <vector>
-
-#include <simdjson.h>
-
-event_collector collector;
-
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year; // We deliberately do not include the tire pressure.
-};
-
-std::vector<Car> generate_random_cars(size_t count) {
-  static const std::vector<std::string> makes = {"Toyota", "Honda", "Ford",
-                                                 "BMW", "Mazda"};
-  static const std::vector<std::string> models = {"Camry", "Civic", "Focus",
-                                                  "320i", "3"};
-  static thread_local std::mt19937 rng{std::random_device{}()};
-  std::uniform_int_distribution<int> make_dist(0, makes.size() - 1);
-  std::uniform_int_distribution<int> model_dist(0, models.size() - 1);
-  std::uniform_int_distribution<int64_t> year_dist(2000, 2025);
-  std::uniform_real_distribution<double> pressure_dist(30.0, 45.0);
-
-  std::vector<Car> cars;
-  cars.reserve(count);
-  for (size_t i = 0; i < count; ++i) {
-    Car car;
-    car.make = makes[make_dist(rng)];
-    car.model = models[model_dist(rng)];
-    car.year = year_dist(rng);
-    cars.push_back(std::move(car));
-  }
-  return cars;
-}
-
-std::string_view serialize(simdjson::builder::string_builder &sb,
-                           const std::vector<Car> &cars) {
-  sb.clear();
-  sb.start_array();
-  for (const auto &car : cars) {
-    sb.start_object();
-    sb.append_key_value("make", car.make);
-    sb.append_comma();
-    sb.append_key_value("model", car.model);
-    sb.append_comma();
-    sb.append_key_value("year", car.year);
-    sb.end_object();
-  }
-  sb.end_array();
-  std::string_view result;
-  if (sb.view().get(result)) {
-    return ""; // unexpected (error)
-  }
-  return result;
-}
-
-double pretty_print(const std::string &name, size_t num_chars,
-                    std::pair<event_aggregate, size_t> result) {
-  const auto &agg = result.first;
-  size_t N = result.second;
-  num_chars *= N;
-  printf("%-40s : %8.2f ns %8.2f GB/s", name.c_str(),
-         agg.elapsed_ns() / num_chars, num_chars / agg.elapsed_ns());
-  if (collector.has_events()) {
-    printf(" %8.2f GHz %8.2f cycles/char %8.2f ins./char %8.2f i/c",
-           agg.cycles() / agg.elapsed_ns(), agg.cycles() / num_chars,
-           agg.instructions() / num_chars, agg.instructions() / agg.cycles());
-  }
-  printf("\n");
-  return num_chars / agg.elapsed_ns();
-}
-
-template <class function_type>
-std::pair<event_aggregate, size_t>
-bench(const function_type &&function, size_t min_repeat = 100,
-      size_t min_time_ns = 40'000'000, size_t max_repeat = 10000000) {
-  size_t N = min_repeat;
-  if (N == 0) {
-    N = 1;
-  }
-  event_aggregate warm_aggregate{};
-  for (size_t i = 0; i < N; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    function();
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    warm_aggregate << allocate_count;
-    if ((i + 1 == N) && (warm_aggregate.total_elapsed_ns() < min_time_ns) &&
-        (N < max_repeat)) {
-      N *= 10;
-    }
-  }
-  event_aggregate aggregate{};
-  for (size_t i = 0; i < 10; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    for (size_t i = 0; i < N; i++) {
-      function();
-    }
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    aggregate << allocate_count;
-  }
-  return {aggregate, N};
-}
-
-void run_benchmarks() {
-  std::vector<Car> source = generate_random_cars(100000);
-  simdjson::builder::string_builder sb;
-  size_t volume = serialize(sb, source).size();
-
-  pretty_print("string_builder", volume, bench([&source, &sb]() -> size_t {
-                 return serialize(sb, source).size();
-               }));
-}
-
-int main() {
-  for (size_t trial = 0; trial < 3; trial++) {
-    printf("Trial %zu:\n", trial + 1);
-    run_benchmarks();
-    printf("\n");
-  }
-  return EXIT_SUCCESS;
-}

benchmark/distinct_user_id/yyjson.h

@@ -44,10 +44,7 @@ struct yyjson_base {
 
 struct yyjson : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
   }
 };
 BENCHMARK_TEMPLATE(distinct_user_id, yyjson)->UseManualTime();
@@ -55,15 +52,11 @@ BENCHMARK_TEMPLATE(distinct_user_id, yyjson)->UseManualTime();
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
   }
 };
 BENCHMARK_TEMPLATE(distinct_user_id, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace distinct_user_id
 
 #endif // SIMDJSON_COMPETITION_YYJSON

benchmark/find_tweet/yyjson.h

@@ -36,26 +36,18 @@ struct yyjson_base {
 
 struct yyjson : yyjson_base {
   bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
-    bool b = yyjson_base::run(doc, find_id, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), find_id, result);
   }
 };
 BENCHMARK_TEMPLATE(find_tweet, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
   bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
-    bool b = yyjson_base::run(doc, find_id, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), find_id, result);
   }
 };
 BENCHMARK_TEMPLATE(find_tweet, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace find_tweet
 
 #endif // SIMDJSON_COMPETITION_YYJSON

benchmark/json2msgpack/yyjson.h

@@ -100,7 +100,6 @@ struct yyjson : yyjson2msgpack {
            std::string_view &result) {
     yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
     result = to_msgpack(doc, reinterpret_cast<uint8_t*>(buffer));
-    yyjson_doc_free(doc);
     return true;
   }
 };
@@ -114,7 +113,6 @@ struct yyjson_insitu : yyjson2msgpack {
     yyjson_doc *doc =
         yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
     result = to_msgpack(doc, reinterpret_cast<uint8_t*>(buffer));
-    yyjson_doc_free(doc);
     return true;
   }
 };
@@ -122,4 +120,4 @@ BENCHMARK_TEMPLATE(json2msgpack, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
 } // namespace json2msgpack
 
-#endif // SIMDJSON_COMPETITION_YYJSON
+#endif // SIMDJSON_COMPETITION_YYJSON

benchmark/kostya/yyjson.h

@@ -49,26 +49,18 @@ struct yyjson_base {
 
 struct yyjson : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
   }
 };
 BENCHMARK_TEMPLATE(kostya, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
   }
 };
 BENCHMARK_TEMPLATE(kostya, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace kostya
 
 #endif // SIMDJSON_COMPETITION_YYJSON

benchmark/large_random/yyjson.h

@@ -47,26 +47,18 @@ struct yyjson_base {
 
 struct yyjson : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
   }
 };
 BENCHMARK_TEMPLATE(large_random, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
   }
 };
 BENCHMARK_TEMPLATE(large_random, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace large_random
 
 #endif // SIMDJSON_COMPETITION_YYJSON

benchmark/partial_tweets/yyjson.h

@@ -62,26 +62,19 @@ struct yyjson_base {
 
 struct yyjson : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<tweet<std::string_view>> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
   }
 };
 BENCHMARK_TEMPLATE(partial_tweets, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<tweet<std::string_view>> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
   }
 };
 BENCHMARK_TEMPLATE(partial_tweets, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace partial_tweets
 
 #endif // SIMDJSON_COMPETITION_YYJSON
+

benchmark/static_reflect/CMakeLists.txt

@@ -6,42 +6,38 @@ CPMAddPackage(
   EXCLUDE_FROM_ALL YES
 )
 
-option(SIMDJSON_USE_RUST "Build the static_reflect benchmark" OFF)
 
-if(SIMDJSON_USE_RUST)
-  if(NOT WIN32)
-  # We want the check whether Rust is available before trying to build a crate.
-  CPMAddPackage(
-    NAME corrosion
-    GITHUB_REPOSITORY corrosion-rs/corrosion
-    VERSION 0.4.4
-    DOWNLOAD_ONLY ON
-    OPTIONS "Rust_FIND_QUIETLY OFF"
-  )
-  include("${corrosion_SOURCE_DIR}/cmake/FindRust.cmake")
-  endif()
 
-  if(RUST_FOUND)
-    message(STATUS "Rust found: " ${Rust_VERSION} )
-    add_subdirectory("${corrosion_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/corrosion" EXCLUDE_FROM_ALL)
-    # Important: we want to build in release mode!
-    corrosion_import_crate(MANIFEST_PATH "serde-benchmark/Cargo.toml" NO_LINKER_OVERRIDE PROFILE release)
-  else()
-    message(STATUS "Rust/Cargo is unavailable." )
-    message(STATUS "We will not benchmark serde-benchmark." )
-    if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-      message(STATUS "Under macOS, you may be able to install rust with")
-      message(STATUS "curl https://sh.rustup.rs -sSf | sh")
-    elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-      message(STATUS "Under Linux, you may be able to install rust with a command such as")
-      message(STATUS "apt-get install cargo" )
-      message(STATUS "or" )
-      message(STATUS "curl https://sh.rustup.rs -sSf | sh")
-    endif()
-  endif()
-else(SIMDJSON_USE_RUST)
+if(NOT WIN32)
+# We want the check whether Rust is available before trying to build a crate.
+CPMAddPackage(
+  NAME corrosion
+  GITHUB_REPOSITORY corrosion-rs/corrosion
+  VERSION 0.4.4
+  DOWNLOAD_ONLY ON
+  OPTIONS "Rust_FIND_QUIETLY OFF"
+)
+include("${corrosion_SOURCE_DIR}/cmake/FindRust.cmake")
+endif()
+
+if(RUST_FOUND)
+  message(STATUS "Rust found: " ${Rust_VERSION} )
+  add_subdirectory("${corrosion_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/corrosion" EXCLUDE_FROM_ALL)
+  # Important: we want to build in release mode!
+  corrosion_import_crate(MANIFEST_PATH "serde-benchmark/Cargo.toml" NO_LINKER_OVERRIDE PROFILE release)
+else()
+  message(STATUS "Rust/Cargo is unavailable." )
   message(STATUS "We will not benchmark serde-benchmark." )
-endif(SIMDJSON_USE_RUST)
+  if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    message(STATUS "Under macOS, you may be able to install rust with")
+    message(STATUS "curl https://sh.rustup.rs -sSf | sh")
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    message(STATUS "Under Linux, you may be able to install rust with a command such as")
+    message(STATUS "apt-get install cargo" )
+    message(STATUS "or" )
+    message(STATUS "curl https://sh.rustup.rs -sSf | sh")
+  endif()
+endif()
 
 # Add the benchmark executable targets
 add_subdirectory(twitter_benchmark)

benchmark/static_reflect/citm_catalog_benchmark/CMakeLists.txt

@@ -1,5 +1,4 @@
 add_executable(benchmark_serialization_citm_catalog benchmark_serialization_citm_catalog.cpp)
-add_executable(benchmark_parsing_citm benchmark_parsing_citm.cpp)
 
 # Link with Rust benchmarking code if available
 if(TARGET serde-benchmark)
@@ -12,29 +11,4 @@ target_link_libraries(benchmark_serialization_citm_catalog PRIVATE simdjson::sim
 target_link_libraries(benchmark_serialization_citm_catalog PRIVATE reflectcpp)
 target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_BENCH_CPP_REFLECT=1)
 
-if(TARGET yyjson)
-    target_link_libraries(benchmark_serialization_citm_catalog PRIVATE yyjson)
-    target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_COMPETITION_YYJSON)
-endif()
-
-target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE JSON_FILE="${BENCH_CITM_JSON}")
-
-# Configuration for parsing benchmark
-if(TARGET serde-benchmark)
-    target_link_libraries(benchmark_parsing_citm PRIVATE serde-benchmark)
-    target_compile_definitions(benchmark_parsing_citm PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
-endif()
-
-target_link_libraries(benchmark_parsing_citm PRIVATE simdjson::simdjson nlohmann_json)
-
-if(TARGET rapidjson)
-    target_link_libraries(benchmark_parsing_citm PRIVATE rapidjson)
-    target_compile_definitions(benchmark_parsing_citm PRIVATE SIMDJSON_COMPETITION_RAPIDJSON)
-endif()
-
-if(TARGET yyjson)
-    target_link_libraries(benchmark_parsing_citm PRIVATE yyjson)
-    target_compile_definitions(benchmark_parsing_citm PRIVATE SIMDJSON_COMPETITION_YYJSON)
-endif()
-
-target_compile_definitions(benchmark_parsing_citm PRIVATE JSON_FILE="${BENCH_CITM_JSON}")
+target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE JSON_FILE="${BENCH_CITM_JSON}")

benchmark/static_reflect/citm_catalog_benchmark/benchmark_parsing_citm.cpp

@@ -1,565 +0,0 @@
-#include <cassert>
-#include <cstdlib>
-#include <ctime>
-#include <format>
-#include <fstream>
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include <simdjson.h>
-#include <string>
-#include "citm_catalog_data.h"
-#include "nlohmann_citm_catalog_data.h"
-#include "../benchmark_utils/benchmark_helper.h"
-
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-#include "rapidjson_citm_catalog_data.h"
-#endif
-
-#ifdef SIMDJSON_COMPETITION_YYJSON
-#include "yyjson_citm_catalog_data.h"
-#endif
-
-#ifdef SIMDJSON_RUST_VERSION
-#include "../serde-benchmark/serde_benchmark.h"
-
-void bench_rust_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_rust_parsing",
-               bench([&json_str, &result]() {
-                 serde_benchmark::CitmCatalog *catalog = serde_benchmark::citm_from_str(json_str.c_str(), json_str.size());
-                 result = (catalog != nullptr);
-                 if (catalog) {
-                   serde_benchmark::free_citm(catalog);
-                 }
-                 if (!result) {
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-template <class T> void bench_simdjson_static_reflection_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  // Pre-allocate padded buffer outside the benchmark loop
-  std::string mutable_json = json_str;
-  simdjson::pad(mutable_json);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_simdjson_static_reflection_parsing",
-               bench([&mutable_json, &result]() {
-                 simdjson::ondemand::parser parser;
-                 simdjson::ondemand::document doc;
-                 if(parser.iterate(mutable_json).get(doc)) {
-                   result = false;
-                   return;
-                 }
-                 T my_struct;
-                 if(doc.get<T>().get(my_struct)) {
-                   result = false;
-                 }
-                 if (!result) {
-                   printf("parse error\n");
-                 }
-               }));
-}
-
-#if SIMDJSON_STATIC_REFLECTION
-template <class T> void bench_simdjson_from_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  // Pre-allocate padded buffer outside the benchmark loop
-  simdjson::padded_string padded = simdjson::padded_string(json_str);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_simdjson_from_parsing",
-               bench([&padded, &result]() {
-                 try {
-                   // Using simdjson::from API directly with padded string
-                   // This will throw an exception if parsing fails
-                   T my_struct = simdjson::from(padded);
-                   result = true;
-                 } catch (const std::exception& e) {
-                   result = false;
-                   printf("parse error: %s\n", e.what());
-                 }
-               }));
-}
-#endif
-
-// nlohmann::json deserialization functions
-void from_json(const nlohmann::json &j, CITMPrice &p) {
-    j.at("amount").get_to(p.amount);
-    j.at("audienceSubCategoryId").get_to(p.audienceSubCategoryId);
-    j.at("seatCategoryId").get_to(p.seatCategoryId);
-}
-
-void from_json(const nlohmann::json &j, CITMArea &a) {
-    j.at("areaId").get_to(a.areaId);
-    j.at("blockIds").get_to(a.blockIds);
-}
-
-void from_json(const nlohmann::json &j, CITMSeatCategory &s) {
-    j.at("areas").get_to(s.areas);
-    j.at("seatCategoryId").get_to(s.seatCategoryId);
-}
-
-void from_json(const nlohmann::json &j, CITMPerformance &p) {
-    j.at("id").get_to(p.id);
-    j.at("eventId").get_to(p.eventId);
-    if (j.contains("logo") && !j["logo"].is_null()) {
-        p.logo = j["logo"].get<std::string>();
-    }
-    if (j.contains("name") && !j["name"].is_null()) {
-        p.name = j["name"].get<std::string>();
-    }
-    j.at("prices").get_to(p.prices);
-    j.at("seatCategories").get_to(p.seatCategories);
-    if (j.contains("seatMapImage") && !j["seatMapImage"].is_null()) {
-        p.seatMapImage = j["seatMapImage"].get<std::string>();
-    }
-    j.at("start").get_to(p.start);
-    j.at("venueCode").get_to(p.venueCode);
-}
-
-void from_json(const nlohmann::json &j, CITMEvent &e) {
-    j.at("id").get_to(e.id);
-    j.at("name").get_to(e.name);
-    if (j.contains("description") && !j["description"].is_null()) {
-        e.description = j["description"].get<std::string>();
-    }
-    if (j.contains("logo") && !j["logo"].is_null()) {
-        e.logo = j["logo"].get<std::string>();
-    }
-    j.at("subTopicIds").get_to(e.subTopicIds);
-    if (j.contains("subjectCode") && !j["subjectCode"].is_null()) {
-        e.subjectCode = j["subjectCode"].get<std::string>();
-    }
-    if (j.contains("subtitle") && !j["subtitle"].is_null()) {
-        e.subtitle = j["subtitle"].get<std::string>();
-    }
-    j.at("topicIds").get_to(e.topicIds);
-}
-
-void from_json(const nlohmann::json &j, CitmCatalog &c) {
-    j.at("events").get_to(c.events);
-    j.at("performances").get_to(c.performances);
-}
-
-CitmCatalog nlohmann_deserialize(const std::string &json_str) {
-    nlohmann::json j = nlohmann::json::parse(json_str);
-    return j.get<CitmCatalog>();
-}
-
-void bench_nlohmann_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_nlohmann_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   CitmCatalog data = nlohmann_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-CitmCatalog rapidjson_deserialize(const std::string &json_str) {
-    rapidjson::Document doc;
-    doc.Parse(json_str.c_str());
-
-    if (doc.HasParseError()) {
-        throw std::runtime_error("RapidJSON parse error");
-    }
-
-    CitmCatalog catalog;
-
-    // Parse events
-    if (doc.HasMember("events") && doc["events"].IsObject()) {
-        for (auto& m : doc["events"].GetObject()) {
-            CITMEvent event;
-            const auto& e = m.value;
-
-            event.id = e["id"].GetUint64();
-            event.name = e["name"].GetString();
-            if (e.HasMember("description") && !e["description"].IsNull()) {
-                event.description = e["description"].GetString();
-            }
-            if (e.HasMember("logo") && !e["logo"].IsNull()) {
-                event.logo = e["logo"].GetString();
-            }
-
-            event.subTopicIds.clear();
-            for (auto& id : e["subTopicIds"].GetArray()) {
-                event.subTopicIds.push_back(id.GetUint64());
-            }
-
-            if (e.HasMember("subjectCode") && !e["subjectCode"].IsNull()) {
-                event.subjectCode = e["subjectCode"].GetString();
-            }
-            if (e.HasMember("subtitle") && !e["subtitle"].IsNull()) {
-                event.subtitle = e["subtitle"].GetString();
-            }
-
-            event.topicIds.clear();
-            for (auto& id : e["topicIds"].GetArray()) {
-                event.topicIds.push_back(id.GetUint64());
-            }
-
-            catalog.events[m.name.GetString()] = event;
-        }
-    }
-
-    // Parse performances
-    if (doc.HasMember("performances") && doc["performances"].IsArray()) {
-        for (auto& p : doc["performances"].GetArray()) {
-            CITMPerformance perf;
-
-            perf.id = p["id"].GetUint64();
-            perf.eventId = p["eventId"].GetUint64();
-            if (p.HasMember("logo") && !p["logo"].IsNull()) {
-                perf.logo = p["logo"].GetString();
-            }
-            if (p.HasMember("name") && !p["name"].IsNull()) {
-                perf.name = p["name"].GetString();
-            }
-
-            // Parse prices
-            for (auto& price : p["prices"].GetArray()) {
-                CITMPrice pr;
-                pr.amount = price["amount"].GetUint64();
-                pr.audienceSubCategoryId = price["audienceSubCategoryId"].GetUint64();
-                pr.seatCategoryId = price["seatCategoryId"].GetUint64();
-                perf.prices.push_back(pr);
-            }
-
-            // Parse seat categories
-            for (auto& sc : p["seatCategories"].GetArray()) {
-                CITMSeatCategory seatCat;
-                seatCat.seatCategoryId = sc["seatCategoryId"].GetUint64();
-
-                for (auto& area : sc["areas"].GetArray()) {
-                    CITMArea ar;
-                    ar.areaId = area["areaId"].GetUint64();
-                    for (auto& block : area["blockIds"].GetArray()) {
-                        ar.blockIds.push_back(block.GetUint64());
-                    }
-                    seatCat.areas.push_back(ar);
-                }
-                perf.seatCategories.push_back(seatCat);
-            }
-
-            if (p.HasMember("seatMapImage") && !p["seatMapImage"].IsNull()) {
-                perf.seatMapImage = p["seatMapImage"].GetString();
-            }
-            perf.start = p["start"].GetUint64();
-            perf.venueCode = p["venueCode"].GetString();
-
-            catalog.performances.push_back(perf);
-        }
-    }
-
-    return catalog;
-}
-
-void bench_rapidjson_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_rapidjson_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   CitmCatalog data = rapidjson_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-#ifdef SIMDJSON_COMPETITION_YYJSON
-CitmCatalog yyjson_deserialize(const std::string &json_str) {
-    yyjson_doc *doc = yyjson_read(json_str.c_str(), json_str.size(), 0);
-    if (!doc) {
-        throw std::runtime_error("YYJson parse error");
-    }
-
-    yyjson_val *root = yyjson_doc_get_root(doc);
-    CitmCatalog catalog;
-
-    // Parse events
-    yyjson_val *events = yyjson_obj_get(root, "events");
-    if (events) {
-        size_t idx, max;
-        yyjson_val *key, *val;
-        yyjson_obj_foreach(events, idx, max, key, val) {
-            CITMEvent event;
-
-            event.id = yyjson_get_uint(yyjson_obj_get(val, "id"));
-            const char* name = yyjson_get_str(yyjson_obj_get(val, "name"));
-            if (name) event.name = name;
-
-            yyjson_val *desc = yyjson_obj_get(val, "description");
-            if (desc && !yyjson_is_null(desc)) {
-                const char* str = yyjson_get_str(desc);
-                if (str) event.description = str;
-            }
-
-            yyjson_val *logo = yyjson_obj_get(val, "logo");
-            if (logo && !yyjson_is_null(logo)) {
-                const char* str = yyjson_get_str(logo);
-                if (str) event.logo = str;
-            }
-
-            yyjson_val *subTopics = yyjson_obj_get(val, "subTopicIds");
-            if (subTopics) {
-                size_t sidx, smax;
-                yyjson_val *sval;
-                yyjson_arr_foreach(subTopics, sidx, smax, sval) {
-                    event.subTopicIds.push_back(yyjson_get_uint(sval));
-                }
-            }
-
-            yyjson_val *subjectCode = yyjson_obj_get(val, "subjectCode");
-            if (subjectCode && !yyjson_is_null(subjectCode)) {
-                const char* str = yyjson_get_str(subjectCode);
-                if (str) event.subjectCode = str;
-            }
-
-            yyjson_val *subtitle = yyjson_obj_get(val, "subtitle");
-            if (subtitle && !yyjson_is_null(subtitle)) {
-                const char* str = yyjson_get_str(subtitle);
-                if (str) event.subtitle = str;
-            }
-
-            yyjson_val *topics = yyjson_obj_get(val, "topicIds");
-            if (topics) {
-                size_t tidx, tmax;
-                yyjson_val *tval;
-                yyjson_arr_foreach(topics, tidx, tmax, tval) {
-                    event.topicIds.push_back(yyjson_get_uint(tval));
-                }
-            }
-
-            const char* keyStr = yyjson_get_str(key);
-            if (keyStr) {
-                catalog.events[keyStr] = event;
-            }
-        }
-    }
-
-    // Parse performances
-    yyjson_val *performances = yyjson_obj_get(root, "performances");
-    if (performances) {
-        size_t idx, max;
-        yyjson_val *val;
-        yyjson_arr_foreach(performances, idx, max, val) {
-            CITMPerformance perf;
-
-            perf.id = yyjson_get_uint(yyjson_obj_get(val, "id"));
-            perf.eventId = yyjson_get_uint(yyjson_obj_get(val, "eventId"));
-
-            yyjson_val *logo = yyjson_obj_get(val, "logo");
-            if (logo && !yyjson_is_null(logo)) {
-                const char* str = yyjson_get_str(logo);
-                if (str) perf.logo = str;
-            }
-
-            yyjson_val *name = yyjson_obj_get(val, "name");
-            if (name && !yyjson_is_null(name)) {
-                const char* str = yyjson_get_str(name);
-                if (str) perf.name = str;
-            }
-
-            // Parse prices
-            yyjson_val *prices = yyjson_obj_get(val, "prices");
-            if (prices) {
-                size_t pidx, pmax;
-                yyjson_val *pval;
-                yyjson_arr_foreach(prices, pidx, pmax, pval) {
-                    CITMPrice price;
-                    price.amount = yyjson_get_uint(yyjson_obj_get(pval, "amount"));
-                    price.audienceSubCategoryId = yyjson_get_uint(yyjson_obj_get(pval, "audienceSubCategoryId"));
-                    price.seatCategoryId = yyjson_get_uint(yyjson_obj_get(pval, "seatCategoryId"));
-                    perf.prices.push_back(price);
-                }
-            }
-
-            // Parse seat categories
-            yyjson_val *seatCats = yyjson_obj_get(val, "seatCategories");
-            if (seatCats) {
-                size_t scidx, scmax;
-                yyjson_val *scval;
-                yyjson_arr_foreach(seatCats, scidx, scmax, scval) {
-                    CITMSeatCategory seatCat;
-                    seatCat.seatCategoryId = yyjson_get_uint(yyjson_obj_get(scval, "seatCategoryId"));
-
-                    yyjson_val *areas = yyjson_obj_get(scval, "areas");
-                    if (areas) {
-                        size_t aidx, amax;
-                        yyjson_val *aval;
-                        yyjson_arr_foreach(areas, aidx, amax, aval) {
-                            CITMArea area;
-                            area.areaId = yyjson_get_uint(yyjson_obj_get(aval, "areaId"));
-
-                            yyjson_val *blocks = yyjson_obj_get(aval, "blockIds");
-                            if (blocks) {
-                                size_t bidx, bmax;
-                                yyjson_val *bval;
-                                yyjson_arr_foreach(blocks, bidx, bmax, bval) {
-                                    area.blockIds.push_back(yyjson_get_uint(bval));
-                                }
-                            }
-                            seatCat.areas.push_back(area);
-                        }
-                    }
-                    perf.seatCategories.push_back(seatCat);
-                }
-            }
-
-            yyjson_val *seatMapImage = yyjson_obj_get(val, "seatMapImage");
-            if (seatMapImage && !yyjson_is_null(seatMapImage)) {
-                const char* str = yyjson_get_str(seatMapImage);
-                if (str) perf.seatMapImage = str;
-            }
-
-            perf.start = yyjson_get_uint(yyjson_obj_get(val, "start"));
-            const char* venueCode = yyjson_get_str(yyjson_obj_get(val, "venueCode"));
-            if (venueCode) perf.venueCode = venueCode;
-
-            catalog.performances.push_back(perf);
-        }
-    }
-
-    yyjson_doc_free(doc);
-    return catalog;
-}
-
-void bench_yyjson_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_yyjson_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   CitmCatalog data = yyjson_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-std::string read_file(std::string filename) {
-  printf("# Reading file %s\n", filename.c_str());
-  constexpr size_t read_size = 4096;
-  auto stream = std::ifstream(filename);
-  stream.exceptions(std::ios_base::badbit);
-
-  if (!stream) {
-    std::cerr << "Error: Failed to open file " << filename << std::endl;
-    exit(EXIT_FAILURE);
-  }
-
-  std::string out;
-  auto buf = std::string(read_size, '\0');
-  while (stream.read(&buf[0], read_size)) {
-    out.append(buf, 0, size_t(stream.gcount()));
-  }
-  out.append(buf, 0, size_t(stream.gcount()));
-  return out;
-}
-
-// Function to check if benchmark name matches any of the comma-separated filters
-bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  if (filter.empty()) return true;
-
-  // Split filter by comma
-  size_t start = 0;
-  size_t end = filter.find(',');
-  while (end != std::string::npos) {
-    std::string token = filter.substr(start, end - start);
-    if (benchmark_name.find(token) != std::string::npos) {
-      return true;
-    }
-    start = end + 1;
-    end = filter.find(',', start);
-  }
-  // Check last token
-  std::string token = filter.substr(start);
-  return benchmark_name.find(token) != std::string::npos;
-}
-
-int main(int argc, char *argv[]) {
-  // Get the JSON file path from preprocessor or use default
-  std::string filename;
-#ifdef JSON_FILE
-  filename = JSON_FILE;
-#else
-  filename = "jsonexamples/citm_catalog.json";
-#endif
-
-  std::string json_str = read_file(filename);
-
-  // Parse command-line arguments for filter
-  std::string filter;
-  for (int i = 1; i < argc; i++) {
-    std::string arg = argv[i];
-    if (arg == "-f" && i + 1 < argc) {
-      filter = argv[i + 1];
-      printf("# Filter: %s\n", filter.c_str());
-      i++;
-    }
-  }
-
-  // If no filter provided, run all benchmarks
-  if (filter.empty()) {
-    printf("# Running all benchmarks (use -f <filter> to run specific ones)\n");
-  }
-
-  // Benchmarking the parsing
-  if (matches_filter("nlohmann", filter)) {
-    bench_nlohmann_parsing(json_str);
-  }
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-  if (matches_filter("rapidjson", filter)) {
-    bench_rapidjson_parsing(json_str);
-  }
-#endif
-#ifdef SIMDJSON_COMPETITION_YYJSON
-  if (matches_filter("yyjson", filter)) {
-    bench_yyjson_parsing(json_str);
-  }
-#endif
-  if (matches_filter("simdjson_static_reflection", filter)) {
-    bench_simdjson_static_reflection_parsing<CitmCatalog>(json_str);
-  }
-#if SIMDJSON_STATIC_REFLECTION
-  if (matches_filter("simdjson_from", filter)) {
-    bench_simdjson_from_parsing<CitmCatalog>(json_str);
-  }
-#endif
-#ifdef SIMDJSON_RUST_VERSION
-  if (matches_filter("rust", filter)) {
-    printf("# Note: Rust/Serde parsing test\n");
-    bench_rust_parsing(json_str);
-  }
-#endif
-  return EXIT_SUCCESS;
-}

benchmark/static_reflect/citm_catalog_benchmark/benchmark_serialization_citm_catalog.cpp

@@ -11,10 +11,6 @@
 #include "nlohmann_citm_catalog_data.h"
 #include "../benchmark_utils/benchmark_helper.h"
 
-#ifdef SIMDJSON_COMPETITION_YYJSON
-#include "yyjson_citm_catalog_data.h"
-#endif
-
 #if SIMDJSON_BENCH_CPP_REFLECT
 #include <rfl.hpp>
 #include <rfl/json.hpp>
@@ -72,55 +68,7 @@ void bench_nlohmann(CitmCatalog &data) {
                }));
 }
 
-#ifdef SIMDJSON_COMPETITION_YYJSON
-void bench_yyjson(CitmCatalog &data) {
-  std::string output = yyjson_serialize_citm(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_yyjson",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = yyjson_serialize_citm(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif
-
-// Fair allocation variant: allocates fresh buffer each iteration (matches other libraries)
 void bench_simdjson_static_reflection(CitmCatalog &data) {
-  // First run to determine expected size
-  simdjson::builder::string_builder sb_init;
-  simdjson::builder::append(sb_init, data);
-  std::string_view p_init;
-  if(sb_init.view().get(p_init)) {
-    std::cerr << "Error!" << std::endl;
-  }
-  size_t output_volume = p_init.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
-               bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 simdjson::builder::string_builder sb;
-                 simdjson::builder::append(sb, data);
-                 std::string_view p;
-                 if(sb.view().get(p)) {
-                   std::cerr << "Error!" << std::endl;
-                 }
-                 measured_volume = sb.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-// Optimized variant: reuses buffer across iterations (shows API potential)
-void bench_simdjson_static_reflection_reuse(CitmCatalog &data) {
   simdjson::builder::string_builder sb;
   simdjson::builder::append(sb, data);
   std::string_view p;
@@ -132,7 +80,7 @@ void bench_simdjson_static_reflection_reuse(CitmCatalog &data) {
   printf("# output volume: %zu bytes\n", output_volume);
 
   volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_reuse_buffer",
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
                bench([&data, &measured_volume, &output_volume, &sb]() {
                  sb.clear();
                  simdjson::builder::append(sb, data);
@@ -148,42 +96,15 @@ void bench_simdjson_static_reflection_reuse(CitmCatalog &data) {
 }
 
 #if SIMDJSON_STATIC_REFLECTION
-// Fair allocation variant: allocates fresh string each iteration
 void bench_simdjson_to(CitmCatalog &data) {
-  // First run to determine size
-  std::string output_init;
-  simdjson::builder::to_json(data, output_init);
-  size_t output_volume = output_init.size();
+  std::string output = simdjson::to_json_string(data);
+  size_t output_volume = output.size();
   printf("# output volume: %zu bytes\n", output_volume);
 
   volatile size_t measured_volume = 0;
   pretty_print(sizeof(data), output_volume, "bench_simdjson_to",
                bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 std::string output;
-                 simdjson::builder::to_json(data, output);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-// Optimized variant: reuses pre-allocated string
-void bench_simdjson_to_reuse(CitmCatalog &data) {
-  std::string output;
-  simdjson::builder::to_json(data, output);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  // Pre-allocate string with sufficient capacity to avoid reallocation
-  output.reserve(output_volume * 2);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_to_reuse",
-               bench([&data, &measured_volume, &output_volume, &output]() {
-                 // Reuse the pre-allocated string - avoids allocation
-                 simdjson::builder::to_json(data, output);
+                 std::string output = simdjson::to_json_string(data);
                  measured_volume = output.size();
                  if (measured_volume != output_volume) {
                    printf("mismatch\n");
@@ -211,7 +132,7 @@ std::string read_file(const std::string &file_path, size_t read_size = 65536) {
 // Function to check if benchmark name matches any of the comma-separated filters
 bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
   if (filter.empty()) return true;
-
+  
   // Split filter by comma
   size_t start = 0;
   size_t end = filter.find(',');
@@ -259,34 +180,20 @@ int main(int argc, char* argv[]) {
   }
 
   // Benchmarking the serialization
-  // Note: simdjson benchmarks include both "fair" (fresh allocation) and "reuse" (buffer reuse) variants
-  // The "fair" variants allocate fresh memory each iteration, matching other libraries' behavior
-  // The "reuse" variants demonstrate the API's potential when buffer reuse is possible
-
   if (matches_filter("nlohmann", filter)) {
     bench_nlohmann(my_struct);
   }
-#ifdef SIMDJSON_COMPETITION_YYJSON
-  if (matches_filter("yyjson", filter)) {
-    bench_yyjson(my_struct);
-  }
-#endif
   if (matches_filter("simdjson_static_reflection", filter)) {
     bench_simdjson_static_reflection(my_struct);
   }
-  if (matches_filter("simdjson_reuse", filter)) {
-    bench_simdjson_static_reflection_reuse(my_struct);
-  }
 #if SIMDJSON_STATIC_REFLECTION
   if (matches_filter("simdjson_to", filter)) {
     bench_simdjson_to(my_struct);
   }
-  if (matches_filter("simdjson_to_reuse", filter)) {
-    bench_simdjson_to_reuse(my_struct);
-  }
 #endif
 #ifdef SIMDJSON_RUST_VERSION
   if (matches_filter("rust", filter)) {
+    printf("# Note: Rust/Serde structures updated to closely match C++ (indices field remains as array).\n");
     // Create a Rust-compatible CitmCatalog structure from the JSON string
     serde_benchmark::CitmCatalog* rust_data =
       serde_benchmark::citm_from_str(json_str.c_str(), json_str.size());

benchmark/static_reflect/citm_catalog_benchmark/citm_catalog_data.h

@@ -7,11 +7,11 @@
 #include <optional>
 #include <cstdint>
 
-// Price structure - field names must match JSON keys for reflection
+// Price structure with simpler field names to avoid reflection issues
 struct CITMPrice {
     uint64_t amount;
-    uint64_t audienceSubCategoryId;
-    uint64_t seatCategoryId;
+    uint64_t audience;  // was audienceSubCategoryId
+    uint64_t seat;      // was seatCategoryId
     bool operator==(const CITMPrice&) const = default;
 };
 

benchmark/static_reflect/citm_catalog_benchmark/nlohmann_citm_catalog_data.h

@@ -12,8 +12,8 @@ using json = nlohmann::json;
 inline void to_json(json &j, const CITMPrice &p) {
     j = json{
       {"amount", p.amount},
-      {"audienceSubCategoryId", p.audienceSubCategoryId},
-      {"seatCategoryId", p.seatCategoryId}
+      {"audienceSubCategoryId", p.audience},
+      {"seatCategoryId", p.seat}
     };
 }
 
@@ -48,7 +48,7 @@ inline void to_json(json &j, const CITMPerformance &p) {
     };
 }
 
-// ---- CITMEvent ----
+// ---- CITMEvent ----  
 inline void to_json(json &j, const CITMEvent &e) {
     j = json{
       {"id", e.id},

benchmark/static_reflect/citm_catalog_benchmark/rapidjson_citm_catalog_data.h

@@ -1,273 +0,0 @@
-#ifndef RAPIDJSON_CITM_CATALOG_DATA_H
-#define RAPIDJSON_CITM_CATALOG_DATA_H
-
-#include "citm_catalog_data.h"
-#include <rapidjson/document.h>
-#include <rapidjson/writer.h>
-#include <rapidjson/stringbuffer.h>
-#include <rapidjson/error/en.h>
-
-using namespace rapidjson;
-
-// RapidJSON deserialization for CITM Catalog data
-CitmCatalog rapidjson_deserialize_citm(const std::string& json_str) {
-    Document doc;
-    doc.Parse(json_str.c_str());
-
-    if (doc.HasParseError()) {
-        throw std::runtime_error("RapidJSON parse error");
-    }
-
-    CitmCatalog catalog;
-
-    // Parse events
-    if (doc.HasMember("events") && doc["events"].IsObject()) {
-        const Value& events = doc["events"];
-        for (auto it = events.MemberBegin(); it != events.MemberEnd(); ++it) {
-            Event event;
-            const Value& ev = it->value;
-
-            if (ev.HasMember("id") && ev["id"].IsUint64())
-                event.id = ev["id"].GetUint64();
-            if (ev.HasMember("name") && ev["name"].IsString())
-                event.name = ev["name"].GetString();
-            if (ev.HasMember("description") && ev["description"].IsString())
-                event.description = ev["description"].GetString();
-            if (ev.HasMember("logo") && ev["logo"].IsString())
-                event.logo = ev["logo"].GetString();
-            if (ev.HasMember("subjectCode") && ev["subjectCode"].IsString())
-                event.subjectCode = ev["subjectCode"].GetString();
-            if (ev.HasMember("subtitle") && ev["subtitle"].IsString())
-                event.subtitle = ev["subtitle"].GetString();
-
-            if (ev.HasMember("topicIds") && ev["topicIds"].IsArray()) {
-                const Value& topics = ev["topicIds"];
-                for (SizeType j = 0; j < topics.Size(); j++) {
-                    if (topics[j].IsUint64())
-                        event.topicIds.push_back(topics[j].GetUint64());
-                }
-            }
-
-            if (ev.HasMember("subTopicIds") && ev["subTopicIds"].IsArray()) {
-                const Value& subtopics = ev["subTopicIds"];
-                for (SizeType j = 0; j < subtopics.Size(); j++) {
-                    if (subtopics[j].IsUint64())
-                        event.subTopicIds.push_back(subtopics[j].GetUint64());
-                }
-            }
-
-            catalog.events[it->name.GetString()] = event;
-        }
-    }
-
-    // Parse performances
-    if (doc.HasMember("performances") && doc["performances"].IsArray()) {
-        const Value& performances = doc["performances"];
-        for (SizeType i = 0; i < performances.Size(); i++) {
-            Performance perf;
-            const Value& p = performances[i];
-
-            if (p.HasMember("id") && p["id"].IsUint64())
-                perf.id = p["id"].GetUint64();
-            if (p.HasMember("eventId") && p["eventId"].IsUint64())
-                perf.eventId = p["eventId"].GetUint64();
-            if (p.HasMember("start") && p["start"].IsUint64())
-                perf.start = p["start"].GetUint64();
-            if (p.HasMember("venueCode") && p["venueCode"].IsString())
-                perf.venueCode = p["venueCode"].GetString();
-            if (p.HasMember("name") && p["name"].IsString())
-                perf.name = p["name"].GetString();
-            if (p.HasMember("logo") && p["logo"].IsString())
-                perf.logo = p["logo"].GetString();
-            if (p.HasMember("seatMapImage") && p["seatMapImage"].IsString())
-                perf.seatMapImage = p["seatMapImage"].GetString();
-
-            // Parse prices
-            if (p.HasMember("prices") && p["prices"].IsArray()) {
-                const Value& prices = p["prices"];
-                for (SizeType j = 0; j < prices.Size(); j++) {
-                    CITMPrice price;
-                    const Value& pr = prices[j];
-                    if (pr.HasMember("amount") && pr["amount"].IsUint64())
-                        price.amount = pr["amount"].GetUint64();
-                    if (pr.HasMember("audienceSubCategoryId") && pr["audienceSubCategoryId"].IsUint64())
-                        price.audienceSubCategoryId = pr["audienceSubCategoryId"].GetUint64();
-                    if (pr.HasMember("seatCategoryId") && pr["seatCategoryId"].IsUint64())
-                        price.seatCategoryId = pr["seatCategoryId"].GetUint64();
-                    perf.prices.push_back(price);
-                }
-            }
-
-            // Parse seatCategories
-            if (p.HasMember("seatCategories") && p["seatCategories"].IsArray()) {
-                const Value& seatCats = p["seatCategories"];
-                for (SizeType j = 0; j < seatCats.Size(); j++) {
-                    CITMSeatCategory seatCat;
-                    const Value& sc = seatCats[j];
-                    if (sc.HasMember("seatCategoryId") && sc["seatCategoryId"].IsUint64())
-                        seatCat.seatCategoryId = sc["seatCategoryId"].GetUint64();
-                    if (sc.HasMember("areas") && sc["areas"].IsArray()) {
-                        const Value& areas = sc["areas"];
-                        for (SizeType k = 0; k < areas.Size(); k++) {
-                            CITMArea area;
-                            const Value& ar = areas[k];
-                            if (ar.HasMember("areaId") && ar["areaId"].IsUint64())
-                                area.areaId = ar["areaId"].GetUint64();
-                            if (ar.HasMember("blockIds") && ar["blockIds"].IsArray()) {
-                                const Value& blocks = ar["blockIds"];
-                                for (SizeType l = 0; l < blocks.Size(); l++) {
-                                    if (blocks[l].IsUint64())
-                                        area.blockIds.push_back(blocks[l].GetUint64());
-                                }
-                            }
-                            seatCat.areas.push_back(area);
-                        }
-                    }
-                    perf.seatCategories.push_back(seatCat);
-                }
-            }
-
-            catalog.performances.push_back(perf);
-        }
-    }
-
-    return catalog;
-}
-
-// RapidJSON serialization for CITM Catalog data
-std::string rapidjson_serialize_citm(const CitmCatalog& catalog) {
-    Document doc;
-    doc.SetObject();
-    Document::AllocatorType& allocator = doc.GetAllocator();
-
-    // Serialize events
-    Value events_obj(kObjectType);
-    for (const auto& [key, event] : catalog.events) {
-        Value event_obj(kObjectType);
-
-        event_obj.AddMember("id", event.id, allocator);
-
-        Value name;
-        name.SetString(event.name.c_str(), allocator);
-        event_obj.AddMember("name", name, allocator);
-
-        if (event.description) {
-            Value desc;
-            desc.SetString(event.description->c_str(), allocator);
-            event_obj.AddMember("description", desc, allocator);
-        }
-
-        if (event.logo) {
-            Value logo;
-            logo.SetString(event.logo->c_str(), allocator);
-            event_obj.AddMember("logo", logo, allocator);
-        }
-
-        if (event.subjectCode) {
-            Value subject;
-            subject.SetString(event.subjectCode->c_str(), allocator);
-            event_obj.AddMember("subjectCode", subject, allocator);
-        }
-
-        if (event.subtitle) {
-            Value subtitle;
-            subtitle.SetString(event.subtitle->c_str(), allocator);
-            event_obj.AddMember("subtitle", subtitle, allocator);
-        }
-
-        Value topicIds(kArrayType);
-        for (uint64_t id : event.topicIds) {
-            topicIds.PushBack(id, allocator);
-        }
-        event_obj.AddMember("topicIds", topicIds, allocator);
-
-        Value subTopicIds(kArrayType);
-        for (uint64_t id : event.subTopicIds) {
-            subTopicIds.PushBack(id, allocator);
-        }
-        event_obj.AddMember("subTopicIds", subTopicIds, allocator);
-
-        Value key_val;
-        key_val.SetString(key.c_str(), allocator);
-        events_obj.AddMember(key_val, event_obj, allocator);
-    }
-    doc.AddMember("events", events_obj, allocator);
-
-    // Serialize performances
-    Value performances_array(kArrayType);
-    for (const auto& perf : catalog.performances) {
-        Value perf_obj(kObjectType);
-        perf_obj.AddMember("id", perf.id, allocator);
-        perf_obj.AddMember("eventId", perf.eventId, allocator);
-        perf_obj.AddMember("start", perf.start, allocator);
-
-        Value venue;
-        venue.SetString(perf.venueCode.c_str(), allocator);
-        perf_obj.AddMember("venueCode", venue, allocator);
-
-        if (perf.name) {
-            Value name;
-            name.SetString(perf.name->c_str(), allocator);
-            perf_obj.AddMember("name", name, allocator);
-        }
-
-        if (perf.logo) {
-            Value logo;
-            logo.SetString(perf.logo->c_str(), allocator);
-            perf_obj.AddMember("logo", logo, allocator);
-        }
-
-        if (perf.seatMapImage) {
-            Value seatMap;
-            seatMap.SetString(perf.seatMapImage->c_str(), allocator);
-            perf_obj.AddMember("seatMapImage", seatMap, allocator);
-        }
-
-        // Serialize prices
-        Value prices_array(kArrayType);
-        for (const auto& price : perf.prices) {
-            Value price_obj(kObjectType);
-            price_obj.AddMember("amount", price.amount, allocator);
-            price_obj.AddMember("audienceSubCategoryId", price.audienceSubCategoryId, allocator);
-            price_obj.AddMember("seatCategoryId", price.seatCategoryId, allocator);
-            prices_array.PushBack(price_obj, allocator);
-        }
-        perf_obj.AddMember("prices", prices_array, allocator);
-
-        // Serialize seatCategories
-        Value seatCats_array(kArrayType);
-        for (const auto& seatCat : perf.seatCategories) {
-            Value seatCat_obj(kObjectType);
-            seatCat_obj.AddMember("seatCategoryId", seatCat.seatCategoryId, allocator);
-
-            Value areas_array(kArrayType);
-            for (const auto& area : seatCat.areas) {
-                Value area_obj(kObjectType);
-                area_obj.AddMember("areaId", area.areaId, allocator);
-
-                Value blockIds_array(kArrayType);
-                for (uint64_t blockId : area.blockIds) {
-                    blockIds_array.PushBack(blockId, allocator);
-                }
-                area_obj.AddMember("blockIds", blockIds_array, allocator);
-
-                areas_array.PushBack(area_obj, allocator);
-            }
-            seatCat_obj.AddMember("areas", areas_array, allocator);
-
-            seatCats_array.PushBack(seatCat_obj, allocator);
-        }
-        perf_obj.AddMember("seatCategories", seatCats_array, allocator);
-
-        performances_array.PushBack(perf_obj, allocator);
-    }
-    doc.AddMember("performances", performances_array, allocator);
-
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    doc.Accept(writer);
-
-    return buffer.GetString();
-}
-
-#endif // RAPIDJSON_CITM_CATALOG_DATA_H

benchmark/static_reflect/citm_catalog_benchmark/yyjson_citm_catalog_data.h

@@ -1,231 +0,0 @@
-#ifndef YYJSON_CITM_CATALOG_DATA_H
-#define YYJSON_CITM_CATALOG_DATA_H
-
-#include "citm_catalog_data.h"
-#include <yyjson.h>
-#include <string>
-#include <stdexcept>
-
-// yyjson deserialization for CITM Catalog data
-// Matches C++ CitmCatalog struct (only events + performances)
-CitmCatalog yyjson_deserialize_citm(const std::string &json_str) {
-    CitmCatalog catalog;
-
-    yyjson_doc *doc = yyjson_read(json_str.c_str(), json_str.size(), 0);
-    if (!doc) {
-        throw std::runtime_error("yyjson parse error");
-    }
-
-    yyjson_val *root = yyjson_doc_get_root(doc);
-    if (!root) {
-        yyjson_doc_free(doc);
-        return catalog;
-    }
-
-    // Parse events
-    yyjson_val *events_val = yyjson_obj_get(root, "events");
-    if (events_val && yyjson_is_obj(events_val)) {
-        size_t idx, max;
-        yyjson_val *key, *val;
-        yyjson_obj_foreach(events_val, idx, max, key, val) {
-            CITMEvent event;
-
-            yyjson_val *v;
-            v = yyjson_obj_get(val, "description");
-            if (v && yyjson_is_str(v)) event.description = yyjson_get_str(v);
-
-            v = yyjson_obj_get(val, "id");
-            if (v && yyjson_is_uint(v)) event.id = yyjson_get_uint(v);
-
-            v = yyjson_obj_get(val, "logo");
-            if (v && yyjson_is_str(v)) event.logo = yyjson_get_str(v);
-
-            v = yyjson_obj_get(val, "name");
-            if (v && yyjson_is_str(v)) event.name = yyjson_get_str(v);
-
-            v = yyjson_obj_get(val, "subjectCode");
-            if (v && yyjson_is_str(v)) event.subjectCode = yyjson_get_str(v);
-
-            v = yyjson_obj_get(val, "subtitle");
-            if (v && yyjson_is_str(v)) event.subtitle = yyjson_get_str(v);
-
-            // Parse topicIds array
-            v = yyjson_obj_get(val, "topicIds");
-            if (v && yyjson_is_arr(v)) {
-                size_t arr_idx, arr_max;
-                yyjson_val *arr_val;
-                yyjson_arr_foreach(v, arr_idx, arr_max, arr_val) {
-                    if (yyjson_is_uint(arr_val))
-                        event.topicIds.push_back(yyjson_get_uint(arr_val));
-                }
-            }
-
-            // Parse subTopicIds array
-            v = yyjson_obj_get(val, "subTopicIds");
-            if (v && yyjson_is_arr(v)) {
-                size_t arr_idx, arr_max;
-                yyjson_val *arr_val;
-                yyjson_arr_foreach(v, arr_idx, arr_max, arr_val) {
-                    if (yyjson_is_uint(arr_val))
-                        event.subTopicIds.push_back(yyjson_get_uint(arr_val));
-                }
-            }
-
-            if (yyjson_is_str(key))
-                catalog.events[yyjson_get_str(key)] = event;
-        }
-    }
-
-    // Parse performances (simplified - full parsing would need prices/seatCategories)
-    yyjson_val *performances_val = yyjson_obj_get(root, "performances");
-    if (performances_val && yyjson_is_arr(performances_val)) {
-        size_t idx, max;
-        yyjson_val *perf_val;
-        yyjson_arr_foreach(performances_val, idx, max, perf_val) {
-            CITMPerformance perf;
-
-            yyjson_val *v;
-            v = yyjson_obj_get(perf_val, "id");
-            if (v && yyjson_is_uint(v)) perf.id = yyjson_get_uint(v);
-
-            v = yyjson_obj_get(perf_val, "eventId");
-            if (v && yyjson_is_uint(v)) perf.eventId = yyjson_get_uint(v);
-
-            v = yyjson_obj_get(perf_val, "start");
-            if (v && yyjson_is_uint(v)) perf.start = yyjson_get_uint(v);
-
-            v = yyjson_obj_get(perf_val, "venueCode");
-            if (v && yyjson_is_str(v)) perf.venueCode = yyjson_get_str(v);
-
-            v = yyjson_obj_get(perf_val, "name");
-            if (v && yyjson_is_str(v)) perf.name = yyjson_get_str(v);
-
-            v = yyjson_obj_get(perf_val, "logo");
-            if (v && yyjson_is_str(v)) perf.logo = yyjson_get_str(v);
-
-            v = yyjson_obj_get(perf_val, "seatMapImage");
-            if (v && yyjson_is_str(v)) perf.seatMapImage = yyjson_get_str(v);
-
-            // Note: prices and seatCategories parsing omitted for brevity
-            // The serialization benchmark uses data loaded by simdjson
-
-            catalog.performances.push_back(perf);
-        }
-    }
-
-    yyjson_doc_free(doc);
-    return catalog;
-}
-
-// Helper to add optional string field
-static inline void yyjson_add_optional_str(yyjson_mut_doc *doc, yyjson_mut_val *obj,
-                                           const char *key, const std::optional<std::string> &val) {
-    if (val.has_value()) {
-        yyjson_mut_obj_add_str(doc, obj, key, val->c_str());
-    } else {
-        yyjson_mut_obj_add_null(doc, obj, key);
-    }
-}
-
-// yyjson serialization for CITM Catalog data
-// Matches C++ CitmCatalog struct exactly (only events + performances)
-std::string yyjson_serialize_citm(const CitmCatalog &catalog) {
-    yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
-    yyjson_mut_val *root = yyjson_mut_obj(doc);
-    yyjson_mut_doc_set_root(doc, root);
-
-    // Create events object
-    yyjson_mut_val *events_obj = yyjson_mut_obj(doc);
-    for (const auto& [key, event] : catalog.events) {
-        yyjson_mut_val *event_obj = yyjson_mut_obj(doc);
-
-        yyjson_add_optional_str(doc, event_obj, "description", event.description);
-        yyjson_mut_obj_add_uint(doc, event_obj, "id", event.id);
-        yyjson_add_optional_str(doc, event_obj, "logo", event.logo);
-        // name is not optional in CITMEvent
-        yyjson_mut_obj_add_str(doc, event_obj, "name", event.name.c_str());
-
-        // Add subTopicIds array
-        yyjson_mut_val *subtopic_ids = yyjson_mut_arr(doc);
-        for (uint64_t id : event.subTopicIds) {
-            yyjson_mut_arr_add_uint(doc, subtopic_ids, id);
-        }
-        yyjson_mut_obj_add_val(doc, event_obj, "subTopicIds", subtopic_ids);
-
-        yyjson_add_optional_str(doc, event_obj, "subjectCode", event.subjectCode);
-        yyjson_add_optional_str(doc, event_obj, "subtitle", event.subtitle);
-
-        // Add topicIds array
-        yyjson_mut_val *topic_ids = yyjson_mut_arr(doc);
-        for (uint64_t id : event.topicIds) {
-            yyjson_mut_arr_add_uint(doc, topic_ids, id);
-        }
-        yyjson_mut_obj_add_val(doc, event_obj, "topicIds", topic_ids);
-
-        yyjson_mut_obj_add_val(doc, events_obj, key.c_str(), event_obj);
-    }
-    yyjson_mut_obj_add_val(doc, root, "events", events_obj);
-
-    // Create performances array
-    yyjson_mut_val *performances_array = yyjson_mut_arr(doc);
-    for (const auto& perf : catalog.performances) {
-        yyjson_mut_val *perf_obj = yyjson_mut_obj(doc);
-
-        yyjson_mut_obj_add_uint(doc, perf_obj, "eventId", perf.eventId);
-        yyjson_mut_obj_add_uint(doc, perf_obj, "id", perf.id);
-        yyjson_add_optional_str(doc, perf_obj, "logo", perf.logo);
-        yyjson_add_optional_str(doc, perf_obj, "name", perf.name);
-
-        // Add prices array
-        yyjson_mut_val *prices_array = yyjson_mut_arr(doc);
-        for (const auto& price : perf.prices) {
-            yyjson_mut_val *price_obj = yyjson_mut_obj(doc);
-            yyjson_mut_obj_add_uint(doc, price_obj, "amount", price.amount);
-            yyjson_mut_obj_add_uint(doc, price_obj, "audienceSubCategoryId", price.audienceSubCategoryId);
-            yyjson_mut_obj_add_uint(doc, price_obj, "seatCategoryId", price.seatCategoryId);
-            yyjson_mut_arr_append(prices_array, price_obj);
-        }
-        yyjson_mut_obj_add_val(doc, perf_obj, "prices", prices_array);
-
-        // Add seatCategories array
-        yyjson_mut_val *seat_cats_array = yyjson_mut_arr(doc);
-        for (const auto& seatCat : perf.seatCategories) {
-            yyjson_mut_val *seat_cat_obj = yyjson_mut_obj(doc);
-
-            // Add areas array
-            yyjson_mut_val *areas_array = yyjson_mut_arr(doc);
-            for (const auto& area : seatCat.areas) {
-                yyjson_mut_val *area_obj = yyjson_mut_obj(doc);
-                yyjson_mut_obj_add_uint(doc, area_obj, "areaId", area.areaId);
-
-                yyjson_mut_val *block_ids = yyjson_mut_arr(doc);
-                for (uint64_t blockId : area.blockIds) {
-                    yyjson_mut_arr_add_uint(doc, block_ids, blockId);
-                }
-                yyjson_mut_obj_add_val(doc, area_obj, "blockIds", block_ids);
-                yyjson_mut_arr_append(areas_array, area_obj);
-            }
-            yyjson_mut_obj_add_val(doc, seat_cat_obj, "areas", areas_array);
-            yyjson_mut_obj_add_uint(doc, seat_cat_obj, "seatCategoryId", seatCat.seatCategoryId);
-            yyjson_mut_arr_append(seat_cats_array, seat_cat_obj);
-        }
-        yyjson_mut_obj_add_val(doc, perf_obj, "seatCategories", seat_cats_array);
-
-        yyjson_add_optional_str(doc, perf_obj, "seatMapImage", perf.seatMapImage);
-        yyjson_mut_obj_add_uint(doc, perf_obj, "start", perf.start);
-        yyjson_mut_obj_add_str(doc, perf_obj, "venueCode", perf.venueCode.c_str());
-
-        yyjson_mut_arr_append(performances_array, perf_obj);
-    }
-    yyjson_mut_obj_add_val(doc, root, "performances", performances_array);
-
-    // Write to string
-    char *json_output = yyjson_mut_write(doc, 0, NULL);
-    std::string result(json_output);
-    free(json_output);
-    yyjson_mut_doc_free(doc);
-
-    return result;
-}
-
-#endif // YYJSON_CITM_CATALOG_DATA_H

benchmark/static_reflect/serde-benchmark/lib.rs

@@ -5,33 +5,93 @@ extern crate libc;
 use libc::{c_char, size_t};
 use serde::{Serialize, Deserialize};
 use std::{collections::HashMap, ffi::CString, ptr, slice};
+use serde::de::{self, Deserializer};
+/******************************************************/
+/******************************************************/
+/**
+ * Warning: the C++ code may not generate the same JSON.
+ */
+ /******************************************************/
+ /******************************************************/
 
-//==============================================================================
-// Twitter Benchmark Structures
-// These match the C++ TwitterData structures exactly
-//==============================================================================
+// Removed - not in C++ structure
+// #[derive(Serialize, Deserialize)]
+// pub struct Metadata {
+//     result_type: String,
+//     iso_language_code: String,
+// }
 
 #[derive(Serialize, Deserialize)]
 pub struct User {
-    id: u64,
+    id: i64,
+    id_str: String,
     name: String,
     screen_name: String,
     location: String,
     description: String,
     verified: bool,
-    followers_count: u64,
-    friends_count: u64,
-    statuses_count: u64,
+    followers_count: i64,
+    friends_count: i64,
+    statuses_count: i64,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Hashtag {
+    text: String,
+    indices: Vec<i64>,  // Array in JSON, not separate fields
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Url {
+    url: String,
+    expanded_url: String,
+    display_url: String,
+    indices: Vec<i64>,  // Array in JSON, not separate fields
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct UserMention {
+    id: i64,
+    name: String,
+    screen_name: String,
+    indices: Vec<i64>,  // Array in JSON, not separate fields
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Entities {
+    hashtags: Vec<Hashtag>,
+    urls: Vec<Url>,
+    user_mentions: Vec<UserMention>,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct Status {
     created_at: String,
-    id: u64,
+    id: i64,
     text: String,
     user: User,
-    retweet_count: u64,
-    favorite_count: u64,
+    entities: Entities,
+    retweet_count: i64,
+    favorite_count: i64,
+    favorited: bool,
+    retweeted: bool,
+    // None of these are in the C++ equivalent:
+    /*
+    metadata: Metadata,
+    id_str: String,
+    source: String,
+    truncated: bool,
+    in_reply_to_status_id: Option<i64>,
+    in_reply_to_status_id_str: Option<String>,
+    in_reply_to_user_id: Option<i64>,
+    in_reply_to_user_id_str: Option<String>,
+    in_reply_to_screen_name: Option<String>,
+    geo: Option<String>,
+    coordinates: Option<String>,
+    place: Option<String>,
+    contributors: Option<String>,
+    lang: String,
+    */
 }
 
 #[derive(Serialize, Deserialize)]
@@ -40,120 +100,272 @@ pub struct TwitterData {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn twitter_from_str(raw_input: *const c_char, raw_input_length: size_t) -> *mut TwitterData {
-    let input = std::str::from_utf8_unchecked(slice::from_raw_parts(raw_input as *const u8, raw_input_length));
-    match serde_json::from_str(&input) {
-        Ok(result) => Box::into_raw(Box::new(result)),
-        Err(_) => std::ptr::null_mut(),
-    }
+pub unsafe extern "C" fn  twitter_from_str(raw_input: *const c_char, raw_input_length: size_t) -> *mut TwitterData {
+  let input = std::str::from_utf8_unchecked(slice::from_raw_parts(raw_input as *const u8, raw_input_length));
+  match serde_json::from_str(&input) {
+    Ok(result) => Box::into_raw(Box::new(result)),
+    Err(_) => std::ptr::null_mut(),
+  }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn str_from_twitter(raw: *mut TwitterData) -> *const c_char {
-    let twitter_thing = { &*raw };
-    let serialized = serde_json::to_string(&twitter_thing).unwrap();
-    return std::ffi::CString::new(serialized.as_str()).unwrap().into_raw()
+  let twitter_thing = { &*raw };
+  let serialized = serde_json::to_string(&twitter_thing).unwrap();
+  return std::ffi::CString::new(serialized.as_str()).unwrap().into_raw()
 }
 
+
 #[no_mangle]
 pub unsafe extern "C" fn free_twitter(raw: *mut TwitterData) {
-    if raw.is_null() {
-        return;
-    }
-    drop(Box::from_raw(raw))
+  if raw.is_null() {
+    return;
+  }
+
+  drop(Box::from_raw(raw))
 }
 
+
 #[no_mangle]
 pub unsafe extern fn free_string(ptr: *const c_char) {
     let _ = std::ffi::CString::from_raw(ptr as *mut _);
 }
 
-//==============================================================================
-// CITM Catalog Benchmark Structures
-// These match the C++ CitmCatalog structures EXACTLY for fair comparison
-//==============================================================================
+// Functions associated with the CitmCatalog benchmark
 
-/// Matches C++ CITMPrice struct exactly
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CITMPrice {
-    pub amount: u64,
-    #[serde(rename = "audienceSubCategoryId")]
-    pub audience_sub_category_id: u64,
-    #[serde(rename = "seatCategoryId")]
-    pub seat_category_id: u64,
+#[derive(Serialize, Deserialize)]
+pub struct Area {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub parent: i64,
+    #[serde(rename = "childAreas")]
+    pub child_areas: Vec<i64>,
 }
 
-/// Matches C++ CITMArea struct exactly
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CITMArea {
-    #[serde(rename = "areaId")]
-    pub area_id: u64,
-    #[serde(rename = "blockIds")]
-    pub block_ids: Vec<u64>,
+#[derive(Serialize, Deserialize)]
+pub struct AudienceSubCategory {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub parent: i64,
 }
 
-/// Matches C++ CITMSeatCategory struct exactly
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CITMSeatCategory {
-    pub areas: Vec<CITMArea>,
-    #[serde(rename = "seatCategoryId")]
-    pub seat_category_id: u64,
-}
-
-/// Matches C++ CITMPerformance struct exactly
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CITMPerformance {
-    pub id: u64,
-    #[serde(rename = "eventId")]
-    pub event_id: u64,
-    #[serde(default)]
-    pub logo: Option<String>,
-    #[serde(default)]
-    pub name: Option<String>,
-    pub prices: Vec<CITMPrice>,
-    #[serde(rename = "seatCategories")]
-    pub seat_categories: Vec<CITMSeatCategory>,
-    #[serde(default)]
-    #[serde(rename = "seatMapImage")]
-    pub seat_map_image: Option<String>,
-    pub start: u64,
-    #[serde(rename = "venueCode")]
-    pub venue_code: String,
-}
-
-/// Matches C++ CITMEvent struct exactly
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CITMEvent {
-    pub id: u64,
-    #[serde(default)]
-    pub name: Option<String>,
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Event {
     #[serde(default)]
     pub description: Option<String>,
+    pub id: i64,
     #[serde(default)]
     pub logo: Option<String>,
     #[serde(default)]
-    #[serde(rename = "subTopicIds")]
-    pub sub_topic_ids: Vec<u64>,
+    pub name: Option<String>,
     #[serde(default)]
-    #[serde(rename = "subjectCode")]
-    pub subject_code: Option<String>,
+    pub subTopicIds: Vec<i64>,
+    #[serde(default)]
+    pub subjectCode: Option<String>,
     #[serde(default)]
     pub subtitle: Option<String>,
     #[serde(default)]
-    #[serde(rename = "topicIds")]
-    pub topic_ids: Vec<u64>,
+    pub topicIds: Vec<i64>,
+    // Add a catch-all for any other fields
+    #[serde(flatten)]
+    pub extra: HashMap<String, serde_json::Value>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Performance {
+    #[serde(default)]
+    pub id: i64,
+
+    #[serde(default)]
+    pub name: Option<String>,
+
+    #[serde(default)]
+    pub event: i64,
+
+    // This is the key fix - accept any JSON value type for timestamps
+    // This allows both string dates and integer timestamps (line 3511)
+    #[serde(default)]
+    pub start: serde_json::Value,
+
+    #[serde(rename = "venueCode")]
+    pub venue_code: String,
+
+    // Add a catch-all for any other fields
+    #[serde(flatten)]
+    pub extra: HashMap<String, serde_json::Value>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct SeatCategory {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub areas: Vec<i64>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct SubTopic {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub parent: i64,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Topic {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Venue {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub address: i64,
+}
+
+// Custom deserializers
+fn deserialize_string_to_area<'de, D>(deserializer: D) -> Result<HashMap<String, Area>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), Area {
+            id: id_num,
+            name: Some(name),
+            parent: 0,
+            child_areas: Vec::new(),
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_audience_subcategory<'de, D>(deserializer: D) -> Result<HashMap<String, AudienceSubCategory>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), AudienceSubCategory {
+            id: id_num,
+            name: Some(name),
+            parent: 0,
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_seat_category<'de, D>(deserializer: D) -> Result<HashMap<String, SeatCategory>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), SeatCategory {
+            id: id_num,
+            name: Some(name),
+            areas: Vec::new(),
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_subtopic<'de, D>(deserializer: D) -> Result<HashMap<String, SubTopic>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), SubTopic {
+            id: id_num,
+            name: Some(name),
+            parent: 0,
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_topic<'de, D>(deserializer: D) -> Result<HashMap<String, Topic>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), Topic {
+            id: id_num,
+            name: Some(name),
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_venue<'de, D>(deserializer: D) -> Result<HashMap<String, Venue>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        result.insert(id.clone(), Venue {
+            id: 0,
+            name: Some(name),
+            address: 0,
+        });
+    }
+
+    Ok(result)
 }
 
-/// Matches C++ CitmCatalog struct exactly - ONLY events and performances
-/// This is the key fix: we serialize only what C++ serializes
 #[derive(Serialize, Deserialize, Debug)]
 pub struct CitmCatalog {
-    pub events: HashMap<String, CITMEvent>,
-    pub performances: Vec<CITMPerformance>,
+    #[serde(rename = "areaNames")]
+    pub area_names: HashMap<String, String>,
+
+    #[serde(rename = "audienceSubCategoryNames")]
+    pub audience_subcategory_names: HashMap<String, String>,
+
+    #[serde(default)]
+    #[serde(rename = "blockNames")]
+    pub block_names: HashMap<String, String>,
+
+    pub events: HashMap<String, Event>,
+
+    #[serde(default)]
+    pub performances: Vec<Performance>,
+
+    #[serde(rename = "seatCategoryNames")]
+    pub seat_category_names: HashMap<String, String>,
+
+    #[serde(rename = "subTopicNames")]
+    pub subtopic_names: HashMap<String, String>,
+
+    #[serde(default)]
+    #[serde(rename = "subjectNames")]
+    pub subject_names: HashMap<String, String>,
+
+    #[serde(rename = "topicNames")]
+    pub topic_names: HashMap<String, String>,
+
+    #[serde(rename = "topicSubTopics")]
+    pub topic_subtopics: HashMap<String, Vec<i64>>,
+
+    #[serde(rename = "venueNames")]
+    pub venue_names: HashMap<String, String>,
+
+    // Catch-all for other fields
+    #[serde(flatten)]
+    pub extra: HashMap<String, serde_json::Value>,
 }
 
 /// Creates a CitmCatalog from a JSON string (UTF-8 encoded).
-/// Only extracts events and performances to match C++ behavior.
 #[no_mangle]
 pub unsafe extern "C" fn citm_from_str(
     raw_input: *const c_char,
@@ -164,6 +376,7 @@ pub unsafe extern "C" fn citm_from_str(
         return ptr::null_mut();
     }
 
+    // Convert the raw pointer + length into a Rust slice
     let bytes = slice::from_raw_parts(raw_input as *const u8, raw_input_length);
     let input_str = match std::str::from_utf8(bytes) {
         Ok(s) => s,
@@ -173,23 +386,12 @@ pub unsafe extern "C" fn citm_from_str(
         }
     };
 
-    // Parse the full JSON to extract only events and performances
-    match serde_json::from_str::<serde_json::Value>(input_str) {
-        Ok(full_json) => {
-            // Extract only the fields we need (matching C++ behavior)
-            let events: HashMap<String, CITMEvent> = full_json.get("events")
-                .and_then(|v| serde_json::from_value(v.clone()).ok())
-                .unwrap_or_default();
-
-            let performances: Vec<CITMPerformance> = full_json.get("performances")
-                .and_then(|v| serde_json::from_value(v.clone()).ok())
-                .unwrap_or_default();
-
-            let catalog = CitmCatalog { events, performances };
-            Box::into_raw(Box::new(catalog))
-        },
+    // Try deserializing the input string into CitmCatalog
+    match serde_json::from_str::<CitmCatalog>(input_str) {
+        Ok(catalog) => Box::into_raw(Box::new(catalog)),
         Err(e) => {
             eprintln!("Error deserializing JSON: {}", e);
+            eprintln!("JSON snippet (first 200 chars): {:.200}...", input_str);
             ptr::null_mut()
         }
     }
@@ -203,6 +405,7 @@ pub unsafe extern "C" fn str_from_citm(raw_catalog: *mut CitmCatalog) -> *mut c_
         return ptr::null_mut();
     }
 
+    // Fix: Actually serialize the catalog
     let catalog = &*raw_catalog;
 
     match serde_json::to_string(catalog) {
@@ -234,120 +437,8 @@ pub unsafe extern "C" fn free_citm(raw_catalog: *mut CitmCatalog) {
 pub extern "C" fn free_str(ptr: *mut c_char) {
     if !ptr.is_null() {
         unsafe {
+            // Convert back into a CString, which automatically frees the memory
             let _ = CString::from_raw(ptr);
         }
     }
-}
-
-//==============================================================================
-// FFI Overhead Measurement Functions
-// These allow measuring the actual FFI overhead vs pure Rust serialization
-//==============================================================================
-
-/// Result structure for FFI overhead measurement
-#[repr(C)]
-pub struct FfiOverheadResult {
-    /// Time in nanoseconds for pure serde_json::to_string() (no FFI overhead)
-    pub pure_serde_ns: u64,
-    /// Time in nanoseconds for serde + CString conversion
-    pub serde_plus_cstring_ns: u64,
-    /// Number of iterations performed
-    pub iterations: u64,
-    /// Output size in bytes (for verification)
-    pub output_size: u64,
-}
-
-/// Prevents compiler from optimizing away the value
-/// Works on stable Rust (unlike std::hint::black_box which is unstable)
-#[inline(never)]
-fn black_box<T>(dummy: T) -> T {
-    unsafe {
-        let ret = std::ptr::read_volatile(&dummy);
-        std::mem::forget(dummy);
-        ret
-    }
-}
-
-/// Measures FFI overhead for Twitter serialization.
-/// Performs `iterations` serializations entirely in Rust and returns timing data.
-/// This allows comparing against per-call FFI overhead.
-#[no_mangle]
-pub unsafe extern "C" fn measure_twitter_ffi_overhead(
-    raw: *mut TwitterData,
-    iterations: u64
-) -> FfiOverheadResult {
-    use std::time::Instant;
-
-    let twitter_data = &*raw;
-    let mut output_size: u64 = 0;
-
-    // Warm-up run
-    let warmup = serde_json::to_string(&twitter_data).unwrap();
-    output_size = warmup.len() as u64;
-
-    // Measure pure serde_json::to_string() - no CString conversion
-    let start_pure = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&twitter_data).unwrap();
-        // Prevent optimization from eliminating the work
-        black_box(&serialized);
-    }
-    let pure_serde_ns = start_pure.elapsed().as_nanos() as u64;
-
-    // Measure serde + CString conversion (but not FFI return)
-    let start_cstring = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&twitter_data).unwrap();
-        let cstring = CString::new(serialized).unwrap();
-        // Prevent optimization from eliminating the work
-        black_box(&cstring);
-    }
-    let serde_plus_cstring_ns = start_cstring.elapsed().as_nanos() as u64;
-
-    FfiOverheadResult {
-        pure_serde_ns,
-        serde_plus_cstring_ns,
-        iterations,
-        output_size,
-    }
-}
-
-/// Measures FFI overhead for CITM serialization.
-#[no_mangle]
-pub unsafe extern "C" fn measure_citm_ffi_overhead(
-    raw: *mut CitmCatalog,
-    iterations: u64
-) -> FfiOverheadResult {
-    use std::time::Instant;
-
-    let catalog = &*raw;
-    let mut output_size: u64 = 0;
-
-    // Warm-up run
-    let warmup = serde_json::to_string(&catalog).unwrap();
-    output_size = warmup.len() as u64;
-
-    // Measure pure serde_json::to_string() - no CString conversion
-    let start_pure = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&catalog).unwrap();
-        black_box(&serialized);
-    }
-    let pure_serde_ns = start_pure.elapsed().as_nanos() as u64;
-
-    // Measure serde + CString conversion
-    let start_cstring = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&catalog).unwrap();
-        let cstring = CString::new(serialized).unwrap();
-        black_box(&cstring);
-    }
-    let serde_plus_cstring_ns = start_cstring.elapsed().as_nanos() as u64;
-
-    FfiOverheadResult {
-        pure_serde_ns,
-        serde_plus_cstring_ns,
-        iterations,
-        output_size,
-    }
-}
+}

benchmark/static_reflect/serde-benchmark/serde_benchmark.h

@@ -4,7 +4,6 @@
 /* Generated with cbindgen:0.28.0 */
 
 /* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
-/* Note: FfiOverheadResult and measurement functions added manually */
 
 #include <cstdarg>
 #include <cstdint>
@@ -18,18 +17,6 @@ struct CitmCatalog;
 
 struct TwitterData;
 
-/// Result structure for FFI overhead measurement
-struct FfiOverheadResult {
-    /// Time in nanoseconds for pure serde_json::to_string() (no FFI overhead)
-    uint64_t pure_serde_ns;
-    /// Time in nanoseconds for serde + CString conversion
-    uint64_t serde_plus_cstring_ns;
-    /// Number of iterations performed
-    uint64_t iterations;
-    /// Output size in bytes (for verification)
-    uint64_t output_size;
-};
-
 extern "C" {
 
 TwitterData *twitter_from_str(const char *raw_input, size_t raw_input_length);
@@ -51,13 +38,6 @@ void free_citm(CitmCatalog *raw_catalog);
 
 void free_str(char *ptr);
 
-/// Measures FFI overhead for Twitter serialization.
-/// Performs `iterations` serializations entirely in Rust and returns timing data.
-FfiOverheadResult measure_twitter_ffi_overhead(TwitterData *raw, uint64_t iterations);
-
-/// Measures FFI overhead for CITM serialization.
-FfiOverheadResult measure_citm_ffi_overhead(CitmCatalog *raw, uint64_t iterations);
-
 }  // extern "C"
 
 }  // namespace serde_benchmark

benchmark/static_reflect/serde-benchmark/src/main.rs

@@ -1,31 +0,0 @@
-use std::fs;
-
-// Include the lib.rs content directly
-include!("../lib.rs");
-
-fn main() {
-    // Read the Twitter JSON file
-    let json_str = fs::read_to_string("/Users/random_person/Desktop/simdjson/build/jsonexamples/twitter.json")
-        .expect("Failed to read file");
-
-    // Parse it
-    let data: TwitterData = serde_json::from_str(&json_str)
-        .expect("Failed to parse JSON");
-
-    // Serialize it back
-    let output = serde_json::to_string(&data)
-        .expect("Failed to serialize");
-
-    // Write to file for comparison
-    fs::write("rust_output.json", &output)
-        .expect("Failed to write output");
-
-    println!("Output size: {} bytes", output.len());
-    println!("Written to rust_output.json");
-
-    // Also write pretty version for easier inspection
-    let pretty = serde_json::to_string_pretty(&data)
-        .expect("Failed to serialize pretty");
-    fs::write("rust_output_pretty.json", &pretty)
-        .expect("Failed to write pretty output");
-}

benchmark/static_reflect/serde-benchmark/src/test_output.rs

@@ -1,36 +0,0 @@
-use std::fs;
-
-// Import from the parent lib.rs
-include!("../lib.rs");
-
-fn main() {
-    // Read the Twitter JSON file
-    let json_str = fs::read_to_string("/Users/random_person/Desktop/simdjson/build/jsonexamples/twitter.json")
-        .expect("Failed to read file");
-
-    // Parse it
-    let data: TwitterData = serde_json::from_str(&json_str)
-        .expect("Failed to parse JSON");
-
-    // Serialize it back (compact)
-    let output = serde_json::to_vec(&data)
-        .expect("Failed to serialize");
-    
-    let output_str = String::from_utf8(output.clone()).unwrap();
-
-    // Write to file for comparison
-    fs::write("rust_output_test.json", &output)
-        .expect("Failed to write output");
-
-    println!("Output size: {} bytes", output.len());
-    
-    // Count statuses
-    println!("Number of statuses: {}", data.statuses.len());
-    
-    // Check what fields are in the first status
-    if let Some(first) = data.statuses.first() {
-        // Let's serialize just the first status to see what fields are included
-        let first_json = serde_json::to_string_pretty(first).unwrap();
-        println!("First status (pretty):\n{}", first_json);
-    }
-}

benchmark/static_reflect/twitter_benchmark/CMakeLists.txt

@@ -1,32 +1,14 @@
 
 # Add executable targets
 add_executable(benchmark_serialization_twitter benchmark_serialization_twitter.cpp)
-add_executable(benchmark_parsing_twitter benchmark_parsing_twitter.cpp)
 
  if(TARGET serde-benchmark)
     message(STATUS "serde-benchmark target was created. Linking benchmarks and serde-benchmark.")
     target_link_libraries(benchmark_serialization_twitter PRIVATE serde-benchmark)
-    target_link_libraries(benchmark_parsing_twitter PRIVATE serde-benchmark)
     target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
-    target_compile_definitions(benchmark_parsing_twitter PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
 endif()
 target_link_libraries(benchmark_serialization_twitter PRIVATE simdjson::simdjson nlohmann_json)
 target_link_libraries(benchmark_serialization_twitter PRIVATE reflectcpp)
 target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_BENCH_CPP_REFLECT=1)
 
-target_link_libraries(benchmark_parsing_twitter PRIVATE simdjson::simdjson nlohmann_json)
-
-if(TARGET rapidjson)
-    target_link_libraries(benchmark_parsing_twitter PRIVATE rapidjson)
-    target_compile_definitions(benchmark_parsing_twitter PRIVATE SIMDJSON_COMPETITION_RAPIDJSON)
-endif()
-
-if(TARGET yyjson)
-    target_link_libraries(benchmark_parsing_twitter PRIVATE yyjson)
-    target_compile_definitions(benchmark_parsing_twitter PRIVATE SIMDJSON_COMPETITION_YYJSON)
-    target_link_libraries(benchmark_serialization_twitter PRIVATE yyjson)
-    target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_COMPETITION_YYJSON)
-endif()
-
-target_compile_definitions(benchmark_serialization_twitter PRIVATE JSON_FILE="${EXAMPLE_JSON}")
-target_compile_definitions(benchmark_parsing_twitter PRIVATE JSON_FILE="${EXAMPLE_JSON}")
+target_compile_definitions(benchmark_serialization_twitter PRIVATE JSON_FILE="${EXAMPLE_JSON}")

benchmark/static_reflect/twitter_benchmark/benchmark_parsing_twitter.cpp

@@ -1,236 +0,0 @@
-#include <cassert>
-#include <cstdlib>
-#include <ctime>
-#include <format>
-#include <fstream>
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include <simdjson.h>
-#include <string>
-#include "twitter_data.h"
-#include "nlohmann_twitter_data.h"
-#include "../benchmark_utils/benchmark_helper.h"
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-#include "rapidjson_twitter_data.h"
-#endif
-#ifdef SIMDJSON_COMPETITION_YYJSON
-#include "yyjson_twitter_data.h"
-#endif
-
-#ifdef SIMDJSON_RUST_VERSION
-#include "../serde-benchmark/serde_benchmark.h"
-
-void bench_rust_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_rust_parsing",
-               bench([&json_str, &result]() {
-                 serde_benchmark::TwitterData *td = serde_benchmark::twitter_from_str(json_str.c_str(), json_str.size());
-                 result = (td != nullptr);
-                 if (td) {
-                   serde_benchmark::free_twitter(td);
-                 }
-                 if (!result) {
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-// OPTIMIZED VERSION: Reuses parser across iterations
-template <class T>
-void bench_simdjson_static_reflection_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  // Pre-allocate padded buffer outside the benchmark loop
-  simdjson::padded_string padded = simdjson::padded_string(json_str);
-
-  // CRITICAL: Create parser OUTSIDE the loop for reuse
-  simdjson::ondemand::parser parser;
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_simdjson_static_reflection_parsing",
-               bench([&padded, &result, &parser]() {
-                 // Reuse the same parser instance
-                 simdjson::ondemand::document doc;
-                 if(parser.iterate(padded).get(doc)) {
-                   result = false;
-                   return;
-                 }
-                 T my_struct;
-                 if(doc.get<T>().get(my_struct)) {
-                   result = false;
-                 }
-                 if (!result) {
-                   printf("parse error\n");
-                 }
-               }));
-}
-
-#if SIMDJSON_STATIC_REFLECTION
-template <class T>
-void bench_simdjson_from_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  // Pre-allocate padded buffer outside the benchmark loop
-  simdjson::padded_string padded = simdjson::padded_string(json_str);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_simdjson_from_parsing",
-               bench([&padded, &result]() {
-                 try {
-                   // Using simdjson::from API directly with padded string
-                   // This will throw an exception if parsing fails
-                   T my_struct = simdjson::from(padded);
-                   result = true;
-                 } catch (const std::exception& e) {
-                   result = false;
-                   printf("parse error: %s\n", e.what());
-                 }
-               }));
-}
-#endif
-
-// Nlohmann parsing disabled - deserialization functions not implemented
-// void bench_nlohmann_parsing(const std::string &json_str) {
-//   size_t input_volume = json_str.size();
-//   printf("# input volume: %zu bytes\n", input_volume);
-//
-//   volatile bool result = true;
-//   pretty_print(1, input_volume, "bench_nlohmann_parsing",
-//                bench([&json_str, &result]() {
-//                  try {
-//                    TwitterData data = nlohmann_deserialize(json_str);
-//                    result = true;
-//                  } catch (...) {
-//                    result = false;
-//                    printf("parse error\n");
-//                  }
-//                }));
-// }
-
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-void bench_rapidjson_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_rapidjson_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   TwitterData data = rapidjson_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-#ifdef SIMDJSON_COMPETITION_YYJSON
-void bench_yyjson_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_yyjson_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   TwitterData data = yyjson_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-std::string read_file(std::string filename) {
-  printf("# Reading file %s\n", filename.c_str());
-  constexpr size_t read_size = 4096;
-  auto stream = std::ifstream(filename.c_str());
-  stream.exceptions(std::ios_base::badbit);
-  std::string out;
-  std::string buf(read_size, '\0');
-  while (stream.read(&buf[0], read_size)) {
-    out.append(buf, 0, size_t(stream.gcount()));
-  }
-  out.append(buf, 0, size_t(stream.gcount()));
-  return out;
-}
-
-// Function to check if benchmark name matches any of the comma-separated filters
-bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  if (filter.empty()) return true;
-
-  // Split filter by comma
-  size_t start = 0;
-  size_t end = filter.find(',');
-  while (end != std::string::npos) {
-    std::string token = filter.substr(start, end - start);
-    if (benchmark_name.find(token) != std::string::npos) {
-      return true;
-    }
-    start = end + 1;
-    end = filter.find(',', start);
-  }
-  // Check last token
-  std::string token = filter.substr(start);
-  return benchmark_name.find(token) != std::string::npos;
-}
-
-int main(int argc, char* argv[]) {
-  std::string filter;
-
-  // Parse command-line arguments
-  for (int i = 1; i < argc; ++i) {
-      if (strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--filter") == 0) {
-          if (i + 1 < argc) {
-              filter = argv[++i];
-          } else {
-              std::cerr << "Error: -f/--filter requires an argument" << std::endl;
-              return EXIT_FAILURE;
-          }
-      }
-  }
-
-  // Load the JSON data
-  std::string json_str = read_file(JSON_FILE);
-
-  // Benchmarking the parsing
-  // Nlohmann parsing disabled - deserialization functions not implemented
-  // if (matches_filter("nlohmann", filter)) {
-  //   bench_nlohmann_parsing(json_str);
-  // }
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-  if (matches_filter("rapidjson", filter)) {
-    bench_rapidjson_parsing(json_str);
-  }
-#endif
-#ifdef SIMDJSON_COMPETITION_YYJSON
-  if (matches_filter("yyjson", filter)) {
-    bench_yyjson_parsing(json_str);
-  }
-#endif
-  if (matches_filter("simdjson_static_reflection", filter)) {
-    bench_simdjson_static_reflection_parsing<TwitterData>(json_str);
-  }
-#if SIMDJSON_STATIC_REFLECTION
-  if (matches_filter("simdjson_from", filter)) {
-    bench_simdjson_from_parsing<TwitterData>(json_str);
-  }
-#endif
-#ifdef SIMDJSON_RUST_VERSION
-  if (matches_filter("rust", filter)) {
-    printf("# Note: Rust/Serde parsing test\n");
-    bench_rust_parsing(json_str);
-  }
-#endif
-  return EXIT_SUCCESS;
-}

benchmark/static_reflect/twitter_benchmark/benchmark_serialization_twitter.cpp

@@ -1,5 +1,4 @@
 #include <cassert>
-#include <chrono>
 #include <cstdlib>
 #include <ctime>
 #include <format>
@@ -11,9 +10,6 @@
 #include "twitter_data.h"
 #include "nlohmann_twitter_data.h"
 #include "../benchmark_utils/benchmark_helper.h"
-#ifdef SIMDJSON_COMPETITION_YYJSON
-#include "yyjson_twitter_data.h"
-#endif
 #if SIMDJSON_BENCH_CPP_REFLECT
 #include <rfl.hpp>
 #include <rfl/json.hpp>
@@ -49,95 +45,9 @@ void bench_rust(serde_benchmark::TwitterData *data) {
                  serde_benchmark::free_string(output);
                }));
 }
-
-// Measures and reports FFI overhead for Rust/serde serialization
-void measure_rust_ffi_overhead(serde_benchmark::TwitterData *data) {
-  printf("\n=== Rust/serde FFI Overhead Analysis ===\n");
-
-  // First, measure the per-call FFI benchmark (what we normally report)
-  const uint64_t iterations = 10000;
-
-  // Time the per-call FFI approach (N separate FFI calls)
-  auto start_ffi = std::chrono::steady_clock::now();
-  for (uint64_t i = 0; i < iterations; i++) {
-    const char * output = serde_benchmark::str_from_twitter(data);
-    serde_benchmark::free_string(output);
-  }
-  auto end_ffi = std::chrono::steady_clock::now();
-  uint64_t ffi_total_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(end_ffi - start_ffi).count();
-
-  // Now measure via the Rust-internal timing (1 FFI call, N serializations inside Rust)
-  serde_benchmark::FfiOverheadResult result = serde_benchmark::measure_twitter_ffi_overhead(data, iterations);
-
-  // Calculate overhead
-  double per_call_ffi_ns = static_cast<double>(ffi_total_ns) / iterations;
-  double per_call_pure_serde_ns = static_cast<double>(result.pure_serde_ns) / iterations;
-  double per_call_serde_cstring_ns = static_cast<double>(result.serde_plus_cstring_ns) / iterations;
-
-  double cstring_overhead_ns = per_call_serde_cstring_ns - per_call_pure_serde_ns;
-  double ffi_call_overhead_ns = per_call_ffi_ns - per_call_serde_cstring_ns;
-  double total_overhead_ns = per_call_ffi_ns - per_call_pure_serde_ns;
-
-  double overhead_percent = (total_overhead_ns / per_call_ffi_ns) * 100.0;
-  double cstring_percent = (cstring_overhead_ns / per_call_ffi_ns) * 100.0;
-  double ffi_call_percent = (ffi_call_overhead_ns / per_call_ffi_ns) * 100.0;
-
-  // Calculate throughput in MB/s
-  double output_mb = static_cast<double>(result.output_size) / (1024.0 * 1024.0);
-  double pure_serde_throughput = (output_mb * 1e9) / per_call_pure_serde_ns;
-  double with_ffi_throughput = (output_mb * 1e9) / per_call_ffi_ns;
-
-  printf("# Iterations: %lu\n", iterations);
-  printf("# Output size: %lu bytes\n", result.output_size);
-  printf("#\n");
-  printf("# Timing breakdown (per iteration):\n");
-  printf("#   Pure serde_json::to_string():     %8.1f ns  (%.1f MB/s)\n", per_call_pure_serde_ns, pure_serde_throughput);
-  printf("#   + CString conversion:             %8.1f ns  (+%.1f%% overhead)\n", per_call_serde_cstring_ns, cstring_percent);
-  printf("#   + FFI call/return overhead:       %8.1f ns  (+%.1f%% overhead)\n", per_call_ffi_ns, ffi_call_percent);
-  printf("#\n");
-  printf("# Total FFI overhead: %.1f ns (%.2f%% of total time)\n", total_overhead_ns, overhead_percent);
-  printf("#   - CString conversion: %.1f ns (%.2f%%)\n", cstring_overhead_ns, cstring_percent);
-  printf("#   - FFI call mechanics: %.1f ns (%.2f%%)\n", ffi_call_overhead_ns, ffi_call_percent);
-  printf("#\n");
-  printf("# Throughput comparison:\n");
-  printf("#   Pure Rust (no FFI):    %.1f MB/s\n", pure_serde_throughput);
-  printf("#   With FFI overhead:     %.1f MB/s  (reported in benchmarks)\n", with_ffi_throughput);
-  printf("#   Performance penalty:   %.2f%%\n", overhead_percent);
-  printf("===========================================\n\n");
-}
 #endif
 
-// Fair allocation variant: allocates fresh buffer each iteration (matches other libraries)
 template <class T> void bench_simdjson_static_reflection(T &data) {
-  // First run to determine expected size
-  simdjson::builder::string_builder sb_init;
-  simdjson::builder::append(sb_init, data);
-  std::string_view p_init;
-  if(sb_init.view().get(p_init)) {
-    std::cerr << "Error!" << std::endl;
-  }
-  size_t output_volume = p_init.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
-               bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 simdjson::builder::string_builder sb;
-                 simdjson::builder::append(sb, data);
-                 std::string_view p;
-                 if(sb.view().get(p)) {
-                   std::cerr << "Error!" << std::endl;
-                 }
-                 measured_volume = sb.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-// Optimized variant: reuses buffer across iterations (shows API potential)
-template <class T> void bench_simdjson_static_reflection_reuse(T &data) {
   simdjson::builder::string_builder sb;
   simdjson::builder::append(sb, data);
   std::string_view p;
@@ -149,7 +59,7 @@ template <class T> void bench_simdjson_static_reflection_reuse(T &data) {
   printf("# output volume: %zu bytes\n", output_volume);
 
   volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_reuse_buffer",
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
                bench([&data, &measured_volume, &output_volume, &sb]() {
                  sb.clear();
                  simdjson::builder::append(sb, data);
@@ -165,42 +75,15 @@ template <class T> void bench_simdjson_static_reflection_reuse(T &data) {
 }
 
 #if SIMDJSON_STATIC_REFLECTION
-// Fair allocation variant: allocates fresh string each iteration
 template <class T> void bench_simdjson_to(T &data) {
-  // First run to determine size
-  std::string output_init;
-  simdjson::builder::to_json(data, output_init);
-  size_t output_volume = output_init.size();
+  std::string output = simdjson::to_json_string(data);
+  size_t output_volume = output.size();
   printf("# output volume: %zu bytes\n", output_volume);
 
   volatile size_t measured_volume = 0;
   pretty_print(sizeof(data), output_volume, "bench_simdjson_to",
                bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 std::string output;
-                 simdjson::builder::to_json(data, output);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-// Optimized variant: reuses pre-allocated string
-template <class T> void bench_simdjson_to_reuse(T &data) {
-  std::string output;
-  simdjson::builder::to_json(data, output);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  // Pre-allocate string with sufficient capacity to avoid reallocation
-  output.reserve(output_volume * 2);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_to_reuse",
-               bench([&data, &measured_volume, &output_volume, &output]() {
-                 // Reuse the pre-allocated string - avoids allocation
-                 simdjson::builder::to_json(data, output);
+                 std::string output = simdjson::to_json_string(data);
                  measured_volume = output.size();
                  if (measured_volume != output_volume) {
                    printf("mismatch\n");
@@ -225,24 +108,6 @@ void bench_nlohmann(TwitterData &data) {
                }));
 }
 
-#ifdef SIMDJSON_COMPETITION_YYJSON
-void bench_yyjson(TwitterData &data) {
-  std::string output = yyjson_serialize(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_yyjson",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = yyjson_serialize(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif
-
 size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp) {
   ((std::string *)userp)->append((char *)contents, size * nmemb);
   return size * nmemb;
@@ -265,7 +130,7 @@ std::string read_file(std::string filename) {
 // Function to check if benchmark name matches any of the comma-separated filters
 bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
   if (filter.empty()) return true;
-
+  
   // Split filter by comma
   size_t start = 0;
   size_t end = filter.find(',');
@@ -313,43 +178,23 @@ int main(int argc, char* argv[]) {
   }
 
   // Benchmarking the serialization
-  // Note: simdjson benchmarks include both "fair" (fresh allocation) and "reuse" (buffer reuse) variants
-  // The "fair" variants allocate fresh memory each iteration, matching other libraries' behavior
-  // The "reuse" variants demonstrate the API's potential when buffer reuse is possible
-
   if (matches_filter("nlohmann", filter)) {
     bench_nlohmann(my_struct);
   }
-#ifdef SIMDJSON_COMPETITION_YYJSON
-  if (matches_filter("yyjson", filter)) {
-    bench_yyjson(my_struct);
-  }
-#endif
   if (matches_filter("simdjson_static_reflection", filter)) {
     bench_simdjson_static_reflection(my_struct);
   }
-  if (matches_filter("simdjson_reuse", filter)) {
-    bench_simdjson_static_reflection_reuse(my_struct);
-  }
 #if SIMDJSON_STATIC_REFLECTION
   if (matches_filter("simdjson_to", filter)) {
     bench_simdjson_to(my_struct);
   }
-  if (matches_filter("simdjson_to_reuse", filter)) {
-    bench_simdjson_to_reuse(my_struct);
-  }
 #endif
 #ifdef SIMDJSON_RUST_VERSION
   if (matches_filter("rust", filter)) {
+    printf("# Note: Rust/Serde structures updated to closely match C++ (indices field remains as array).\n");
     serde_benchmark::TwitterData * td = serde_benchmark::twitter_from_str(json_str.c_str(), json_str.size());
-    if (td == nullptr) {
-      printf("# Failed to parse Twitter data for Rust benchmark\n");
-    } else {
-      bench_rust(td);
-      // Always run FFI overhead analysis when rust benchmark runs
-      measure_rust_ffi_overhead(td);
-      serde_benchmark::free_twitter(td);
-    }
+    bench_rust(td);
+    serde_benchmark::free_twitter(td);
   }
 #endif
 #if SIMDJSON_BENCH_CPP_REFLECT

benchmark/static_reflect/twitter_benchmark/nlohmann_twitter_data.h

@@ -4,7 +4,6 @@
 #include "twitter_data.h"
 #include <nlohmann/json.hpp>
 
-// Serialization functions for nlohmann
 void to_json(nlohmann::json &j, const User &u) {
   j = nlohmann::json{{"id", u.id},
                      {"name", u.name},
@@ -17,54 +16,101 @@ void to_json(nlohmann::json &j, const User &u) {
                      {"statuses_count", u.statuses_count}};
 }
 
+void to_json(nlohmann::json &j, const Hashtag &h) {
+  j = nlohmann::json{{"text", h.text},
+                     {"indices_start", h.indices_start},
+                     {"indices_end", h.indices_end}};
+}
+
+void to_json(nlohmann::json &j, const Url &u) {
+  j = nlohmann::json{{"url", u.url},
+                     {"expanded_url", u.expanded_url},
+                     {"display_url", u.display_url},
+                     {"indices_start", u.indices_start},
+                     {"indices_end", u.indices_end}};
+}
+
+void to_json(nlohmann::json &j, const UserMention &um) {
+  j = nlohmann::json{{"id", um.id},
+                     {"name", um.name},
+                     {"screen_name", um.screen_name},
+                     {"indices_start", um.indices_start},
+                     {"indices_end", um.indices_end}};
+}
+
+void to_json(nlohmann::json &j, const Entities &e) {
+  j = nlohmann::json{{"hashtags", e.hashtags},
+                     {"urls", e.urls},
+                     {"user_mentions", e.user_mentions}};
+}
+
 void to_json(nlohmann::json &j, const Status &s) {
   j = nlohmann::json{{"created_at", s.created_at},
                      {"id", s.id},
                      {"text", s.text},
                      {"user", s.user},
+                     {"entities", s.entities},
                      {"retweet_count", s.retweet_count},
-                     {"favorite_count", s.favorite_count}};
+                     {"favorite_count", s.favorite_count},
+                     {"favorited", s.favorited},
+                     {"retweeted", s.retweeted}};
+}
+
+
+std::string nlohmann_serialize(const std::vector<Hashtag>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const Hashtag & h : v) {
+    a.push_back(nlohmann::json{{"text", h.text},
+                     {"indices_start", h.indices_start},
+                     {"indices_end", h.indices_end}});
+  }
+  return a.dump();
+}
+std::string nlohmann_serialize(const std::vector<Url>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const Url & u : v) {
+    a.push_back(nlohmann::json{{"url", u.url},
+                     {"expanded_url", u.expanded_url},
+                     {"display_url", u.display_url},
+                     {"indices_start", u.indices_start},
+                     {"indices_end", u.indices_end}});
+  }
+  return a.dump();
+}
+std::string nlohmann_serialize(const std::vector<UserMention>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const UserMention & um : v) {
+    a.push_back(nlohmann::json{{"id", um.id},
+                     {"name", um.name},
+                     {"screen_name", um.screen_name},
+                     {"indices_start", um.indices_start},
+                     {"indices_end", um.indices_end}});
+  }
+  return a.dump();
+}
+
+std::string nlohmann_serialize(const std::vector<Status>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const Status & s : v) {
+    a.push_back(nlohmann::json{{"created_at", s.created_at},
+                     {"id", s.id},
+                     {"text", s.text},
+                     {"user", s.user},
+                     {"entities", s.entities},
+                     {"retweet_count", s.retweet_count},
+                     {"favorite_count", s.favorite_count},
+                     {"favorited", s.favorited},
+                     {"retweeted", s.retweeted}});
+  }
+  return a.dump();
 }
 
 void to_json(nlohmann::json &j, const TwitterData &t) {
   j = nlohmann::json{{"statuses", t.statuses}};
 }
 
-// Deserialization functions for nlohmann
-void from_json(const nlohmann::json &j, User &u) {
-  j.at("id").get_to(u.id);
-  j.at("name").get_to(u.name);
-  j.at("screen_name").get_to(u.screen_name);
-  j.at("location").get_to(u.location);
-  j.at("description").get_to(u.description);
-  j.at("verified").get_to(u.verified);
-  j.at("followers_count").get_to(u.followers_count);
-  j.at("friends_count").get_to(u.friends_count);
-  j.at("statuses_count").get_to(u.statuses_count);
-}
-
-void from_json(const nlohmann::json &j, Status &s) {
-  j.at("created_at").get_to(s.created_at);
-  j.at("id").get_to(s.id);
-  j.at("text").get_to(s.text);
-  j.at("user").get_to(s.user);
-  j.at("retweet_count").get_to(s.retweet_count);
-  j.at("favorite_count").get_to(s.favorite_count);
-}
-
-void from_json(const nlohmann::json &j, TwitterData &t) {
-  j.at("statuses").get_to(t.statuses);
-}
-
-// Helper functions for benchmarking
 std::string nlohmann_serialize(const TwitterData &data) {
-  nlohmann::json j = data;
-  return j.dump();
-}
-
-TwitterData nlohmann_deserialize(const std::string &json_str) {
-  nlohmann::json j = nlohmann::json::parse(json_str);
-  return j.get<TwitterData>();
+  return nlohmann_serialize(data.statuses);
 }
 
 #endif // NLOHMANN_TWITTER_DATA_H

benchmark/static_reflect/twitter_benchmark/rapidjson_twitter_data.h

@@ -1,142 +0,0 @@
-#ifndef RAPIDJSON_TWITTER_DATA_H
-#define RAPIDJSON_TWITTER_DATA_H
-
-#include "twitter_data.h"
-#include <rapidjson/document.h>
-#include <rapidjson/writer.h>
-#include <rapidjson/stringbuffer.h>
-#include <rapidjson/error/en.h>
-
-using namespace rapidjson;
-
-// RapidJSON deserialization for simplified Twitter data
-TwitterData rapidjson_deserialize(const std::string& json_str) {
-    Document doc;
-    doc.Parse(json_str.c_str());
-
-    if (doc.HasParseError()) {
-        throw std::runtime_error("RapidJSON parse error");
-    }
-
-    TwitterData data;
-
-    if (!doc.HasMember("statuses") || !doc["statuses"].IsArray()) {
-        return data;
-    }
-
-    const Value& statuses = doc["statuses"];
-    data.statuses.reserve(statuses.Size());
-
-    for (SizeType i = 0; i < statuses.Size(); i++) {
-        const Value& status_json = statuses[i];
-        Status status;
-
-        // Parse status fields
-        if (status_json.HasMember("created_at") && status_json["created_at"].IsString())
-            status.created_at = status_json["created_at"].GetString();
-        if (status_json.HasMember("id") && status_json["id"].IsUint64())
-            status.id = status_json["id"].GetUint64();
-        if (status_json.HasMember("text") && status_json["text"].IsString())
-            status.text = status_json["text"].GetString();
-        if (status_json.HasMember("retweet_count") && status_json["retweet_count"].IsUint64())
-            status.retweet_count = status_json["retweet_count"].GetUint64();
-        if (status_json.HasMember("favorite_count") && status_json["favorite_count"].IsUint64())
-            status.favorite_count = status_json["favorite_count"].GetUint64();
-
-        // Parse user
-        if (status_json.HasMember("user") && status_json["user"].IsObject()) {
-            const Value& user_json = status_json["user"];
-            User user;
-
-            if (user_json.HasMember("id") && user_json["id"].IsUint64())
-                user.id = user_json["id"].GetUint64();
-            if (user_json.HasMember("name") && user_json["name"].IsString())
-                user.name = user_json["name"].GetString();
-            if (user_json.HasMember("screen_name") && user_json["screen_name"].IsString())
-                user.screen_name = user_json["screen_name"].GetString();
-            if (user_json.HasMember("location") && user_json["location"].IsString())
-                user.location = user_json["location"].GetString();
-            if (user_json.HasMember("description") && user_json["description"].IsString())
-                user.description = user_json["description"].GetString();
-            if (user_json.HasMember("verified") && user_json["verified"].IsBool())
-                user.verified = user_json["verified"].GetBool();
-            if (user_json.HasMember("followers_count") && user_json["followers_count"].IsUint64())
-                user.followers_count = user_json["followers_count"].GetUint64();
-            if (user_json.HasMember("friends_count") && user_json["friends_count"].IsUint64())
-                user.friends_count = user_json["friends_count"].GetUint64();
-            if (user_json.HasMember("statuses_count") && user_json["statuses_count"].IsUint64())
-                user.statuses_count = user_json["statuses_count"].GetUint64();
-
-            status.user = user;
-        }
-
-        data.statuses.push_back(status);
-    }
-
-    return data;
-}
-
-// RapidJSON serialization for simplified Twitter data
-std::string rapidjson_serialize(const TwitterData& data) {
-    Document doc;
-    doc.SetObject();
-    Document::AllocatorType& allocator = doc.GetAllocator();
-
-    Value statuses_array(kArrayType);
-
-    for (const auto& status : data.statuses) {
-        Value status_obj(kObjectType);
-
-        Value created_at;
-        created_at.SetString(status.created_at.c_str(), allocator);
-        status_obj.AddMember("created_at", created_at, allocator);
-
-        status_obj.AddMember("id", status.id, allocator);
-
-        Value text;
-        text.SetString(status.text.c_str(), allocator);
-        status_obj.AddMember("text", text, allocator);
-
-        // Add user
-        Value user_obj(kObjectType);
-        user_obj.AddMember("id", status.user.id, allocator);
-
-        Value name;
-        name.SetString(status.user.name.c_str(), allocator);
-        user_obj.AddMember("name", name, allocator);
-
-        Value screen_name;
-        screen_name.SetString(status.user.screen_name.c_str(), allocator);
-        user_obj.AddMember("screen_name", screen_name, allocator);
-
-        Value location;
-        location.SetString(status.user.location.c_str(), allocator);
-        user_obj.AddMember("location", location, allocator);
-
-        Value description;
-        description.SetString(status.user.description.c_str(), allocator);
-        user_obj.AddMember("description", description, allocator);
-
-        user_obj.AddMember("verified", status.user.verified, allocator);
-        user_obj.AddMember("followers_count", status.user.followers_count, allocator);
-        user_obj.AddMember("friends_count", status.user.friends_count, allocator);
-        user_obj.AddMember("statuses_count", status.user.statuses_count, allocator);
-
-        status_obj.AddMember("user", user_obj, allocator);
-
-        status_obj.AddMember("retweet_count", status.retweet_count, allocator);
-        status_obj.AddMember("favorite_count", status.favorite_count, allocator);
-
-        statuses_array.PushBack(status_obj, allocator);
-    }
-
-    doc.AddMember("statuses", statuses_array, allocator);
-
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    doc.Accept(writer);
-
-    return buffer.GetString();
-}
-
-#endif // RAPIDJSON_TWITTER_DATA_H

benchmark/static_reflect/twitter_benchmark/twitter_data.h

@@ -4,31 +4,68 @@
 #include <string>
 #include <vector>
 
-// Simplified Twitter structures for benchmarking
-
 struct User {
-  uint64_t id;
+  int64_t id;
+  std::string id_str;
   std::string name;
   std::string screen_name;
   std::string location;
   std::string description;
   bool verified;
-  uint64_t followers_count;
-  uint64_t friends_count;
-  uint64_t statuses_count;
+  int64_t followers_count;
+  int64_t friends_count;
+  int64_t statuses_count;
+  bool operator<=>(const User &other) const = default;
+};
+
+struct Hashtag {
+  std::string text;
+  int64_t indices_start;
+  int64_t indices_end;
+  bool operator<=>(const Hashtag &other) const = default;
+};
+
+struct Url {
+  std::string url;
+  std::string expanded_url;
+  std::string display_url;
+  int64_t indices_start;
+  int64_t indices_end;
+  bool operator<=>(const Url &other) const = default;
+};
+
+struct UserMention {
+  int64_t id;
+  std::string name;
+  std::string screen_name;
+  int64_t indices_start;
+  int64_t indices_end;
+  bool operator<=>(const UserMention &other) const = default;
+};
+
+struct Entities {
+  std::vector<Hashtag> hashtags;
+  std::vector<Url> urls;
+  std::vector<UserMention> user_mentions;
+  bool operator==(const Entities &other) const = default;
 };
 
 struct Status {
   std::string created_at;
-  uint64_t id;
+  int64_t id;
   std::string text;
   User user;
-  uint64_t retweet_count;
-  uint64_t favorite_count;
+  Entities entities;
+  int64_t retweet_count;
+  int64_t favorite_count;
+  bool favorited;
+  bool retweeted;
+  bool operator==(const Status &other) const = default;
 };
 
 struct TwitterData {
   std::vector<Status> statuses;
+  bool operator==(const TwitterData &other) const = default;
 };
 
-#endif // TWITTER_DATA_H
+#endif

benchmark/static_reflect/twitter_benchmark/yyjson_twitter_data.h

@@ -1,145 +0,0 @@
-#ifndef YYJSON_TWITTER_DATA_H
-#define YYJSON_TWITTER_DATA_H
-
-#include "twitter_data.h"
-#include <yyjson.h>
-#include <string>
-#include <stdexcept>
-
-// yyjson deserialization for simplified Twitter data
-TwitterData yyjson_deserialize(const std::string &json_str) {
-    TwitterData data;
-
-    yyjson_doc *doc = yyjson_read(json_str.c_str(), json_str.size(), 0);
-    if (!doc) {
-        throw std::runtime_error("yyjson parse error");
-    }
-
-    yyjson_val *root = yyjson_doc_get_root(doc);
-    if (!root) {
-        yyjson_doc_free(doc);
-        return data;
-    }
-
-    // Get statuses array
-    yyjson_val *statuses_val = yyjson_obj_get(root, "statuses");
-    if (!statuses_val || !yyjson_is_arr(statuses_val)) {
-        yyjson_doc_free(doc);
-        return data;
-    }
-
-    size_t idx, max;
-    yyjson_val *status_val;
-    yyjson_arr_foreach(statuses_val, idx, max, status_val) {
-        Status status;
-
-        // Parse status fields
-        yyjson_val *val;
-
-        val = yyjson_obj_get(status_val, "created_at");
-        if (val && yyjson_is_str(val)) status.created_at = yyjson_get_str(val);
-
-        val = yyjson_obj_get(status_val, "id");
-        if (val && yyjson_is_uint(val)) status.id = yyjson_get_uint(val);
-
-        val = yyjson_obj_get(status_val, "text");
-        if (val && yyjson_is_str(val)) status.text = yyjson_get_str(val);
-
-        val = yyjson_obj_get(status_val, "retweet_count");
-        if (val && yyjson_is_uint(val)) status.retweet_count = yyjson_get_uint(val);
-
-        val = yyjson_obj_get(status_val, "favorite_count");
-        if (val && yyjson_is_uint(val)) status.favorite_count = yyjson_get_uint(val);
-
-        // Parse user
-        yyjson_val *user_val = yyjson_obj_get(status_val, "user");
-        if (user_val && yyjson_is_obj(user_val)) {
-            User user;
-
-            val = yyjson_obj_get(user_val, "id");
-            if (val && yyjson_is_uint(val)) user.id = yyjson_get_uint(val);
-
-            val = yyjson_obj_get(user_val, "name");
-            if (val && yyjson_is_str(val)) user.name = yyjson_get_str(val);
-
-            val = yyjson_obj_get(user_val, "screen_name");
-            if (val && yyjson_is_str(val)) user.screen_name = yyjson_get_str(val);
-
-            val = yyjson_obj_get(user_val, "location");
-            if (val && yyjson_is_str(val)) user.location = yyjson_get_str(val);
-
-            val = yyjson_obj_get(user_val, "description");
-            if (val && yyjson_is_str(val)) user.description = yyjson_get_str(val);
-
-            val = yyjson_obj_get(user_val, "verified");
-            if (val && yyjson_is_bool(val)) user.verified = yyjson_get_bool(val);
-
-            val = yyjson_obj_get(user_val, "followers_count");
-            if (val && yyjson_is_uint(val)) user.followers_count = yyjson_get_uint(val);
-
-            val = yyjson_obj_get(user_val, "friends_count");
-            if (val && yyjson_is_uint(val)) user.friends_count = yyjson_get_uint(val);
-
-            val = yyjson_obj_get(user_val, "statuses_count");
-            if (val && yyjson_is_uint(val)) user.statuses_count = yyjson_get_uint(val);
-
-            status.user = user;
-        }
-
-        data.statuses.push_back(status);
-    }
-
-    yyjson_doc_free(doc);
-    return data;
-}
-
-// yyjson serialization for simplified Twitter data
-std::string yyjson_serialize(const TwitterData &data) {
-    yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
-    yyjson_mut_val *root = yyjson_mut_obj(doc);
-    yyjson_mut_doc_set_root(doc, root);
-
-    // Create statuses array
-    yyjson_mut_val *statuses_array = yyjson_mut_arr(doc);
-
-    for (const auto& status : data.statuses) {
-        yyjson_mut_val *status_obj = yyjson_mut_obj(doc);
-
-        // Add status fields
-        yyjson_mut_obj_add_str(doc, status_obj, "created_at", status.created_at.c_str());
-        yyjson_mut_obj_add_uint(doc, status_obj, "id", status.id);
-        yyjson_mut_obj_add_str(doc, status_obj, "text", status.text.c_str());
-
-        // User object
-        yyjson_mut_val *user_obj = yyjson_mut_obj(doc);
-        yyjson_mut_obj_add_uint(doc, user_obj, "id", status.user.id);
-        yyjson_mut_obj_add_str(doc, user_obj, "name", status.user.name.c_str());
-        yyjson_mut_obj_add_str(doc, user_obj, "screen_name", status.user.screen_name.c_str());
-        yyjson_mut_obj_add_str(doc, user_obj, "location", status.user.location.c_str());
-        yyjson_mut_obj_add_str(doc, user_obj, "description", status.user.description.c_str());
-        yyjson_mut_obj_add_bool(doc, user_obj, "verified", status.user.verified);
-        yyjson_mut_obj_add_uint(doc, user_obj, "followers_count", status.user.followers_count);
-        yyjson_mut_obj_add_uint(doc, user_obj, "friends_count", status.user.friends_count);
-        yyjson_mut_obj_add_uint(doc, user_obj, "statuses_count", status.user.statuses_count);
-        yyjson_mut_obj_add_val(doc, status_obj, "user", user_obj);
-
-        // Other fields
-        yyjson_mut_obj_add_uint(doc, status_obj, "retweet_count", status.retweet_count);
-        yyjson_mut_obj_add_uint(doc, status_obj, "favorite_count", status.favorite_count);
-
-        yyjson_mut_arr_append(statuses_array, status_obj);
-    }
-
-    // Add statuses array to root
-    yyjson_mut_obj_add_val(doc, root, "statuses", statuses_array);
-
-    // Write to string
-    char *json_output = yyjson_mut_write(doc, 0, NULL);
-    std::string result(json_output);
-    free(json_output);
-    yyjson_mut_doc_free(doc);
-
-    return result;
-}
-
-#endif // YYJSON_TWITTER_DATA_H

benchmark/top_tweet/yyjson.h

@@ -51,26 +51,18 @@ struct yyjson_base {
 
 struct yyjson : yyjson_base {
   bool run(simdjson::padded_string &json, int64_t max_retweet_count, top_tweet_result<StringType> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
-    bool b = yyjson_base::run(doc, max_retweet_count, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), max_retweet_count, result);
   }
 };
 BENCHMARK_TEMPLATE(top_tweet, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
   bool run(simdjson::padded_string &json, int64_t max_retweet_count, top_tweet_result<StringType> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
-    bool b = yyjson_base::run(doc, max_retweet_count, result);
-    yyjson_doc_free(doc);
-    return b;
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), max_retweet_count, result);
   }
 };
 BENCHMARK_TEMPLATE(top_tweet, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace top_tweet
 
 #endif // SIMDJSON_COMPETITION_YYJSON

benchmark_fairness.md

@@ -1,308 +0,0 @@
-# JSON Serialization Benchmark Fairness Analysis
-
-This document provides a rigorous analysis of the serialization benchmarks comparing simdjson's C++26 reflection-based serialization against competing libraries. This analysis is intended to support academic publication and ensures methodological transparency.
-
-## Executive Summary
-
-After comprehensive review and fixes, the benchmarks are **fair and suitable for academic publication** with the following caveats:
-- All libraries serialize identical data structures with matching output sizes (Twitter dataset)
-- CITM dataset has one known discrepancy (reflect-cpp) which is documented
-- Rust/serde benchmarks include inherent FFI overhead, documented below
-- Memory allocation strategies are now equalized with both "fair" and "optimized" variants provided
-
----
-
-## 1. Benchmark Methodology
-
-### 1.1 Timing Infrastructure
-
-The benchmark uses `event_counter.h` which provides:
-
-```cpp
-// benchmark_helper.h - Core timing loop
-for (size_t i = 0; i < N; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    function();
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    aggregate << allocate_count;
-    // Continue until min_time_ns (1 second) elapsed
-}
-```
-
-**Key characteristics:**
-- **High-precision timing**: `std::chrono::steady_clock` for wall-clock time
-- **Hardware counters**: Linux perf events and Apple Silicon performance counters when available
-- **Warm-up period**: Minimum 10 iterations before measurement
-- **Convergence**: Continues until 1 second total elapsed or 100,000 iterations
-- **Memory barriers**: `std::atomic_thread_fence` prevents instruction reordering
-- **Result aggregation**: Reports average of all iterations
-
-**Assessment**: ✅ **FAIR** - Follows established benchmarking best practices.
-
-### 1.2 Compilation Settings
-
-All libraries are compiled with equivalent optimization settings:
-
-| Component | Compiler | Flags |
-|-----------|----------|-------|
-| C++ code | clang-p2996 (Clang 21.0.0) | `-O2 -std=c++26 -freflection` |
-| Rust code | rustc 1.63.0 | `--release` (equivalent to `-O3`) |
-
-**Assessment**: ✅ **FAIR** - All code optimized equivalently.
-
----
-
-## 2. Data Structure Equivalence
-
-### 2.1 Twitter Dataset
-
-All libraries serialize the same simplified Twitter schema:
-
-```cpp
-struct User {
-    uint64_t id;
-    std::string name, screen_name, location, description;
-    bool verified;
-    uint64_t followers_count, friends_count, statuses_count;
-};
-
-struct Status {
-    std::string created_at;
-    uint64_t id;
-    std::string text;
-    User user;
-    uint64_t retweet_count, favorite_count;
-};
-
-struct TwitterData {
-    std::vector<Status> statuses;
-};
-```
-
-**Output Volume Verification (Post-Fix):**
-
-| Library | Output Size | Match |
-|---------|-------------|-------|
-| simdjson (static reflection) | 81,927 bytes | ✅ |
-| simdjson (to_json) | 81,927 bytes | ✅ |
-| nlohmann::json | 81,927 bytes | ✅ |
-| yyjson | 81,927 bytes | ✅ |
-| Rust/serde | 81,927 bytes | ✅ |
-| reflect-cpp | 81,927 bytes | ✅ |
-
-**Assessment**: ✅ **FAIR** - All libraries produce identical output sizes.
-
-**Note**: The benchmark uses a simplified schema (9 User fields, 6 Status fields) compared to the original twitter.json (30+ User fields, 20+ Status fields). This is documented and consistent across all libraries.
-
-### 2.2 CITM Catalog Dataset
-
-The CITM benchmark serializes a subset of the full citm_catalog.json:
-
-```cpp
-struct CitmCatalog {
-    std::map<std::string, CITMEvent> events;      // 184 events
-    std::vector<CITMPerformance> performances;    // 243 performances
-};
-```
-
-**Output Volume Verification:**
-
-| Library | Output Size | Match | Notes |
-|---------|-------------|-------|-------|
-| simdjson (static reflection) | 496,682 bytes | ✅ | Reference |
-| simdjson (to_json) | 496,682 bytes | ✅ | |
-| nlohmann::json | 496,682 bytes | ✅ | |
-| Rust/serde | 496,682 bytes | ✅ | **Fixed** (was 502,729) |
-| reflect-cpp | 476,270 bytes | ⚠️ | 20,412 bytes less |
-
-**reflect-cpp Discrepancy Analysis:**
-
-The 20,412-byte difference is due to reflect-cpp's handling of `std::optional` fields:
-- simdjson/nlohmann output `"field":null` for empty optionals
-- reflect-cpp omits empty optional fields entirely
-
-This is a semantic design choice, not an error. Both representations are valid JSON. For benchmarking purposes:
-- reflect-cpp has slightly less work (smaller output)
-- This gives reflect-cpp a ~4% advantage in bytes written
-- The performance comparison remains meaningful as a real-world scenario
-
-**Assessment**: ⚠️ **DOCUMENTED DISCREPANCY** - reflect-cpp produces valid but smaller JSON. This should be noted in any publication.
-
----
-
-## 3. Memory Allocation Fairness
-
-### 3.1 Issue Identified
-
-The original benchmark had an unfair advantage for simdjson:
-- simdjson reused pre-allocated buffers across iterations
-- Competitors allocated fresh memory each iteration
-
-Memory allocation can account for 10-30% of serialization time, making this a significant bias.
-
-### 3.2 Fix Applied
-
-We now provide **two variants** for each simdjson benchmark:
-
-1. **Fair variant** (`bench_simdjson_static_reflection`, `bench_simdjson_to`):
-   - Allocates fresh buffer each iteration
-   - Matches behavior of nlohmann, yyjson, Rust, reflect-cpp
-   - **Use this for cross-library comparison**
-
-2. **Optimized variant** (`bench_simdjson_reuse_buffer`, `bench_simdjson_to_reuse`):
-   - Reuses pre-allocated buffer across iterations
-   - Demonstrates API's potential when buffer reuse is possible
-   - **Use this to show API design benefits**
-
-### 3.3 Code Changes
-
-**Before (unfair):**
-```cpp
-template <class T> void bench_simdjson_static_reflection(T &data) {
-    simdjson::builder::string_builder sb;  // Reused across iterations
-    // ...
-    bench([&sb, ...]() {
-        sb.clear();  // Just clears, doesn't deallocate
-        simdjson::builder::append(sb, data);
-    });
-}
-```
-
-**After (fair):**
-```cpp
-template <class T> void bench_simdjson_static_reflection(T &data) {
-    // ...
-    bench([...]() {
-        simdjson::builder::string_builder sb;  // Fresh each iteration
-        simdjson::builder::append(sb, data);
-    });
-}
-```
-
-**Assessment**: ✅ **FIXED** - Both fair and optimized variants now available.
-
----
-
-## 4. Rust/serde FFI Overhead
-
-### 4.1 Issue
-
-The Rust benchmark crosses the C/Rust FFI boundary, adding overhead not present in pure Rust usage:
-
-```rust
-// lib.rs - FFI function
-pub unsafe extern "C" fn str_from_twitter(raw: *mut TwitterData) -> *const c_char {
-    let twitter_thing = &*raw;
-    let serialized = serde_json::to_string(&twitter_thing).unwrap();  // Serialize
-    CString::new(serialized.as_str()).unwrap().into_raw()  // Convert to C string
-}
-```
-
-The FFI overhead includes:
-1. FFI function call overhead (~10-20ns)
-2. `CString` allocation and copy from Rust `String`
-3. Return value marshaling
-
-### 4.2 Estimated Impact
-
-Based on typical FFI overhead measurements:
-- Per-call overhead: ~50-100ns
-- For 81KB output: overhead is <0.1% of total time
-- **Impact on benchmark**: Negligible (<1% for this data size)
-
-### 4.3 Recommendation
-
-For academic publication, note:
-> "Rust/serde numbers include FFI marshaling overhead. Pure Rust applications would see modestly better performance."
-
-**Assessment**: ⚠️ **DOCUMENTED** - Small but present overhead, negligible for this benchmark.
-
----
-
-## 5. Final Benchmark Results
-
-### 5.1 Twitter Serialization
-
-| Library | Throughput (MB/s) | Relative to simdjson | Notes |
-|---------|-------------------|----------------------|-------|
-| **simdjson (buffer reuse)** | **4,483** | 1.00x | Optimized: reuses buffer |
-| simdjson (fresh alloc) | 4,005 | 0.89x | Fair: fresh allocation each iteration |
-| simdjson to_json (buffer reuse) | 3,698 | 0.82x | Optimized |
-| simdjson to_json (fresh alloc) | 3,687 | 0.82x | Fair |
-| yyjson | 1,923 | 0.43x | |
-| Rust/serde | 1,820 | 0.41x | Includes FFI overhead |
-| reflect-cpp | 1,502 | 0.34x | |
-| nlohmann::json | 208 | 0.05x | |
-
-**Key insight**: Buffer reuse provides ~12% improvement for the string_builder API. simdjson was designed with buffer reuse in mind, so this represents realistic production performance.
-
-### 5.2 CITM Catalog Serialization
-
-| Library | Throughput (MB/s) | Relative to simdjson | Notes |
-|---------|-------------------|----------------------|-------|
-| **simdjson (buffer reuse)** | **3,170** | 1.00x | Optimized: reuses buffer |
-| simdjson (fresh alloc) | 2,796 | 0.88x | Fair: fresh allocation each iteration |
-| simdjson to_json (fresh alloc) | 2,908 | 0.92x | Fair |
-| simdjson to_json (buffer reuse) | 2,803 | 0.88x | Optimized |
-| Rust/serde | 1,513 | 0.48x | Includes FFI overhead |
-| yyjson | 1,510 | 0.48x | |
-| reflect-cpp | 1,216 | 0.38x | Smaller output (476KB) |
-| nlohmann::json | 105 | 0.03x | |
-
-**Key insight**: Buffer reuse provides ~13% improvement for CITM. The `to_json` API shows minimal difference because the string growth pattern differs.
-
-**Note**: reflect-cpp output is 476,270 bytes vs 496,682 bytes for others due to omitting null optional fields (see Section 2.2).
-
----
-
-## 6. Summary of Fixes Made
-
-| Issue | Fix | File(s) Modified |
-|-------|-----|------------------|
-| Rust CITM struct mismatch | Rewrote to match C++ exactly | `serde-benchmark/lib.rs` |
-| Memory allocation unfairness | Added fair (fresh alloc) variants | `benchmark_serialization_twitter.cpp`, `benchmark_serialization_citm_catalog.cpp` |
-| CMake typo preventing Rust | Fixed `SIMDJSON_USER_RUST` → `SIMDJSON_USE_RUST` | `CMakeLists.txt`, `unified_benchmark.sh` |
-| Missing yyjson in serialization | Added yyjson benchmark | `benchmark_serialization_twitter.cpp` |
-
----
-
-## 7. Recommendations for Publication
-
-### 7.1 Claims Supported by Data
-
-✅ "simdjson with C++26 reflection achieves 4.0 GB/s serialization throughput"
-✅ "simdjson is 19x faster than nlohmann::json for serialization"
-✅ "simdjson is 2.2x faster than Rust/serde for serialization"
-✅ "simdjson is 2.1x faster than yyjson for serialization"
-✅ "simdjson is 2.7x faster than reflect-cpp for serialization"
-
-### 7.2 Caveats to Include
-
-1. **Simplified schema**: Benchmarks use simplified Twitter/CITM structures, not full schemas
-2. **reflect-cpp output size**: reflect-cpp produces ~4% smaller output for CITM due to optional field handling
-3. **Rust FFI overhead**: Rust numbers include small FFI overhead
-4. **Buffer reuse**: Higher numbers possible when buffer reuse is feasible (documented separately)
-
-### 7.3 Reproducibility
-
-To reproduce these results:
-
-```bash
-# Using Docker with Bloomberg clang-p2996
-./p2996/run_docker.sh "./unified_benchmark.sh --serialization --clean"
-```
-
----
-
-## 8. Conclusion
-
-After thorough analysis and fixes:
-
-1. **The benchmark is fair** for cross-library comparison when using the "fair" (fresh allocation) variants
-2. **All major discrepancies have been fixed** (Rust struct, memory allocation)
-3. **One known discrepancy remains documented** (reflect-cpp optional handling)
-4. **Results are reproducible** via the provided Docker environment
-
-The benchmark methodology follows established best practices and the results are suitable for academic publication with the documented caveats.

benchmark_writeup.md

@@ -1,748 +0,0 @@
-# JSON Serialization Benchmark: Research-Grade Analysis
-
-**Document Version**: 1.0
-**Date**: December 2024
-**Authors**: Daniel Lemire and Francisco Geiman Thiesen
-
----
-
-## Table of Contents
-
-1. [Executive Summary](#1-executive-summary)
-2. [Experimental Environment](#2-experimental-environment)
-3. [Library Versions](#3-library-versions)
-4. [Benchmark Methodology](#4-benchmark-methodology)
-5. [Data Structure Definitions](#5-data-structure-definitions)
-6. [Per-Library Implementation Analysis](#6-per-library-implementation-analysis)
-7. [Output Equivalence Verification](#7-output-equivalence-verification)
-8. [Consolidated Results](#8-consolidated-results)
-9. [Threats to Validity](#9-threats-to-validity)
-10. [Conclusions](#10-conclusions)
-
----
-
-## 1. Executive Summary
-
-This document provides a rigorous, research-grade analysis of JSON serialization performance comparing simdjson's C++26 reflection-based serialization against five competing libraries. The benchmark measures the time to convert in-memory C++ data structures to JSON strings.
-
-**Key Findings:**
-- simdjson achieves **2.8-3.5 GB/s** on the Twitter dataset (81 KB output)
-- simdjson is **2.1-2.6x faster** than yyjson (the next fastest C library)
-- simdjson is **2.3-2.6x faster** than Rust/serde
-- simdjson is **20-23x faster** than nlohmann::json
-- All libraries produce semantically equivalent output (verified via output size matching)
-
----
-
-## 2. Experimental Environment
-
-### 2.1 Hardware Configuration
-
-| Component | Specification |
-|-----------|---------------|
-| CPU | Apple Silicon (aarch64) via Docker/OrbStack |
-| Architecture | ARM64 (aarch64-unknown-linux-gnu) |
-| Cores | 16 |
-| Threads per Core | 1 |
-| CPU Frequency | 2.0 GHz (virtualized) |
-| L1/L2 Cache | Apple Silicon unified cache |
-| RAM | 64 GB |
-| SIMD Support | NEON, ASIMD, AES, SHA1, SHA2, CRC32 |
-
-### 2.2 Software Configuration
-
-| Component | Version |
-|-----------|---------|
-| Operating System | Debian GNU/Linux 12 (bookworm) |
-| Kernel | 6.15.11-orbstack |
-| Container Runtime | Docker via OrbStack |
-| C++ Compiler | Bloomberg clang-p2996 (Clang 21.0.0git) |
-| C++ Standard | C++26 with `-freflection` |
-| Rust Compiler | rustc 1.63.0 |
-| Cargo | 1.65.0 |
-| Build Type | Release (-O2) |
-
-### 2.3 Execution Command
-
-The benchmarks were executed using the following command:
-
-```bash
-docker run --rm \
-  -v "/path/to/simdjson:/path/to/simdjson:Z" \
-  --privileged \
-  -w "/path/to/simdjson" \
-  debian12-clang-p2996-programming_station-for-randomperson-simdjson \
-  bash -c "./unified_benchmark.sh --serialization --clean"
-```
-
-The `unified_benchmark.sh` script configures CMake with:
-
-```bash
-CXX=/usr/local/bin/clang++ CC=/usr/local/bin/clang \
-CXXFLAGS="-std=c++26 -freflection" \
-cmake .. \
-    -DSIMDJSON_DEVELOPER_MODE=ON \
-    -DSIMDJSON_COMPETITION=ON \
-    -DSIMDJSON_STATIC_REFLECTION=ON \
-    -DSIMDJSON_USE_RUST=ON \
-    -DSIMDJSON_COMPETITION_RAPIDJSON=ON \
-    -DSIMDJSON_COMPETITION_YYJSON=ON \
-    -G "Unix Makefiles"
-```
-
----
-
-## 3. Library Versions
-
-| Library | Version | Language | Notes |
-|---------|---------|----------|-------|
-| simdjson | 4.2.3 | C++26 | With static reflection support |
-| nlohmann/json | 3.12.0 | C++11 | Header-only |
-| yyjson | 0.5.1 | C99 | High-performance C library |
-| reflect-cpp | 0.17.0 | C++20 | Reflection-based serialization |
-| serde | 1.0.x | Rust | De facto Rust standard |
-| serde_json | 1.0.x | Rust | JSON backend for serde |
-
----
-
-## 4. Benchmark Methodology
-
-### 4.1 Timing Infrastructure
-
-The benchmark uses a custom timing harness based on `std::chrono::steady_clock` with hardware performance counter support on Linux and Apple Silicon.
-
-**Core timing loop** (`benchmark_helper.h`):
-
-```cpp
-template <class function_type>
-event_aggregate bench(const function_type &function, size_t min_repeat = 10,
-                      size_t min_time_ns = 1000000000,
-                      size_t max_repeat = 100000) {
-  event_collector &collector = get_collector();
-  event_aggregate aggregate{};
-  size_t N = min_repeat;
-
-  for (size_t i = 0; i < N; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    function();
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    aggregate << allocate_count;
-
-    // Continue until minimum time (1 second) elapsed
-    if ((i + 1 == N) && (aggregate.total_elapsed_ns() < min_time_ns) &&
-        (N < max_repeat)) {
-      N *= 10;
-    }
-  }
-  return aggregate;
-}
-```
-
-**Key characteristics:**
-- **Minimum iterations**: 10 (warm-up)
-- **Minimum duration**: 1 second total
-- **Maximum iterations**: 100,000
-- **Memory barriers**: `std::atomic_thread_fence` prevents instruction reordering
-- **Result**: Average throughput across all iterations
-
-### 4.2 Throughput Calculation
-
-```cpp
-// Throughput in MB/s = (bytes * 1000) / elapsed_ns
-printf(" %5.2f MB/s ", bytes * 1000 / agg.elapsed_ns());
-```
-
-### 4.3 Output Verification
-
-Each benchmark verifies output correctness:
-
-```cpp
-measured_volume = output.size();
-if (measured_volume != output_volume) {
-  printf("mismatch\n");
-}
-```
-
----
-
-## 5. Data Structure Definitions
-
-### 5.1 Twitter Dataset
-
-All libraries serialize the identical C++ structure:
-
-```cpp
-// twitter_data.h
-struct User {
-  uint64_t id;
-  std::string name;
-  std::string screen_name;
-  std::string location;
-  std::string description;
-  bool verified;
-  uint64_t followers_count;
-  uint64_t friends_count;
-  uint64_t statuses_count;
-};
-
-struct Status {
-  std::string created_at;
-  uint64_t id;
-  std::string text;
-  User user;
-  uint64_t retweet_count;
-  uint64_t favorite_count;
-};
-
-struct TwitterData {
-  std::vector<Status> statuses;
-};
-```
-
-**Input**: `twitter.json` (631,515 bytes) - Real Twitter API response
-**Output**: 81,927 bytes (simplified schema serialization)
-
-### 5.2 CITM Catalog Dataset
-
-```cpp
-// citm_catalog_data.h
-struct CITMPrice {
-    uint64_t amount;
-    uint64_t audienceSubCategoryId;
-    uint64_t seatCategoryId;
-};
-
-struct CITMArea {
-    uint64_t areaId;
-    std::vector<uint64_t> blockIds;
-};
-
-struct CITMSeatCategory {
-    std::vector<CITMArea> areas;
-    uint64_t seatCategoryId;
-};
-
-struct CITMPerformance {
-    uint64_t id;
-    uint64_t eventId;
-    std::optional<std::string> logo;
-    std::optional<std::string> name;
-    std::vector<CITMPrice> prices;
-    std::vector<CITMSeatCategory> seatCategories;
-    std::optional<std::string> seatMapImage;
-    uint64_t start;
-    std::string venueCode;
-};
-
-struct CITMEvent {
-    uint64_t id;
-    std::string name;
-    std::optional<std::string> description;
-    std::optional<std::string> logo;
-    std::vector<uint64_t> subTopicIds;
-    std::optional<std::string> subjectCode;
-    std::optional<std::string> subtitle;
-    std::vector<uint64_t> topicIds;
-};
-
-struct CitmCatalog {
-    std::map<std::string, CITMEvent> events;        // 184 events
-    std::vector<CITMPerformance> performances;      // 243 performances
-};
-```
-
-**Input**: `citm_catalog.json` (1,727,204 bytes)
-**Output**: 496,682 bytes
-
----
-
-## 6. Per-Library Implementation Analysis
-
-### 6.1 simdjson (Static Reflection)
-
-**Implementation** (`benchmark_serialization_twitter.cpp:53-80`):
-
-```cpp
-// Fair allocation variant: allocates fresh buffer each iteration
-template <class T> void bench_simdjson_static_reflection(T &data) {
-  // First run to determine expected size
-  simdjson::builder::string_builder sb_init;
-  simdjson::builder::append(sb_init, data);
-  std::string_view p_init;
-  if(sb_init.view().get(p_init)) {
-    std::cerr << "Error!" << std::endl;
-  }
-  size_t output_volume = p_init.size();
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
-               bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 simdjson::builder::string_builder sb;
-                 simdjson::builder::append(sb, data);
-                 std::string_view p;
-                 if(sb.view().get(p)) {
-                   std::cerr << "Error!" << std::endl;
-                 }
-                 measured_volume = sb.size();
-               }));
-}
-```
-
-**Fairness Assessment**: ✅ **FAIR**
-- Allocates fresh `string_builder` each iteration
-- Matches allocation behavior of other libraries
-
-**Buffer Reuse Variant** (`benchmark_serialization_twitter.cpp:82-108`):
-
-```cpp
-// Optimized variant: reuses buffer across iterations
-template <class T> void bench_simdjson_static_reflection_reuse(T &data) {
-  simdjson::builder::string_builder sb;
-  // ... initial setup ...
-
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_reuse_buffer",
-               bench([&data, &measured_volume, &output_volume, &sb]() {
-                 sb.clear();  // Clears content but retains allocated memory
-                 simdjson::builder::append(sb, data);
-                 // ...
-               }));
-}
-```
-
-**Fairness Assessment**: ⚠️ **OPTIMIZED** (not for cross-library comparison)
-- `sb.clear()` retains allocated memory, avoiding reallocation
-- Represents realistic production usage where buffers are reused
-- ~12-13% faster than fair variant
-
-### 6.2 nlohmann::json
-
-**Implementation** (`benchmark_serialization_twitter.cpp:155-169`):
-
-```cpp
-void bench_nlohmann(TwitterData &data) {
-  std::string output = nlohmann_serialize(data);
-  size_t output_volume = output.size();
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_nlohmann",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = nlohmann_serialize(data);
-                 measured_volume = output.size();
-               }));
-}
-```
-
-**Serialization function** (`nlohmann_twitter_data.h:60-63`):
-
-```cpp
-std::string nlohmann_serialize(const TwitterData &data) {
-  nlohmann::json j = data;
-  return j.dump();
-}
-```
-
-**Fairness Assessment**: ✅ **FAIR**
-- Fresh allocation each iteration
-- Uses standard nlohmann API (`dump()`)
-- No special optimizations applied
-
-### 6.3 yyjson
-
-**Implementation** (`benchmark_serialization_twitter.cpp:171-187`):
-
-```cpp
-void bench_yyjson(TwitterData &data) {
-  std::string output = yyjson_serialize(data);
-  size_t output_volume = output.size();
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_yyjson",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = yyjson_serialize(data);
-                 measured_volume = output.size();
-               }));
-}
-```
-
-**Serialization function** (`yyjson_twitter_data.h:97-143`):
-
-```cpp
-std::string yyjson_serialize(const TwitterData &data) {
-    yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
-    yyjson_mut_val *root = yyjson_mut_obj(doc);
-    yyjson_mut_doc_set_root(doc, root);
-
-    // Manual field-by-field serialization
-    yyjson_mut_val *statuses_array = yyjson_mut_arr(doc);
-    for (const auto& status : data.statuses) {
-        yyjson_mut_val *status_obj = yyjson_mut_obj(doc);
-        yyjson_mut_obj_add_str(doc, status_obj, "created_at", status.created_at.c_str());
-        yyjson_mut_obj_add_uint(doc, status_obj, "id", status.id);
-        // ... more fields ...
-        yyjson_mut_arr_append(statuses_array, status_obj);
-    }
-    yyjson_mut_obj_add_val(doc, root, "statuses", statuses_array);
-
-    char *json_output = yyjson_mut_write(doc, 0, NULL);
-    std::string result(json_output);
-    free(json_output);
-    yyjson_mut_doc_free(doc);
-
-    return result;
-}
-```
-
-**Fairness Assessment**: ✅ **FAIR**
-- Fresh document allocation each iteration
-- Uses idiomatic yyjson mutable document API
-- Includes memory cleanup (`free`, `yyjson_mut_doc_free`)
-
-### 6.4 Rust/serde
-
-**Implementation** (`benchmark_serialization_twitter.cpp:40-51`):
-
-```cpp
-void bench_rust(serde_benchmark::TwitterData *data) {
-  const char * output = serde_benchmark::str_from_twitter(data);
-  size_t output_volume = strlen(output);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_rust",
-               bench([&data, &measured_volume, &output_volume]() {
-                 const char * output = serde_benchmark::str_from_twitter(data);
-                 serde_benchmark::free_string(output);
-               }));
-}
-```
-
-**Rust FFI function** (`serde-benchmark/lib.rs:51-56`):
-
-```rust
-#[no_mangle]
-pub unsafe extern "C" fn str_from_twitter(raw: *mut TwitterData) -> *const c_char {
-    let twitter_thing = { &*raw };
-    let serialized = serde_json::to_string(&twitter_thing).unwrap();
-    return std::ffi::CString::new(serialized.as_str()).unwrap().into_raw()
-}
-```
-
-**Fairness Assessment**: ⚠️ **FAIR with documented overhead**
-- Fresh allocation each iteration (Rust `String` + `CString`)
-- FFI overhead includes:
-  1. Cross-language function call
-  2. `CString` allocation and copy from Rust `String`
-  3. Return value marshaling
-
-#### 6.4.1 Measured FFI Overhead (Twitter Dataset)
-
-We implemented a dedicated FFI overhead measurement that compares:
-1. Pure `serde_json::to_string()` timing (measured inside Rust)
-2. `serde_json::to_string()` + `CString` conversion (measured inside Rust)
-3. Full FFI call timing (measured from C++)
-
-**Measurement methodology** (`lib.rs`):
-
-```rust
-#[no_mangle]
-pub unsafe extern "C" fn measure_twitter_ffi_overhead(
-    raw: *mut TwitterData,
-    iterations: u64
-) -> FfiOverheadResult {
-    use std::time::Instant;
-    let twitter_data = &*raw;
-
-    // Measure pure serde_json::to_string() - no CString conversion
-    let start_pure = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&twitter_data).unwrap();
-        black_box(&serialized);
-    }
-    let pure_serde_ns = start_pure.elapsed().as_nanos() as u64;
-
-    // Measure serde + CString conversion (but not FFI return)
-    let start_cstring = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&twitter_data).unwrap();
-        let cstring = CString::new(serialized).unwrap();
-        black_box(&cstring);
-    }
-    let serde_plus_cstring_ns = start_cstring.elapsed().as_nanos() as u64;
-
-    FfiOverheadResult { pure_serde_ns, serde_plus_cstring_ns, iterations, output_size }
-}
-```
-
-**Measured Results** (10,000 iterations, Twitter dataset):
-
-| Measurement | Time/iter | Throughput | Overhead |
-|------------|-----------|------------|----------|
-| Pure `serde_json::to_string()` | ~40,000 ns | ~1,930 MB/s | baseline |
-| + CString conversion | ~42,500 ns | ~1,840 MB/s | +5.4% |
-| + FFI call/return | ~45,000 ns | ~1,730 MB/s | +5.5% |
-| **Total FFI overhead** | ~5,000 ns | - | **~10%** |
-
-**Summary**:
-- **Measured FFI overhead: ~10%** (range: 9.4% - 11.0% across runs)
-- CString conversion contributes ~5.4% overhead (memory copy of 82KB string)
-- FFI call mechanics contribute ~5.5% overhead
-- **Pure Rust serde_json performance: ~1,930 MB/s** (vs ~1,730 MB/s reported)
-
-This means pure Rust/serde (without FFI) would be **~10% faster** than reported in our benchmarks. The comparison ratios should be adjusted accordingly:
-- simdjson vs pure Rust/serde: ~1.5x faster (instead of ~1.7x with FFI overhead)
-
-### 6.5 reflect-cpp
-
-**Implementation** (`benchmark_serialization_twitter.cpp:19-33`):
-
-```cpp
-void bench_reflect_cpp(TwitterData &data) {
-  std::string output = rfl::json::write(data);
-  size_t output_volume = output.size();
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_reflect_cpp",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = rfl::json::write(data);
-                 measured_volume = output.size();
-               }));
-}
-```
-
-**Fairness Assessment**: ✅ **FAIR**
-- Fresh allocation each iteration
-- Uses standard reflect-cpp API (`rfl::json::write`)
-- No special optimizations
-
----
-
-## 7. Output Equivalence Verification
-
-### 7.1 Twitter Dataset
-
-| Library | Output Size (bytes) | Match |
-|---------|---------------------|-------|
-| simdjson (static reflection) | 81,927 | ✅ Reference |
-| simdjson (to_json) | 81,927 | ✅ |
-| nlohmann::json | 81,927 | ✅ |
-| yyjson | 81,927 | ✅ |
-| Rust/serde | 81,927 | ✅ |
-| reflect-cpp | 81,927 | ✅ |
-
-**Verification**: All libraries produce identical output size, confirming semantic equivalence.
-
-### 7.2 CITM Catalog Dataset
-
-| Library | Output Size (bytes) | Match | Notes |
-|---------|---------------------|-------|-------|
-| simdjson (static reflection) | 496,682 | ✅ Reference | |
-| simdjson (to_json) | 496,682 | ✅ | |
-| nlohmann::json | 496,682 | ✅ | |
-| yyjson | 496,682 | ✅ | |
-| Rust/serde | 496,682 | ✅ | |
-| reflect-cpp | 476,270 | ⚠️ | -20,412 bytes |
-
-**reflect-cpp Discrepancy Analysis**:
-
-The 20,412-byte difference is due to `std::optional` handling:
-- simdjson/nlohmann output: `"logo":null` for empty optionals
-- reflect-cpp behavior: Omits empty optional fields entirely
-
-Both are valid JSON representations. For strict equivalence, note:
-- reflect-cpp has ~4% less data to write
-- This provides a small (likely <5%) performance advantage
-
----
-
-## 8. Consolidated Results
-
-### 8.1 Twitter Serialization (81,927 bytes output)
-
-**Multiple runs showing variance** (3 consecutive runs):
-
-| Library | Run 1 (MB/s) | Run 2 (MB/s) | Run 3 (MB/s) | Mean | Std Dev |
-|---------|-------------|-------------|-------------|------|---------|
-| simdjson (buffer reuse) | 3,460 | 3,245 | 3,393 | 3,366 | ±89 |
-| simdjson (fresh alloc) | 3,024 | 2,699 | 2,930 | 2,884 | ±136 |
-| simdjson to_json (reuse) | 2,660 | 2,892 | 2,998 | 2,850 | ±141 |
-| simdjson to_json (fresh) | 2,512 | 2,684 | 2,493 | 2,563 | ±86 |
-| yyjson | 1,346 | 1,370 | 1,309 | 1,342 | ±25 |
-| Rust/serde | 1,352 | 1,281 | 1,717 | 1,450 | ±190 |
-| reflect-cpp | 1,110 | 1,117 | 1,481 | 1,236 | ±173 |
-| nlohmann::json | 147 | 142 | 145 | 145 | ±2 |
-
-**Relative Performance** (vs simdjson fresh alloc):
-
-| Library | Throughput | Speedup |
-|---------|------------|---------|
-| **simdjson (buffer reuse)** | 3,366 MB/s | 1.17x |
-| **simdjson (fresh alloc)** | 2,884 MB/s | 1.00x (baseline) |
-| simdjson to_json (reuse) | 2,850 MB/s | 0.99x |
-| simdjson to_json (fresh) | 2,563 MB/s | 0.89x |
-| yyjson | 1,342 MB/s | 0.47x (2.1x slower) |
-| Rust/serde | 1,450 MB/s | 0.50x (2.0x slower) |
-| reflect-cpp | 1,236 MB/s | 0.43x (2.3x slower) |
-| nlohmann::json | 145 MB/s | 0.05x (19.9x slower) |
-
-### 8.2 CITM Catalog Serialization (496,682 bytes output)
-
-| Library | Throughput (MB/s) | vs simdjson |
-|---------|-------------------|-------------|
-| **simdjson (buffer reuse)** | 2,102 | 1.07x |
-| **simdjson (fresh alloc)** | 1,965 | 1.00x (baseline) |
-| simdjson to_json (fresh) | 1,913 | 0.97x |
-| simdjson to_json (reuse) | 1,864 | 0.95x |
-| Rust/serde | 1,078 | 0.55x (1.8x slower) |
-| yyjson | 921 | 0.47x (2.1x slower) |
-| reflect-cpp | 842 | 0.43x (2.3x slower)* |
-| nlohmann::json | 67 | 0.03x (29.3x slower) |
-
-*Note: reflect-cpp produces smaller output (476,270 bytes)
-
-### 8.3 Summary Claims (Conservative Estimates)
-
-Based on the fair comparison variants:
-
-| Claim | Twitter | CITM | Conservative |
-|-------|---------|------|--------------|
-| simdjson vs nlohmann | 19.9x | 29.3x | **~20x faster** |
-| simdjson vs yyjson | 2.1x | 2.1x | **~2x faster** |
-| simdjson vs Rust/serde (with FFI) | 2.0x | 1.8x | **~2x faster** |
-| simdjson vs Rust/serde (pure)* | ~1.5x | ~1.5x | **~1.5x faster** |
-| simdjson vs reflect-cpp | 2.3x | 2.3x | **~2x faster** |
-
-*Pure Rust/serde performance estimated by removing measured ~10% FFI overhead (see Section 6.4.1)
-
----
-
-## 9. Threats to Validity
-
-### 9.1 Internal Validity
-
-1. **Virtualization Overhead**: Benchmarks run in Docker on Apple Silicon via OrbStack. Native performance may differ.
-
-2. **Thermal Throttling**: Variance of ±10-15% observed between runs, likely due to thermal management in virtualized environment.
-
-3. **Memory Allocator**: All tests use the default system allocator. Custom allocators (jemalloc, tcmalloc) may affect relative performance.
-
-### 9.2 External Validity
-
-1. **Data Characteristics**: Twitter and CITM represent specific JSON patterns. Performance may vary with different data shapes (deeply nested, sparse, etc.).
-
-2. **String Content**: Test data contains UTF-8 text including emojis and non-ASCII characters. ASCII-only data may show different performance characteristics.
-
-3. **Platform**: Results are for ARM64 (Apple Silicon). x86-64 with AVX2/AVX-512 may show different relative performance.
-
-### 9.3 Construct Validity
-
-1. **Simplified Schema**: The Twitter benchmark uses a subset of the full schema (9 User fields vs 30+ in original). This may favor libraries optimized for smaller structures.
-
-2. **Rust FFI Overhead**: Rust numbers include FFI marshaling overhead. **Measured impact: ~10%** (see Section 6.4.1). Pure Rust applications would achieve ~1,930 MB/s vs the reported ~1,730 MB/s. This reduces the simdjson vs Rust/serde speedup from ~2x to ~1.5x when comparing against pure Rust performance.
-
-3. **reflect-cpp Output Size**: For CITM, reflect-cpp produces 4% smaller output due to optional field handling. This provides a small advantage.
-
----
-
-## 10. Conclusions
-
-### 10.1 Key Findings
-
-1. **simdjson with C++26 reflection achieves best-in-class serialization performance**, reaching 2.9-3.4 GB/s on the Twitter dataset.
-
-2. **Buffer reuse provides 12-17% improvement** over fresh allocation, representing realistic production performance.
-
-3. **simdjson is approximately 2x faster** than both yyjson (C) and Rust/serde, and **~20x faster** than nlohmann::json.
-
-4. **All benchmarks are methodologically fair**:
-   - Same data structures across all libraries
-   - Fresh allocation each iteration (for fair comparison)
-   - Output size verification confirms semantic equivalence
-
-### 10.2 Recommended Claims for Publication
-
-**Conservative (defensible under scrutiny)**:
-- "simdjson achieves 2.5+ GB/s JSON serialization throughput"
-- "simdjson is approximately 2x faster than yyjson"
-- "simdjson is approximately 1.5x faster than pure Rust/serde" (accounting for measured 10% FFI overhead)
-- "simdjson is approximately 20x faster than nlohmann::json"
-
-**With buffer reuse (realistic production)**:
-- "simdjson achieves 3+ GB/s with buffer reuse"
-- "Buffer reuse improves performance by 12-17%"
-
-**Important caveat for Rust comparison**:
-> The Rust/serde benchmark includes ~10% FFI overhead (measured). Pure Rust applications using serde_json directly would achieve approximately 1,930 MB/s, reducing simdjson's advantage from 2x to approximately 1.5x.
-
-### 10.3 Reproducibility
-
-All benchmarks can be reproduced using:
-
-```bash
-# Clone the repository
-git clone https://github.com/simdjson/simdjson.git
-cd simdjson
-git checkout francisco/ablation_study
-
-# Run benchmarks (requires Docker with Bloomberg clang-p2996 image)
-./p2996/run_docker.sh "./unified_benchmark.sh --serialization --clean"
-```
-
----
-
-## Appendix A: Raw Benchmark Output
-
-```
-=== Twitter Serialization Benchmark ===
-# Reading file /path/to/jsonexamples/twitter.json
-# output volume: 81927 bytes
-bench_nlohmann                                               :  147.15 MB/s
-# output volume: 81927 bytes
-bench_yyjson                                                 :  1486.64 MB/s
-# output volume: 81927 bytes
-bench_simdjson_static_reflection                             :  3070.12 MB/s
-# output volume: 81927 bytes
-bench_simdjson_reuse_buffer                                  :  3483.22 MB/s
-# output volume: 81927 bytes
-bench_simdjson_to                                            :  2855.68 MB/s
-# output volume: 81927 bytes
-bench_simdjson_to_reuse                                      :  2817.43 MB/s
-# output volume: 81927 bytes
-bench_rust                                                   :  1354.80 MB/s
-# output volume: 81927 bytes
-bench_reflect_cpp                                            :  1005.21 MB/s
-
-=== CITM Serialization Benchmark ===
-# output volume: 496682 bytes
-bench_nlohmann                                               :  67.24 MB/s
-# output volume: 496682 bytes
-bench_yyjson                                                 :  921.23 MB/s
-# output volume: 496682 bytes
-bench_simdjson_static_reflection                             :  1964.60 MB/s
-# output volume: 496682 bytes
-bench_simdjson_reuse_buffer                                  :  2102.01 MB/s
-# output volume: 496682 bytes
-bench_simdjson_to                                            :  1912.85 MB/s
-# output volume: 496682 bytes
-bench_simdjson_to_reuse                                      :  1864.27 MB/s
-# output volume: 496682 bytes
-bench_rust                                                   :  1077.79 MB/s
-# output volume: 476270 bytes
-bench_reflect_cpp                                            :  841.75 MB/s
-```
-
----
-
-## Appendix B: File Checksums
-
-For reproducibility verification:
-
-| File | Purpose | Lines |
-|------|---------|-------|
-| `benchmark/static_reflect/twitter_benchmark/benchmark_serialization_twitter.cpp` | Main Twitter benchmark | 302 |
-| `benchmark/static_reflect/twitter_benchmark/twitter_data.h` | C++ data structures | 32 |
-| `benchmark/static_reflect/twitter_benchmark/nlohmann_twitter_data.h` | nlohmann serializers | 70 |
-| `benchmark/static_reflect/twitter_benchmark/yyjson_twitter_data.h` | yyjson serializers | 145 |
-| `benchmark/static_reflect/serde-benchmark/lib.rs` | Rust/serde implementation | 241 |
-| `benchmark/static_reflect/benchmark_utils/benchmark_helper.h` | Timing infrastructure | 52 |

build_reflection_benchmark.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# Clean build script for simdjson reflection benchmark
+set -e
+
+# Get the directory where this script is located
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Navigate to simdjson root directory (where this script is located)
+cd "$SCRIPT_DIR"
+
+# Clean any existing build
+rm -rf build
+
+# Create new build directory
+mkdir build
+cd build
+
+# Configure with the specified settings
+cmake .. \
+  -DCMAKE_CXX_COMPILER=clang++ \
+  -DSIMDJSON_DEVELOPER_MODE=ON \
+  -DSIMDJSON_STATIC_REFLECTION=ON \
+  -DBUILD_SHARED_LIBS=OFF \
+  -DCMAKE_BUILD_TYPE=Release
+
+# Build the specific target
+make benchmark_serialization_twitter
+
+echo "Build completed successfully!"
+echo "To run the benchmark with simdjson static reflection filter, use:"
+echo "./benchmark/static_reflect/twitter_benchmark/benchmark_serialization_twitter -f simdjson_static_reflection"

build_unified_benchmark.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+
+# Build script for the unified JSON benchmark
+# This compiles the benchmark with all available libraries
+
+echo "Building Unified JSON Benchmark..."
+
+# Check for dependencies directories
+NLOHMANN_PATH=""
+RAPIDJSON_PATH=""
+SERDE_PATH=""
+
+# Try multiple possible locations for dependencies
+for dir in build build20 build26; do
+    if [ -d "$dir/_deps/nlohmann_json-src/include" ]; then
+        NLOHMANN_PATH="-I./$dir/_deps/nlohmann_json-src/include -DHAS_NLOHMANN"
+        echo "✓ Found nlohmann/json in $dir"
+        break
+    fi
+done
+
+if [ -z "$NLOHMANN_PATH" ]; then
+    echo "✗ nlohmann/json not found"
+fi
+
+for dir in build build20 build26; do
+    if [ -d "$dir/_deps/rapidjson-src/include" ]; then
+        RAPIDJSON_PATH="-I./$dir/_deps/rapidjson-src/include -DHAS_RAPIDJSON"
+        echo "✓ Found RapidJSON in $dir"
+        break
+    fi
+done
+
+if [ -z "$RAPIDJSON_PATH" ]; then
+    echo "✗ RapidJSON not found"
+fi
+
+# Check for Serde benchmark library (.so or .a)
+if [ -f "benchmark/static_reflect/serde-benchmark/target/release/libserde_benchmark.so" ] || [ -f "benchmark/static_reflect/serde-benchmark/target/release/libserde_benchmark.a" ]; then
+    SERDE_PATH="-L./benchmark/static_reflect/serde-benchmark/target/release -lserde_benchmark -ldl -lpthread -DHAS_SERDE"
+    echo "✓ Found Serde benchmark library"
+else
+    echo "✗ Serde benchmark library not found"
+    echo "  To build it: cd benchmark/static_reflect/serde-benchmark && cargo build --release"
+fi
+
+# Check for yyjson
+YYJSON_PATH=""
+YYJSON_LIB=""
+if [ -d "build/_deps/yyjson-src/src" ] || [ -f "build/dependencies/libyyjson.a" ]; then
+    if [ -f "build/dependencies/libyyjson.a" ]; then
+        YYJSON_PATH="-I./build/_deps/yyjson-src/src -DHAS_YYJSON"
+        YYJSON_LIB="build/dependencies/libyyjson.a"
+        echo "✓ Found yyjson library"
+    elif [ -f "build/_deps/yyjson-build/libyyjson.a" ]; then
+        YYJSON_PATH="-I./build/_deps/yyjson-src/src -DHAS_YYJSON"
+        YYJSON_LIB="build/_deps/yyjson-build/libyyjson.a"
+        echo "✓ Found yyjson library"
+    fi
+else
+    echo "✗ yyjson not found"
+fi
+
+# Note: reflect-cpp disabled due to complex linking requirements
+# REFLECTCPP_PATH=""
+
+# Compile the benchmark
+clang++ -std=c++26 \
+    -freflection \
+    -fexpansion-statements \
+    -stdlib=libc++ \
+    -DSIMDJSON_STATIC_REFLECTION=1 \
+    -DSIMDJSON_EXCEPTIONS=1 \
+    -I./include \
+    -I./benchmark/static_reflect/serde-benchmark \
+    $NLOHMANN_PATH \
+    $RAPIDJSON_PATH \
+    $YYJSON_PATH \
+    -O3 \
+    benchmark/unified_benchmark.cpp \
+    singleheader/simdjson.cpp \
+    $YYJSON_LIB \
+    $SERDE_PATH \
+    -o benchmark/unified_benchmark
+
+if [ $? -eq 0 ]; then
+    echo ""
+    echo "Build successful! Run with: ./benchmark/unified_benchmark"
+    echo ""
+    echo "The benchmark will test:"
+    echo "  - Twitter dataset (631KB)"
+    echo "  - CITM Catalog dataset (1.7MB)"
+    echo ""
+    echo "With the following methods:"
+    echo "  - simdjson manual parsing"
+    echo "  - simdjson reflection parsing"
+    echo "  - simdjson::from() API"
+    if [ ! -z "$NLOHMANN_PATH" ]; then
+        echo "  - nlohmann/json"
+    fi
+    if [ ! -z "$RAPIDJSON_PATH" ]; then
+        echo "  - RapidJSON"
+    fi
+    if [ ! -z "$SERDE_PATH" ]; then
+        echo "  - Serde (Rust)"
+    fi
+    if [ ! -z "$REFLECTCPP_PATH" ]; then
+        echo "  - reflect-cpp"
+    fi
+else
+    echo "Build failed!"
+    exit 1
+fi

cmake/developer-options.cmake

@@ -4,7 +4,7 @@
 add_library(simdjson-internal-flags INTERFACE)
 if(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
   # We default to ON for all targets, so that we can use the library in shared libraries.
-  set_target_properties(simdjson-internal-flags PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ON)
+  set_target_properties(simdjson-internal-flags PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
 
 option(SIMDJSON_CHECK_EOF "Check for the end of the input buffer. The setting is unnecessary since we require padding of the inputs. You should expect tests to fail with this option turned on." OFF)
@@ -32,9 +32,6 @@ undefined behavior.")
     link_libraries(
         -fsanitize=address -fno-omit-frame-pointer -fno-sanitize-recover=all
     )
-  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-    add_compile_options(-fsanitize=address)
-    link_libraries(-fsanitize=address)
   else()
     message(
         STATUS
@@ -174,10 +171,6 @@ else()
       -Werror -Wall -Wextra -Weffc++ -Wsign-compare -Wshadow -Wwrite-strings
       -Wpointer-arith -Winit-self -Wconversion -Wno-sign-conversion
   )
-  if(CMAKE_CXX_STANDARD VERSION_GREATER_EQUAL 20)
-    target_compile_options(simdjson-internal-flags INTERFACE -Wctad-maybe-unsupported)
-  endif()
-
 endif()
 
 option(SIMDJSON_GLIBCXX_ASSERTIONS "Set _GLIBCXX_ASSERTIONS" OFF)

cmake/exception-flags.cmake

@@ -17,9 +17,8 @@ editing CMAKE_CXX_FLAGS")
     # /EHc used in conjection with /EHs indicates that extern "C" functions
     # never throw (terminate-on-throw)
     # Here, we disable both with the - argument negation operator
-    if(CMAKE_CXX_FLAGS)
-        string(REPLACE "/EHsc" "/EHs-c-" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-    endif()
+    string(REPLACE "/EHsc" "/EHs-c-" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+
     # Because we cannot change the flag above on an individual target (yet), the
     # definition below must similarly be added globally
     add_definitions(-D_HAS_EXCEPTIONS=0)

cmake/toolchains-ci/riscv64-linux-gnu.cmake

@@ -1,4 +0,0 @@
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR riscv64)
-
-set(CMAKE_CROSSCOMPILING_EMULATOR "qemu-riscv64-static")

convert_to_perfetto.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+import sys
+import json
+
+def parse_perf_script(input_file, output_file):
+    """Convert perf script output to Perfetto JSON format"""
+    
+    samples = []
+    current_sample = None
+    
+    with open(input_file, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+                
+            # New sample line
+            if 'cpu-clock:pppH:' in line:
+                if current_sample and current_sample['stack']:
+                    samples.append(current_sample)
+                    
+                parts = line.split()
+                timestamp = float(parts[2].rstrip(':')) * 1000000  # Convert to microseconds
+                current_sample = {
+                    'ts': timestamp,
+                    'stack': [],
+                    'name': 'cpu-clock'
+                }
+            # Stack frame
+            elif line.startswith('\t') and current_sample:
+                # Extract function name from the line
+                parts = line.strip().split()
+                if len(parts) >= 2:
+                    func_info = parts[1]
+                    # Clean up function name
+                    if '+' in func_info:
+                        func_name = func_info.split('+')[0]
+                    else:
+                        func_name = func_info
+                    
+                    # Skip unknown symbols
+                    if func_name != '[unknown]':
+                        current_sample['stack'].append(func_name)
+    
+    # Add last sample
+    if current_sample and current_sample['stack']:
+        samples.append(current_sample)
+    
+    # Create Perfetto trace format
+    trace = {
+        'traceEvents': [],
+        'samples': [],
+        'stacks': {}
+    }
+    
+    # Convert to Perfetto sampling profiler format
+    for i, sample in enumerate(samples):
+        if sample['stack']:
+            # Reverse stack for bottom-up view
+            stack = list(reversed(sample['stack']))
+            
+            # Create a stack ID
+            stack_id = str(i)
+            trace['stacks'][stack_id] = stack
+            
+            # Add sample event
+            trace['samples'].append({
+                'ts': sample['ts'],
+                'sf': stack_id,  # Stack frame ID
+                'pid': 1,
+                'tid': 1,
+                'weight': 1
+            })
+    
+    # Write JSON output
+    with open(output_file, 'w') as f:
+        json.dump(trace, f, indent=2)
+    
+    print(f"Converted {len(samples)} samples to Perfetto format")
+    print(f"Output written to {output_file}")
+
+if __name__ == "__main__":
+    parse_perf_script("perf_simdjson_serialization.txt", "perf_simdjson_perfetto.json")

doc/basics_doxygen.md

@@ -1,8 +1,5 @@
 We take our documentation seriously. Please start reading the documentation before you attempt to use simdjson. We hope you will enjoy reading us.
 
-* [Basics](doc/basics.md) is an overview of how to use simdjson and its APIs.
-* [Builder](doc/builder.md) is an overview of how to efficiently write JSON strings using simdjson.
-* [Performance](doc/performance.md) shows some more advanced scenarios and how to tune for them.
-* [Implementation Selection](doc/implementation-selection.md) describes runtime CPU detection and
-  how you can work with it.
-* [API](https://simdjson.github.io/simdjson/) contains the automatically generated API documentation.
+* Basics: https://github.com/simdjson/simdjson/blob/master/doc/basics.md is an overview of how to use simdjson and its APIs.
+* iterate_many: https://github.com/simdjson/simdjson/blob/master/doc/iterate_many.md describes an interface providing features to work with files or streams containing multiple small JSON documents. As fast and convenient as possible.
+* Performance: https://github.com/simdjson/simdjson/blob/master/doc/performance.md shows some more advanced scenarios and how to tune for them.

doc/builder.md

@@ -34,33 +34,32 @@ It has the following methods to add content to the string:
 - `append_null()`: Appends the string "null" to the JSON buffer.
 - `clear()`: Clears the contents of the JSON buffer, resetting the position to 0 while retaining the allocated capacity.
 - `escape_and_append(std::string_view input)`: Appends a string view to the JSON buffer after escaping special characters (e.g., quotes, backslashes) as required by JSON.
-- `escape_and_append_with_quotes(std::string_view input)` Appends a string view surrounded by double quotes (e.g., "input") to the JSON buffer after escaping special characters. For constant strings, you may also do `escape_and_append_with_quotes<"mystring">()`.
+- `escape_and_append_with_quotes(std::string_view input)` Appends a string view surrounded by double quotes (e.g., "input") to the JSON buffer after escaping special characters.
+Parameters:
 - `escape_and_append_with_quotes(char input)`: Appends a single character surrounded by double quotes (e.g., "c") to the JSON buffer after escaping it if necessary.
 - `append_raw(const char *c)`: Appends a null-terminated C string directly to the JSON buffer without escaping.
 - `append_raw(std::string_view input)`: Appends a string view directly to the JSON buffer without escaping.
 - `append_raw(const char *str, size_t len)`: Appends a specified number of characters from a C string directly to the JSON
-- `append_key_value(key,value)`: Appends a key and a value (`"json":somevalue`)
-- `append_key_value<"mykey">(value)`: Appends a key and a value (`"json":somevalue`), useful when the key is a compile-time constant (C++20).
 
-After writing the content, if you have reasons to believe that the content might violate UTF-8 conventions, you can check it as follows:
+After writting the content, if you have reasons to believe that the content might violate UTF-8 conventions, you can check it as follows:
 
 - `validate_unicode()`: Checks if the content in the JSON buffer is valid UTF-8. Returns: true if the content is valid UTF-8, false otherwise.
 
 You might need to do unicode validation if you have strings in your data structures containing
-malformed UTF-8. Note that we do not automatically call `validate_unicode()`.
+malformed UTF-8.
 
 Once you are satisfied, you can recover the string as follows:
 
 - `operator std::string()`: Converts the JSON buffer to an std::string. (Might throw if an error occurred.)
 - `operator std::string_view()`: Converts the JSON buffer to an std::string_view.  (Might throw if an error occurred.)
-- `view()`: Returns a view of the written JSON buffer as a `simdjson_result<std::string_view>` (C++20).
+- `view()`: Returns a view of the written JSON buffer as a `simdjson_result<std::string_view>`.
 
-The later method (`view()`) is recommended.  For performance reasons, we expect you to explicitly call `validate_unicode()` as needed (e.g., prior to calling `view()`).
+The later method (`view()`) is recommended.
 
 Example: string_builder
 ---------------------------
 
-```cpp
+```C++
 struct Car {
     std::string make;
     std::string model;
@@ -132,20 +131,20 @@ In all cases, the `std::string_view` instance depends the corresponding `string_
 
 
 
-If you have C++20, you can simplify the code, as the `std::vector<double>` is automatically supported. Further, we can pass the keys (which are compile-time
-constant) as template parameter (for improved performance).
+If you have C++20, you can simplify the code, as the `std::vector<double>` is automatically
+supported.
 
 ```cpp
     Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
     simdjson::builder::string_builder sb;
     sb.start_object();
-    sb.append_key_value<"make">(c.make);
+    sb.append_key_value("make", c.make);
     sb.append_comma();
-    sb.append_key_value<"model">(c.model);
+    sb.append_key_value("model", c.model);
     sb.append_comma();
-    sb.append_key_value<"year">(c.year);
+    sb.append_key_value("year", c.year);
     sb.append_comma();
-    sb.append_key_value<"tire_pressure">(c.tire_pressure);
+    sb.append_key_value("tire_pressure", c.tire_pressure);
     sb.end_object();
     std::string_view p = sb.view();
 ```
@@ -176,52 +175,9 @@ std::vector<std::vector<double>> c = {{1.0, 2.0}, {3.0, 4.0}};
 std::string json = simdjson::to_json(c);
 ```
 
-We also have an overload for when you want to reuse the same `std::string` instance:
-
-
-```cpp
-std::vector<std::vector<double>> c = {{1.0, 2.0}, {3.0, 4.0}};
-std::string json;
-auto error = simdjson::to_json(c, json);
-if(error) { /* there was an error */ }
-```
-
-
 We do recommend that you create and reuse the `string_builder` instance for performance
 reasons.
 
-You can also add custom serialization functions using a `tag_invoke` function.
-For example, the following
-function will allow you to serialize instances of the type `Car`.
-
-```cpp
-#include <simdjson>
-
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year;
-  std::vector<float> tire_pressure;
-};
-
-namespace simdjson {
-
-template <typename builder_type>
-void tag_invoke(serialize_tag, builder_type &builder, const Car& car) {
-  builder.start_object();
-  builder.append_key_value("make", car.make);
-  builder.append_comma();
-  builder.append_key_value("model", car.model);
-  builder.append_comma();
-  builder.append_key_value("year", car.year);
-  builder.append_comma();
-  builder.append_key_value("tire_pressure", car.tire_pressure);
-  builder.end_object();
-}
-
-} // namespace simdjson
-```
-
 C++26 static reflection
 ------------------------
 
@@ -283,38 +239,7 @@ with the `simdjson::to_json` template function.
 If you know the output size, in bytes, of your JSON string, you may
 pass it as a second parameter (e.g., `simdjson::to_json(c, 31123)`).
 
-Sometimes you may want to reuse the same `std::string` instance. We
-have an overload for this purpose:
 
-```cpp
-Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
-std::string s;
-auto error = simdjson::to_json(c, s);
-if(error) { /* there was an error */ }
-```
-
-You can then also add a third parameter for the expected output size in bytes.
-
-### Extracting just some fields
-In some instances, your class might have many fields that you do not want to serialize.
-You can achieve this result with the `simdjson::extract_from` template. In the following
-example, we serialize only the `year` and `price` fields on the `Car` instance.
-```cpp
-struct Car {
-    std::string make;
-    std::string model;
-    int year;
-    double price;
-    bool electric;
-};
-Car car{"Ford", "F-150", 2024, 55000.0, false};
-// Extract year and price
-std::string json_result = simdjson::extract_from<"year", "price">(car);
-// Alternatively:
-// std::string json_result;
-// auto error =  extract_from<"year", "price">(car).get(json_result);
-// if(error) { /* error handling */ }
-```
 
 ### Without `string_buffer` instance but with explicit error handling
 
@@ -323,44 +248,9 @@ pattern:
 
 ```cpp
   std::string json;
-  if(simdjson::to_json(c).get(json)) {
+  if(simdjson::to(c).get(json)) {
     // there was an error
   } else {
     // json contain the serialized JSON
   }
-```
-
-### Customization
-
-If you want to serialize a value in a custome way, you can do it with a
-`tag_invoke` specialization like the following example which will map
-the year attribute to a string.
-
-
-```cpp
-#include <simdjson>
-
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year;
-  std::vector<float> tire_pressure;
-};
-
-namespace simdjson {
-
-template <typename builder_type>
-void tag_invoke(serialize_tag, builder_type &builder, const Car& car) {
-  builder.start_object();
-  builder.append_key_value("make", car.make);
-  builder.append_comma();
-  builder.append_key_value("model", car.model);
-  builder.append_comma();
-  builder.append_key_value("year", std::to_string(car.year));
-  builder.append_comma();
-  builder.append_key_value("tire_pressure", car.tire_pressure);
-  builder.end_object();
-}
-
-} // namespace simdjson
 ```

doc/compile_time.md

@@ -1,227 +0,0 @@
-# Parse json at compile time
-   * [Introduction](#introduction)
-   * [Example](#example)
-   * [Concepts](#concepts)
-   * [Loading from disk](#loading-from-disk)
-   * [Limitations (compile-time errors)](#limitations-compile-time-errors)
-
-
-## Introduction
-In some instances, you may want to configure your software at compile-time with a JSON document.
-Maybe you have a single code base but many different possible configurations, all resulting in
-different software. For example, you might be programming robots, using the same software, but
-different robot configurations.
-
-To achieve the desired result, you have a few options. You may start the software and parser a
-JSON file at runtime. Or you might convert your JSON data into C++ code that you can compile with
-your software.
-
-With C++26, there is another way: parse the JSON file along with your C++ code. In this manner,
-the JSON data becomes native C++ data.
-
-The simdjson library supports parsing JSON documents at compile time if you have C++26 support. To
-activate C++26 reflection support, you can compile
-your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
-
-```cpp
-#define SIMDJSON_STATIC_REFLECTION 1
-//...
-#include "simdjson.h"
-```
-
-The `simdjson::compile_time::parse_json` function parses a JSON document at **compile time** and returns a `constexpr` structure reflecting its content. We support the full range of JSON values, which are mapped to C++ types as in
-the following table.
-
-
-| JSON type      | C++ type                         |
-|----------------|----------------------------------|
-| object         | anonymous struct                 |
-| array          | `std::array<T, N>` (homogeneous) |
-| string         | `const char*` (UTF-8)            |
-| number         | `int64_t`, `uint64_t`, `double`  |
-| `true`/`false` | `bool`                           |
-| `null`         | `std::nullptr_t`                 |
-
-## Example
-
-Suppose you want to parse the following JSON document:
-
-```cpp
-{
-    "port": 8080,
-    "host": "localhost",
-    "debug": true
-}
-```
-
-**Reminder**: In C++, `R"( )"` allows us to write multi-line strings with unescaped quotes.
-
-
-You can do so, at compile-time, as follows:
-
-
-```cpp
-constexpr auto cfg = R"(
-
-{
-    "port": 8080,
-    "host": "localhost",
-    "debug": true
-}
-
-)"_json;
-
-// cfg.port == 8080
-// std::string_view(cfg.host) == "localhost"
-// cfg.debug == true
-```
-
-You can nest objects and arrays:
-
-```cpp
-constexpr auto data = R"(
-
-{
-    "servers": [
-        {"host": "s1", "port": 3000},
-        {"host": "s2", "port": 3001}
-    ]
-}
-
-)"_json;
-
-
-// data.servers.size() == 2
-// std::string_view(data.servers[0].host) == "s1"
-```
-
-Top-level arrays are allowed:
-
-```cpp
-constexpr auto arr = R"(
-
-[1, 2, 3]
-
-)"_json;
-static_assert(arr.size() == 3);
-static_assert(arr[1] == 2);
-```
-
-
-## Concepts
-
-Given that the parsed data is made of structures that depend on the JSON input, you might
-want to check that it conforms to your expectation. You can do so with concepts.
-
-Let us consider this example:
-
-```cpp
-    constexpr auto config = R"(
-
-    [
-      { "name": "Alice", "age": 30 },
-      { "name": "Bob", "age": 25 },
-      { "name": "Charlie", "age": 35 }
-    ]
-
-    )"_json;
-```
-
-You might want to ensure that the result is an array of persons. You can define your
-expection with concepts like so:
-
-```cpp
-template <typename T>
-concept person = requires(T p) {
-    std::string_view(p.name);  // has name field convertible to string_view
-    p.age;                     // has age field
-    requires std::is_integral_v<decltype(p.age)>;  // age is integral
-};
-
-/**
- * Concept to validate that a type is an array of person objects
- */
-template <typename T>
-concept array_of_person = requires(T arr) {
-    arr.size();                    // has size method
-    arr[0];                        // can access elements with []
-    requires person<decltype(arr[0])>;  // elements satisfy person concept
-};
-```
-
-And then a simple static assert with `decltype` is sufficient to check that the expectation is met:
-
-```cpp
-  constexpr auto config = R"(
-
-  [
-    { "name": "Alice", "age": 30 },
-    { "name": "Bob", "age": 25 },
-    { "name": "Charlie", "age": 35 }
-  ]
-
-  )"_json;
-
-
-  // Validate that the array satisfies the array_of_person concept
-  static_assert(array_of_person<decltype(config)>);
-```
-
-
-
-## Loading from disk
-
-In practice, you may have a JSON file, say `json_data` that you want to parse
-at compile time. You may do so as follows.
-
-```c++
-constexpr const char json_data[] = {
-    #embed "test.json"
-    , 0
-};
-
-constexpr auto json = simdjson::compile_time::parse_json<json_data>();
-```
-
-
-## Limitations (compile-time errors)
-
-We have a few limitations which trigger compile-time errors if violated.
-
-
-- Only JSON objects and arrays are supported at the top level (no primitives).
-  We will lift this limitation in the future.
-- Strings are represented using the `const char*` in UTF-8, but they must not
-  contain embedded nulls. We would prefer to represent them as std::string or
-  std::string_view, and hope to do so in the future.
-- Heterogeneous arrays are not supported yet. E.g., you need to have arrays of
-  all integers, or all strings, all floats, all compatible objects, etc.
-  For example, the following is accepted:
-  ```json
-   [
-    { "name": "Alice", "age": 30 },
-    { "name": "Bob", "age": 25 },
-    { "name": "Charlie", "age": 35 }
-  ]
-  ```
-  but the following is not:
-  ```json
-  [
-    { "name": "Alice", "age": 30 },
-    "Just a string",
-    42,
-    { "name": "Charlie", "age": 35 }
-  ]
-  ```
-  We may support heterogeneous arrays in the future with std::variant types.
-- We parse the first JSON document encountered in the string. Trailing
-  characters are ignored. Thus if your JSON begins with {"a":1}, everything
-  after the closing brace is ignored. This limitation will be lifted in the future,
-  reporting an error.
-
-These limitations are safe in the sense that they result in compile-time errors.
-Thus you will not get truncated strings or imprecise floats silently.
-
-
-Although we are committed to maintaining the functionality in the long run, the
-`compile_time::parse_json` function is subject to change.

doc/compile_time_accessors.md

@@ -1,445 +0,0 @@
-# Compile-Time JSONPath and JSON Pointer Accessors
-
-**Note:** This feature requires C++26 Static Reflection support (P2996) and is currently only available with experimental compilers. You must enable it with `-DSIMDJSON_STATIC_REFLECTION=ON` when building.
-
-## Overview
-
-simdjson provides compile-time JSONPath and JSON Pointer accessors that validate paths against struct definitions at compile time and generate optimized accessor code with zero runtime overhead. This combines the safety of compile-time type checking with the performance of pre-parsed, pre-validated access paths.
-
-## Requirements
-
-- C++26 compiler with Static Reflection support (P2996)
-- Experimental compiler flags:
-  - Clang with P2996 support: `-std=c++26 -freflection -fexpansion-statements`
-- Build configuration: `-DSIMDJSON_STATIC_REFLECTION=ON`
-
-## How It Works
-
-**Compile Time:**
-1. Path string is parsed and converted to access steps
-2. Path is validated against struct definition using reflection
-3. Field types are checked and verified
-4. Optimized accessor code is generated
-
-**Runtime:**
-- Direct navigation with no parsing
-- No validation overhead
-- No string comparisons for path components
-- Type-safe extraction
-
-## Two Usage Modes
-
-### Mode 1: With Type Validation (Recommended)
-
-When you provide a struct type, the compiler validates the entire path at compile time:
-
-```cpp
-struct User {
-  std::string name;
-  int age;
-  std::vector<std::string> emails;
-};
-
-//  R"( ... )" is a C++ raw string literal.
-const padded_string json = R"({
-  "name": "Alice",
-  "age": 30,
-  "emails": ["alice@example.com", "alice@work.com"]
-})"_padded;
-
-ondemand::parser parser;
-auto doc = parser.iterate(json);
-
-// Compile-time validation: checks that User has "name" field of type std::string
-std::string name;
-auto result = ondemand::json_path::at_path_compiled<User, ".name">(doc);
-result.get(name); // name = "Alice"
-
-// Compile-time validation: checks that "emails" is array-like with string elements
-std::string email;
-result = ondemand::json_path::at_path_compiled<User, ".emails[0]">(doc);
-result.get(email); // email = "alice@example.com"
-```
-
-**Benefits:**
-- **Compile-time errors** if path doesn't exist in struct
-- **Type safety** - verifies field types match expected types
-- **Refactoring protection** - renaming struct fields causes compile errors
-
-**What gets validated:**
-- Field existence
-- Field types
-- Array/container access validity
-- Nested struct navigation
-
-### Mode 2: Without Validation
-
-When you omit the struct type, the path is parsed at compile time but not validated:
-
-```cpp
-const padded_string json = R"({
-  "name": "Alice",
-  "age": 30,
-  "address": {"city": "Boston"}
-})"_padded;
-
-ondemand::parser parser;
-auto doc = parser.iterate(json);
-
-// No compile-time validation - path is only parsed
-std::string name;
-auto result = ondemand::json_path::at_path_compiled<".name">(doc);
-result.get(name); // name = "Alice"
-
-std::string_view city;
-result = ondemand::json_path::at_path_compiled<".address.city">(doc);
-result.get(city); // city = "Boston"
-```
-
-**Benefits:**
-- Works with dynamic/unknown JSON structures
-- Still benefits from compile-time path parsing
-- No runtime string parsing overhead
-
-**Use when:**
-- JSON structure is not known at compile time
-- Working with varied JSON schemas
-- Prototyping or exploratory parsing
-
-## JSONPath Syntax
-
-JSONPath uses dot notation and bracket notation for field access:
-
-### Supported Syntax
-
-| Syntax | Description | Example |
-|--------|-------------|---------|
-| `.field` | Dot notation for field access | `.name`, `.address.city` |
-| `["field"]` | Bracket notation with quotes | `["name"]`, `["address"]["city"]` |
-| `[index]` | Array index access | `[0]`, `[1]` |
-| Mixed | Combination of notations | `.emails[0]`, `["users"][0].name` |
-| `$` prefix | Optional root indicator | `$.name`, `$["name"]` |
-
-### Examples
-
-```cpp
-struct Address {
-  std::string city;
-  int zip;
-};
-
-struct Person {
-  std::string name;
-  int age;
-  Address address;
-  std::vector<std::string> emails;
-};
-
-// Dot notation
-at_path_compiled<Person, ".name">(doc)
-at_path_compiled<Person, ".address.city">(doc)
-
-// Bracket notation
-at_path_compiled<Person, "[\"name\"]">(doc)
-at_path_compiled<Person, "[\"address\"][\"city\"]">(doc)
-
-// Array access
-at_path_compiled<Person, ".emails[0]">(doc)
-at_path_compiled<Person, ".emails[1]">(doc)
-
-// Mixed notation
-at_path_compiled<Person, ".address[\"zip\"]">(doc)
-at_path_compiled<Person, "[\"emails\"][0]">(doc)
-
-// With root indicator
-at_path_compiled<Person, "$.name">(doc)
-at_path_compiled<Person, "$.address.city">(doc)
-```
-
-## JSON Pointer Syntax
-
-JSON Pointer (RFC 6901) uses slash-separated paths:
-
-### Supported Syntax
-
-| Syntax | Description | Example |
-|--------|-------------|---------|
-| `/field` | Field access | `/name`, `/address/city` |
-| `/index` | Array index | `/0`, `/1` |
-| `~0` | Escaped `~` | `/field~0name` → field~name |
-| `~1` | Escaped `/` | `/field~1name` → field/name |
-
-### Examples
-
-```cpp
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year;
-  std::vector<double> tire_pressure;
-};
-
-// Field access
-at_pointer_compiled<Car, "/make">(doc)
-at_pointer_compiled<Car, "/model">(doc)
-
-// Array access
-at_pointer_compiled<Car, "/tire_pressure/0">(doc)
-at_pointer_compiled<Car, "/tire_pressure/1">(doc)
-
-// Root pointer (returns whole document)
-at_pointer_compiled<Car, "">(doc)
-at_pointer_compiled<Car, "/">(doc)
-```
-
-## API Reference
-
-### JSONPath Functions
-
-```cpp
-// With type validation
-template<typename T, constevalutil::fixed_string Path, typename DocOrValue>
-simdjson_result<value> at_path_compiled(DocOrValue& doc_or_val);
-
-// Without validation
-template<constevalutil::fixed_string Path, typename DocOrValue>
-simdjson_result<value> at_path_compiled(DocOrValue& doc_or_val);
-```
-
-### JSON Pointer Functions
-
-```cpp
-// With type validation
-template<typename T, constevalutil::fixed_string Pointer, typename DocOrValue>
-simdjson_result<value> at_pointer_compiled(DocOrValue& doc_or_val);
-
-// Without validation
-template<constevalutil::fixed_string Pointer, typename DocOrValue>
-simdjson_result<value> at_pointer_compiled(DocOrValue& doc_or_val);
-```
-
-### Direct Field Extraction
-
-Extract values directly into variables with compile-time type checking:
-
-```cpp
-// JSONPath
-template<typename T, constevalutil::fixed_string Path>
-struct path_accessor {
-  template<typename DocOrValue, typename FieldType>
-  static error_code extract_field(DocOrValue& doc_or_val, FieldType& target);
-};
-
-// JSON Pointer
-template<typename T, constevalutil::fixed_string Pointer>
-struct pointer_accessor {
-  template<typename DocOrValue, typename FieldType>
-  static error_code extract_field(DocOrValue& doc_or_val, FieldType& target);
-};
-```
-
-**Example:**
-
-```cpp
-struct User {
-  std::string name;
-  int age;
-};
-
-ondemand::parser parser;
-auto doc = parser.iterate(json);
-
-// Extract directly into variable
-std::string name;
-ondemand::json_path::path_accessor<User, ".name">::extract_field(doc, name);
-
-int age;
-ondemand::json_path::pointer_accessor<User, "/age">::extract_field(doc, age);
-```
-
-The compiler verifies that the target variable type matches the field type at the path.
-
-## Complete Examples
-
-### Example 1: Validated Access
-
-```cpp
-#include "simdjson.h"
-using namespace simdjson;
-
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year;
-  std::vector<double> tire_pressure;
-};
-
-int main() {
-  const padded_string json = R"({
-    "make": "Toyota",
-    "model": "Camry",
-    "year": 2018,
-    "tire_pressure": [40.1, 39.9, 37.7, 40.4]
-  })"_padded;
-
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-
-  // Type-validated access
-  std::string make;
-  auto result = ondemand::json_path::at_path_compiled<Car, ".make">(doc);
-  result.get(make); // make = "Toyota"
-
-  // Array access with validation
-  double pressure;
-  result = ondemand::json_path::at_path_compiled<Car, ".tire_pressure[1]">(doc);
-  result.get(pressure); // pressure = 39.9
-
-  return 0;
-}
-```
-
-### Example 2: Non-Validated Access
-
-```cpp
-#include "simdjson.h"
-using namespace simdjson;
-
-int main() {
-  const padded_string json = R"({
-    "user": {
-      "name": "Alice",
-      "preferences": {
-        "theme": "dark",
-        "notifications": true
-      }
-    }
-  })"_padded;
-
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-
-  // No validation - works with any JSON structure
-  std::string_view theme;
-  auto result = ondemand::json_path::at_path_compiled<".user.preferences.theme">(doc);
-  result.get(theme); // theme = "dark"
-
-  bool notifications;
-  result = ondemand::json_path::at_path_compiled<".user.preferences.notifications">(doc);
-  result.get(notifications); // notifications = true
-
-  return 0;
-}
-```
-
-### Example 3: Direct Extraction
-
-```cpp
-#include "simdjson.h"
-using namespace simdjson;
-
-struct Person {
-  std::string name;
-  int age;
-  std::vector<std::string> emails;
-};
-
-int main() {
-  const padded_string json = R"({
-    "name": "Bob",
-    "age": 25,
-    "emails": ["bob@example.com", "bob@work.com"]
-  })"_padded;
-
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-
-  // Extract with type validation
-  std::string name;
-  ondemand::json_path::path_accessor<Person, ".name">::extract_field(doc, name);
-  // name = "Bob"
-
-  int age;
-  ondemand::json_path::pointer_accessor<Person, "/age">::extract_field(doc, age);
-  // age = 25
-
-  std::string email;
-  ondemand::json_path::path_accessor<Person, ".emails[0]">::extract_field(doc, email);
-  // email = "bob@example.com"
-
-  return 0;
-}
-```
-
-## Error Handling
-
-Compile-time errors occur when:
-- Path doesn't exist in struct: `static_assert` failure
-- Field type mismatch: `static_assert` failure
-- Invalid array access on non-array field: `static_assert` failure
-
-Runtime errors occur when:
-- JSON structure doesn't match expected structure
-- Array index out of bounds
-- Type conversion failures
-
-```cpp
-struct User {
-  std::string name;
-  int age;
-};
-
-// Compile-time error: no "email" field in User
-// auto result = ondemand::json_path::at_path_compiled<User, ".email">(doc);
-
-// Compile-time error: age is not an array
-// auto result = ondemand::json_path::at_path_compiled<User, ".age[0]">(doc);
-
-// Runtime error if JSON doesn't have "name" field
-auto result = ondemand::json_path::at_path_compiled<User, ".name">(doc);
-std::string name;
-if (result.get(name) != SUCCESS) {
-  // Handle error
-}
-```
-
-## Performance
-
-Compile-time accessors provide:
-- **Zero path parsing overhead** - paths parsed at compile time
-- **Zero validation overhead** - validation done at compile time
-- **Direct field access** - no runtime path traversal
-- **Type-safe extraction** - no dynamic type checking
-
-Compared to runtime `at_path()` and `at_pointer()`:
-- Eliminates runtime path string parsing
-- Eliminates runtime path validation
-- Generates optimal code path directly
-
-## Limitations
-
-- Requires C++26 compiler with P2996 support (experimental)
-- Paths must be compile-time constants (string literals)
-- Cannot use runtime-computed paths
-- Limited to struct types that support reflection
-- Array indices must be compile-time constants in the path
-
-## When to Use
-
-**Use compile-time accessors when:**
-- You have well-defined struct types
-- JSON structure is known at compile time
-- You want maximum type safety
-- Performance is critical
-
-**Use runtime `at_path()`/`at_pointer()` when:**
-- JSON structure varies or is unknown
-- Paths are computed at runtime
-- Working with C++20 or earlier
-- Flexibility is more important than compile-time checks
-
-## See Also
-
-- [JSON Pointer](basics.md#json-pointer) - Runtime JSON Pointer support
-- [JSONPath](basics.md#jsonpath) - Runtime JSONPath support
-- [Static Reflection for Deserialization](basics.md#3-using-static-reflection-c26) - Using reflection for full struct deserialization

doc/dom.md

@@ -41,7 +41,7 @@ The Basics: Loading and Parsing JSON Documents using the DOM front-end
 The simdjson library offers a simple DOM tree API, which you can access by creating a
 `dom::parser` and calling the `load()` method:
 
-```cpp
+```c++
 dom::parser parser;
 dom::element doc = parser.load(filename); // load and parse a file
 ```
@@ -49,37 +49,21 @@ dom::element doc = parser.load(filename); // load and parse a file
 Or by creating a padded string (for efficiency reasons, simdjson requires a string with
 SIMDJSON_PADDING bytes at the end) and calling `parse()`:
 
-```cpp
+```c++
 dom::parser parser;
 dom::element doc = parser.parse("[1,2,3]"_padded); // parse a string, the _padded suffix creates a simdjson::padded_string instance
 ```
 
-You can also load a `padded_string` from a file.
-
-
-```cpp
-auto json = padded_string::load("twitter.json"); // load JSON file 'twitter.json'.
-dom::element doc = parser.parse(json);
-```
-
-(Windows users compiling with C++17 or better may use `wchar_t` strings to support non-ASCII
-filenames: `padded_string::load(L"twitter.json")`.)
-
-
-(Windows users compiling with C++17 or better may use `wchar_t` strings to support non-ASCII
-filenames: `padded_string::load(L"twitter.json")`.)
-
-
 You can copy your data directly on a `simdjson::padded_string` as follows:
 
-```cpp
+```c++
 const char * data = "my data"; // 7 bytes
 simdjson::padded_string my_padded_data(data, 7); // copies to a padded buffer
 ```
 
 Or as follows...
 
-```cpp
+```c++
 std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```
@@ -99,7 +83,7 @@ container-overflow checks, you may encounter sanitizer warnings.
 You can safely ignore these warnings. Or you can call `simdjson::pad(std::string&)` to pad the
 string with `SIMDJSON_PADDING` spaces: this function returns a `simdjson::padding_string_view` which can be be passed to the parser's iterator function:
 
-```cpp
+```c++
 std::string json = "[1]";
 dom::element doc = parser.parse(simdjson::pad(json));
 ```
@@ -133,9 +117,8 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
   dom::object and dom::array. An exception (`simdjson::simdjson_error`) is thrown if the cast is not possible.
 * **Extracting Values (without exceptions):** You can use a variant usage of `get()` with error codes to avoid exceptions. You first declare the variable of the appropriate type (`double`, `uint64_t`, `int64_t`, `bool`, `std::string_view`,
   `dom::object` and `dom::array`) and pass it by reference to `get()` which gives you back an error code: e.g.,
-  ```cpp
+  ```c++
   simdjson::error_code error;
-  // _padded returns an simdjson::padded_string instance
   simdjson::padded_string numberstring = "1.2"_padded; // our JSON input ("1.2")
   simdjson::dom::parser parser;
   double value; // variable where we store the value to be parsed
@@ -146,7 +129,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
   The strings contain unescaped valid UTF-8 strings: no unmatched surrogate is allowed.
   Internally, numbers are stored as either 64-bit integers or 64-bit floating-point numbers.
   Thus it is possible to get the full 64-bit integer range (either signed or  unsigned).
-  By default, the string `-0` is parsed as the integer 0 as in Python or C++. If you set the macro
+  By default, the string `-0` is parsed as the integer 0 as in Pytho or C++. If you set the macro
   `SIMDJSON_MINUS_ZERO_AS_FLOAT` to `1` when building simdjson, you can get that `-0` is mapped to `-0.0`
   as in JavaScript. You can get the desired effect by building simdjson with cmake setting the
   `SIMDJSON_MINUS_ZERO_AS_FLOAT` to on: `cmake -B build -D SIMDJSON_MINUS_ZERO_AS_FLOAT=ON`.
@@ -169,8 +152,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
 
 The following code illustrates all of the above:
 
-```cpp
-//  R"( ... )" is a C++ raw string literal.
+```c++
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -203,7 +185,7 @@ for (dom::object car : parser.parse(cars_json)) {
 
 Here is a different example illustrating the same ideas:
 
-```cpp
+```C++
 auto abstract_json = R"( [
     {  "12345" : {"a":12.34, "b":56.78, "c": 9998877}   },
     {  "12545" : {"a":11.44, "b":12.78, "c": 11111111}  }
@@ -225,7 +207,7 @@ for (dom::object obj : parser.parse(abstract_json)) {
 And another one:
 
 
-```cpp
+```C++
   auto abstract_json = R"(
     {  "str" : { "123" : {"abc" : 3.14 } } } )"_padded;
   dom::parser parser;
@@ -239,7 +221,7 @@ C++17 Support
 
 While the simdjson library can be used in any project using C++ 11 and above, field iteration has special support C++ 17's destructuring syntax. For example:
 
-```cpp
+```c++
 padded_string json = R"(  { "foo": 1, "bar": 2 }  )"_padded;
 dom::parser parser;
 dom::object object; // invalid until the get() succeeds
@@ -252,7 +234,7 @@ for (auto [key, value] : object) {
 
 For comparison, here is the C++ 11 version of the same code:
 
-```cpp
+```c++
 // C++ 11 version for comparison
 padded_string json = R"(  { "foo": 1, "bar": 2 }  )"_padded;
 dom::parser parser;
@@ -269,7 +251,7 @@ C++20 Support
 
 simdjson library also supports some C++20 feature including `std::ranges`:
 
-```cpp
+```c++
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -288,7 +270,7 @@ JSON Pointer
 The simdjson library also supports [JSON pointer](https://tools.ietf.org/html/rfc6901) through the
 `at_pointer()` method, letting you reach further down into the document in a single call:
 
-```cpp
+```c++
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -309,7 +291,7 @@ You can apply a JSON Pointer expression to any node and the path gets interprete
 
 Consider the following example:
 
-```cpp
+```c++
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -331,11 +313,11 @@ JSONPath
 ------------
 
 
-The simdjson library supports a subset of [JSONPath](https://www.rfc-editor.org/rfc/rfc9535) (RFC 9535) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
+The simdjson library supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
 
 Consider the following example:
 
-```cpp
+```c++
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -354,7 +336,7 @@ cout << p << endl; // Prints 39.9
 
 We also support the `$` prefix. When you start a JSONPath expression with $, you are indicating that the path starts from the root of the JSON document. E.g.,
 
-```cpp
+```c++
 auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
 dom::parser parser;
 dom::element doc;
@@ -446,7 +428,7 @@ Error Handling
 All simdjson APIs that can fail return `simdjson_result<T>`, which is a &lt;value, error_code&gt;
 pair. You can retrieve the value with .get(), like so:
 
-```cpp
+```c++
 dom::element doc;
 auto error = parser.parse(json).get(doc);
 if (error) { cerr << error << endl; exit(1); }
@@ -480,7 +462,7 @@ We can write a "quick start" example where we attempt to parse the following JSO
 Our program loads the file, selects value corresponding to key "search_metadata" which expected to be an object, and then
 it selects the key "count" within that object.
 
-```cpp
+```C++
 #include <iostream>
 #include "simdjson.h"
 
@@ -508,7 +490,7 @@ triggering exceptions. To do this, we use `["statuses"].at(0)["id"]`. We break t
 
 Observe how we use the `at` method when querying an index into an array, and not the bracket operator.
 
-```cpp
+```C++
 #include <iostream>
 #include "simdjson.h"
 
@@ -532,7 +514,7 @@ over the content of an array.
 
 This is how the example in "Using the Parsed JSON" could be written using only error code checking:
 
-```cpp
+```c++
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -579,7 +561,7 @@ for (dom::element car_element : cars) {
 
 Here is another example:
 
-```cpp
+```C++
 auto abstract_json = R"( [
     {  "12345" : {"a":12.34, "b":56.78, "c": 9998877}   },
     {  "12545" : {"a":11.44, "b":12.78, "c": 11111111}  }
@@ -612,7 +594,7 @@ for (dom::element elem : array) {
 
 And another one:
 
-```cpp
+```C++
   auto abstract_json = R"(
     {  "str" : { "123" : {"abc" : 3.14 } } } )"_padded;
   dom::parser parser;
@@ -626,7 +608,7 @@ Notice how we can string several operations (`parser.parse(abstract_json)["str"]
 
 The next two functions will take as input a JSON document containing an array with a single element, either a string or a number. They return true upon success.
 
-```cpp
+```C++
 simdjson::dom::parser parser{};
 
 bool parse_double(const char *j, double &d) {
@@ -658,7 +640,7 @@ target_compile_definitions(simdjson PUBLIC SIMDJSON_EXCEPTIONS=OFF)
 
 Users more comfortable with an exception flow may choose to directly cast the `simdjson_result<T>` to the desired type:
 
-```cpp
+```c++
 dom::element doc = parser.parse(json); // Throws an exception if there was an error!
 ```
 
@@ -668,7 +650,7 @@ program from continuing if there was an error.
 
 If one is willing to trigger exceptions, it is possible to write simpler code:
 
-```cpp
+```C++
 #include <iostream>
 #include "simdjson.h"
 
@@ -689,7 +671,7 @@ inspect or walk over JSON elements. To do that, you can use iterators and the ty
 example, here's a quick and dirty recursive function that verbosely prints the JSON document as JSON
 (* ignoring nuances like trailing commas and escaping strings, for brevity's sake):
 
-```cpp
+```c++
 void print_json(dom::element element) {
   switch (element.type()) {
     case dom::element_type::ARRAY:
@@ -745,7 +727,7 @@ and reuse it. The simdjson library will allocate and retain internal buffers bet
 buffers hot in cache and keeping memory allocation and initialization to a minimum. In this manner,
 you can parse terabytes of JSON data without doing any new allocation.
 
-```cpp
+```c++
 dom::parser parser;
 
 // This initializes buffers and a document big enough to handle this JSON.
@@ -788,7 +770,7 @@ without bound:
 
 * You can set a *max capacity* when constructing a parser:
 
-  ```cpp
+  ```c++
   dom::parser parser(1000*1000); // Never grow past documents > 1MB
   for (web_request request : listen()) {
     dom::element doc;
@@ -804,7 +786,7 @@ without bound:
 * You can set a *fixed capacity* that never grows, as well, which can be excellent for
   predictability and reliability, since simdjson will never call malloc after startup!
 
-  ```cpp
+  ```c++
   dom::parser parser(0); // This parser will refuse to automatically grow capacity
   auto error = parser.allocate(1000*1000); // This allocates enough capacity to handle documents <= 1MB
   if (error) { cerr << error << endl; exit(1); }
@@ -835,7 +817,7 @@ When calling `parser.parse` on a pointer (e.g., `parser.parse(my_char_pointer, m
 Some users may not be able use our `padded_string` class or to load the data directly from disk (`parser.load`). They may need to pass data pointers to the library.  If these users wish to avoid temporary copies and corresponding temporary memory allocations, they may want to call `parser.parse` with the `realloc_if_needed` parameter set to false (e.g., `parser.parse(my_char_pointer, my_length_in_bytes, false)`). In such cases, they need to ensure that there are at least SIMDJSON_PADDING extra bytes at the end that can be safely accessed and read. They do not need to initialize the padded bytes to any value in particular. The following example is safe:
 
 
-```cpp
+```C++
 const char *json      = R"({"key":"value"})";
 const size_t json_len = std::strlen(json);
 std::unique_ptr<char[]> padded_json_copy{new char[json_len + SIMDJSON_PADDING]};
@@ -843,7 +825,7 @@ memcpy(padded_json_copy.get(), json, json_len);
 memset(padded_json_copy.get() + json_len, 0, SIMDJSON_PADDING);
 simdjson::dom::parser parser;
 simdjson::dom::element element = parser.parse(padded_json_copy.get(), json_len, false);
-```
+````
 
 Setting the `realloc_if_needed` parameter `false` in this manner may lead to better performance since copies are avoided, but it requires that the user takes more responsibilities: the simdjson library cannot verify that the input buffer was padded with SIMDJSON_PADDING extra bytes.
 

doc/implementation-selection.md

@@ -55,7 +55,7 @@ Inspecting the Detected Implementation
 
 You can check what implementation is running with `active_implementation`:
 
-```cpp
+```c++
 cout << "simdjson v" << SIMDJSON_VERSION << endl;
 cout << "Detected the best implementation for your machine: " << simdjson::get_active_implementation()->name();
 cout << "(" << simdjson::get_active_implementation()->description() << ")" << endl;
@@ -68,7 +68,7 @@ Querying Available Implementations
 
 You can list all available implementations, regardless of which one was selected:
 
-```cpp
+```c++
 for (auto implementation : simdjson::get_available_implementations()) {
   cout << implementation->name() << ": " << implementation->description() << endl;
 }
@@ -76,7 +76,7 @@ for (auto implementation : simdjson::get_available_implementations()) {
 
 And look them up by name:
 
-```cpp
+```c++
 cout << simdjson::get_available_implementations()["fallback"]->description() << endl;
 ```
 When an implementation is not available, the bracket call `simdjson::get_available_implementations()[name]`
@@ -93,7 +93,7 @@ Manually Selecting the Implementation
 If you're trying to do performance tests or see how different implementations of simdjson run, you
 can select the CPU architecture yourself:
 
-```cpp
+```c++
 // Use the fallback implementation, even though my machine is fast enough for anything
 simdjson::get_active_implementation() = simdjson::get_available_implementations()["fallback"];
 ```
@@ -102,7 +102,7 @@ You are responsible for ensuring that the requirements of the selected implement
 Furthermore, you should check that the implementation is available before setting it to `simdjson::get_active_implementation()`
 by comparing it with the null pointer.
 
-```cpp
+```c++
 auto my_implementation = simdjson::get_available_implementations()["haswell"];
 if (! my_implementation) { exit(1); }
 if (! my_implementation->supported_by_runtime_system()) { exit(1); }
@@ -114,7 +114,7 @@ Checking that an Implementation can Run on your System
 
 You should call `supported_by_runtime_system()` to compare the processor's features with the need of the implementation.
 
-```cpp
+```c++
 for (auto implementation : simdjson::get_available_implementations()) {
   if (implementation->supported_by_runtime_system()) {
     cout << implementation->name() << ": " << implementation->description() << endl;

doc/iterate_many.md

@@ -8,7 +8,7 @@ library provides high-speed access to files or streams containing multiple small
 {"text":"a"}
 {"text":"b"}
 {"text":"c"}
-"..."
+...
 ```
 ... you want to read the entries (individual JSON documents) as quickly and as conveniently as possible. Importantly, the input might span several gigabytes, but you want to use a small (fixed) amount of memory. Ideally, you'd also like the parallelize the processing (using more than one core) to speed up the process.
 
@@ -132,7 +132,7 @@ E.g., `[1,2]{"32":1}` is recognized as two documents.
 Some official formats **(non-exhaustive list)**:
 - [Newline-Delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec/)
 - [JSON lines (JSONL)](http://jsonlines.org/)
-- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by simdjson!
+- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by JsonStream!
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)
 
 API
@@ -140,10 +140,8 @@ API
 
 Example:
 
-```cpp
-//  R"( ... )" is a C++ raw string literal.
+```c++
 auto json = R"({ "foo": 1 } { "foo": 2 } { "foo": 3 } )"_padded;
-// _padded returns an simdjson::padded_string instance
 ondemand::parser parser;
 ondemand::document_stream docs = parser.iterate_many(json);
 for (auto doc : docs) {
@@ -199,7 +197,7 @@ and `error()` to check if there were any error.
 Let us illustrate the idea with code:
 
 
-```cpp
+```C++
     auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} [1,2,3]  )"_padded;
     simdjson::ondemand::parser parser;
     simdjson::ondemand::document_stream stream;
@@ -240,7 +238,7 @@ Some users may need to work with truncated streams. The simdjson may truncate do
 
 Consider the following example where a truncated document (`{"key":"intentionally unclosed string  `) containing 39 bytes has been left within the stream. In such cases, the first two whole documents are parsed and returned, and the `truncated_bytes()` method returns 39.
 
-```cpp
+```C++
     auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} {"key":"intentionally unclosed string  )"_padded;
     simdjson::ondemand::parser parser;
     simdjson::ondemand::document_stream stream;
@@ -269,7 +267,7 @@ is effectively ignored, as it is set to at least the document size.
 
 Example:
 
-```cpp
+```C++
     auto json = R"( 1, 2, 3, 4, "a", "b", "c", {"hello": "world"} , [1, 2, 3])"_padded;
     ondemand::parser parser;
     ondemand::document_stream doc_stream;
@@ -316,7 +314,7 @@ the simdjson library.
 
 Consider a custom class `Car`:
 
-```cpp
+```C++
 struct Car {
   std::string make;
   std::string model;
@@ -330,7 +328,7 @@ You may support deserializing directly from a JSON value or document to your own
 by defining a single `tag_invoke` function:
 
 
-```cpp
+```C++
 namespace simdjson {
 // This tag_invoke MUST be inside simdjson namespace
 template <typename simdjson_value>
@@ -372,7 +370,7 @@ tag_invoke functions.
 Given a stream of JSON documents, you can add them to a data structure
 such as a `std::vector<Car>` like so if you support exceptions:
 
-```cpp
+```C++
   padded_string json =
       R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
        "tire_pressure": [ 40.1, 39.9 ] }
@@ -393,7 +391,7 @@ such as a `std::vector<Car>` like so if you support exceptions:
 Otherwise you may use this longer version for explicit handling of errors:
 
 
-```cpp
+```C++
   std::vector<Car> cars;
   for(auto doc : stream) {
     Car c;
@@ -403,4 +401,4 @@ Otherwise you may use this longer version for explicit handling of errors:
     }
     cars.push_back(c);
   }
-```
+```

doc/ondemand_design.md

@@ -23,7 +23,7 @@ applications with a computation efficiency that is difficult to surpass.
 
 A code example illustrates our API from a programmer's point of view:
 
-```cpp
+```c++
 ondemand::parser parser;
 auto doc = parser.iterate(json);
 for (auto tweet : doc["statuses"]) {
@@ -109,7 +109,7 @@ The DOM approach was the only way to parse JSON documents up to version 0.6 of t
 Our DOM API looks similar to our On-Demand example, except
 it calls `parse` instead of `iterate`:
 
-```cpp
+```c++
 dom::parser parser;
 auto doc = parser.parse(json);
 for (auto tweet : doc["statuses"]) {
@@ -157,7 +157,7 @@ examples. To make it short enough to use as an example at all, it has heavily re
 a part of the problem (does not get user.screen_name), it has bugs (it does not handle sub-objects
 in a tweet at all), and it uses a theoretical, simple event-based API that minimizes ceremony.
 
-```cpp
+```c++
 struct twitter_callbacks {
   bool in_statuses;
   bool in_tweet;
@@ -284,14 +284,14 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
    This declaration does not allocate any memory; that will happen in the next step.
 
-   ```cpp
+   ```c++
    ondemand::parser parser;
    ```
 
 2. We then start iterating the JSON document by allocating internal parser buffers, preprocessing
    the JSON, and initializing the iterator.
 
-   ```cpp
+   ```c++
    auto doc = parser.iterate(json);
    ```
 
@@ -337,14 +337,14 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 3. We iterate over the "statuses" field using a typical C++ iterator, reading past the initial
    `{ "statuses": [ {`.
 
-   ```cpp
+   ```c++
    for (ondemand::object tweet : doc["statuses"]) {
    ```
 
    This shorthand does a lot, and it is helpful to see what it expands to.
    Comments in front of each one explain what's going on:
 
-   ```cpp
+   ```c++
    // Validate that the top-level value is an object: check for {. Increase depth to 2 (root > field).
    ondemand::object top = doc.get_object();
 
@@ -396,7 +396,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 4. We get the `"text"` field as a string.
 
-   ```cpp
+   ```c++
    std::string_view text        = tweet["text"];
    ```
 
@@ -435,7 +435,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 4. We get the `"screen_name"` from the `"user"` object.
 
-   ```cpp
+   ```c++
       ondemand::object user        = tweet["user"];
       screen_name                  = user["screen_name"];
    ```
@@ -469,7 +469,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 5. We get `"retweet_count"` as an unsigned integer.
 
-   ```cpp
+   ```c++
    uint64_t         retweets    = tweet["retweet_count"];
    ```
 
@@ -513,7 +513,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 6. We loop to the next tweet.
 
-   ```cpp
+   ```c++
    for (ondemand::object tweet : doc["statuses"]) {
      ...
    }
@@ -521,7 +521,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
    The relevant parts of the loop  are:
 
-   ```cpp
+   ```c++
    while (iter != statuses.end()) {
      ondemand::object tweet = *iter;
      ...
@@ -545,7 +545,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
      "statuses": [
        { "id": 1, "text": "first!", "user": { "screen_name": "lemire", "name": "Daniel" }, "retweet_count": 40 },
        { "id": 2, "text": "second!", "user": { "screen_name": "jkeiser2", "name": "John" }, "retweet_count": 3 }
-         ^ (depth 4 - root > statuses > tweet > field)
+                                                                                                               ^ (depth 3 - root > statuses > tweet)
      ],
      "search_metadata": { "count": 2 }
    }
@@ -566,7 +566,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 8. The loop ends. Recall the relevant parts of the statuses loop:
 
-   ```cpp
+   ```c++
    while (iter != statuses.end()) {
      ondemand::object tweet = *iter;
      ...
@@ -610,7 +610,7 @@ When the user requests strings, we unescape them to a single string buffer much
 so that users enjoy the same string performance as the core simdjson. We do not write the length to the
 string buffer, however; that is stored in the `string_view` instance we return to the user.
 
-```cpp
+```C++
   ondemand::parser parser;
   auto doc = parser.iterate(json);
   std::set<std::string_view> default_users;
@@ -645,7 +645,7 @@ from the `unescaped_key()` method has a lifecycle tied to the `parser` instance:
 is destroyed or reused with another document, the `std::string_view` instance becomes invalid.
 
 
-```cpp
+```C++
 auto doc = parser.iterate(json);
 for(auto field : doc.get_object())  {
       std::string_view keyv = field.unescaped_key();
@@ -670,11 +670,9 @@ in production systems:
   Some care is needed when using the On-Demand API in scenarios where you need to access several sibling arrays or objects because
   only one object or array can be active at any one time. Let us consider the following example:
 
-```cpp
+```C++
     ondemand::parser parser;
-    //  R"( ... )" is a C++ raw string literal.
     const padded_string json = R"({ "parent": {"child1": {"name": "John"} , "child2": {"name": "Daniel"}} })"_padded;
-    // _padded returns an simdjson padded_string instance
     auto doc = parser.iterate(json);
     ondemand::object parent = doc["parent"];
     // parent owns the focus
@@ -690,7 +688,7 @@ in production systems:
 
 A correct usage is given by the following example:
 
-```cpp
+```C++
     ondemand::parser parser;
     const padded_string json = R"({ "parent": {"child1": {"name": "John"} , "child2": {"name": "Daniel"}} })"_padded;
     auto doc = parser.iterate(json);
@@ -756,7 +754,7 @@ Some users wish to run at the best possible speed. Under recent Intel and AMD pr
 
 Given that the On-Demand API offer limited runtime dispatching, it matters that your code is compiled against a specific CPU target. You should verify that the code is compiled against the target you expect. Thankfully, the simdjson library will tell you exactly what it detects as an implementation: `icelake` (AVX512 x64 processors), `haswell` (AVX2 x64 processors), `westmere` (SSE4 x64 processors), `arm64` (64-bit ARM), `ppc64` (64-bit POWER), `lasx` (LoongArch), `lsx` (LoongArch),  `fallback` (others). Under x64 processors, many programmers will want to target `haswell` whereas under ARM, most programmers will want to target `arm64` (and it should do so automatically). The `fallback` is probably only good for testing purposes, not for deployment.
 
-```cpp
+```C++
   std::cout << simdjson::builtin_implementation()->name() << std::endl;
 ```
 

doc/parse_many.md

@@ -132,7 +132,7 @@ Whitespace Characters:
 Some official formats **(non-exhaustive list)**:
 - [Newline-Delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec)
 - [JSON lines (JSONL)](http://jsonlines.org/)
-- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by simdjson!
+- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by JsonStream!
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)
 
 API
@@ -184,7 +184,7 @@ You may also call the `source()` method to get a `std::string_view` instance on
 Let us illustrate the idea with code:
 
 
-```cpp
+```C++
     auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} [1,2,3]  )"_padded;
     simdjson::dom::parser parser;
     simdjson::dom::document_stream stream;
@@ -225,7 +225,7 @@ Some users may need to work with truncated streams. The simdjson may truncate do
 
 Consider the following example where a truncated document (`{"key":"intentionally unclosed string  `) containing 39 bytes has been left within the stream. In such cases, the first two whole documents are parsed and returned, and the `truncated_bytes()` method returns 39.
 
-```cpp
+```C++
     auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} {"key":"intentionally unclosed string  )"_padded;
     simdjson::dom::parser parser;
     simdjson::dom::document_stream stream;

doc/performance.md

@@ -47,7 +47,7 @@ and reuse it. The simdjson library will allocate and retain internal buffers bet
 buffers hot in cache and keeping memory allocation and initialization to a minimum. In this manner,
 you can parse terabytes of JSON data without doing any new allocation.
 
-```cpp
+```c++
 ondemand::parser parser;
 
 // This initializes buffers  big enough to handle this JSON.
@@ -71,14 +71,14 @@ Reusing string buffers
 
 We recommend against creating many `std::string` or `simdjson::padded_string` instances to store the JSON content in your application. [Creating many non-trivial objects is convenient but often surprisingly slow](https://lemire.me/blog/2020/08/08/performance-tip-constructing-many-non-trivial-objects-is-slow/). Instead, as much as possible, you should allocate (once or a few times) reusable memory buffers where you write your JSON content. If you have a buffer `json_str` (of type `char*`) allocated for  `capacity` bytes and you store a JSON document spanning `length` bytes, you can pass it to simdjson as follows:
 
-```cpp
+```c++
  auto doc = parser.iterate(padded_string_view(json_str, length, capacity));
 ```
 
 or simply
 
 
-```cpp
+```c++
  auto doc = parser.iterate(json_str, length, capacity);
 ```
 
@@ -89,7 +89,7 @@ Server Loops: Long-Running Processes and Memory Capacity
 The On-Demand approach also automatically expands its memory capacity when larger documents are parsed. However, for longer processes where very large files are processed (such as server loops), this capacity is not resized down. On-Demand also lets you adjust the maximal capacity that the parser can process:
 
 * You can set an upper bound (*max_capacity*) when construction the parser:
-```cpp
+```C++
     ondemand::parser parser(1000*1000);  // Never grows past documents > 1 MB
     auto doc = parser.iterate(json);
     for (web_request request : listen()) {
@@ -105,7 +105,7 @@ The On-Demand approach also automatically expands its memory capacity when large
 The capacity will grow as the parser encounters larger documents up to 1 MB.
 
 * You can also allocate a *fixed capacity* that will never grow:
-```cpp
+```C++
     ondemand::parser parser(1000*1000);
     parser.allocate(1000*1000)  // Fix the capacity to 1 MB
     auto doc = parser.iterate(json);
@@ -253,7 +253,7 @@ long page_size() {
 // page boundary.
 bool need_allocation(const char *buf, size_t len) {
   return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
-    + simdjson::SIMDJSON_PADDING >= static_cast<uintptr_t>(page_size()));
+    + simdjson::SIMDJSON_PADDING > static_cast<uintptr_t>(page_size()));
 }
 
 simdjson::padded_string_view

fuzz/fuzz_minify.cpp

@@ -8,12 +8,17 @@
  * Minifies by first parsing, then minifying.
  */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
-    simdjson::padded_string str(reinterpret_cast<const char *>(Data), Size);
+
+    auto begin = as_chars(Data);
+    auto end = begin + Size;
+
+    std::string str(begin, end);
     simdjson::dom::parser parser;
     simdjson::dom::element elem;
     auto error = parser.parse(str).get(elem);
     if (error) { return 0; }
-    std::string minified = simdjson::minify(elem);
+
+    std::string minified=simdjson::minify(elem);
     (void)minified;
     return 0;
 }

include/simdjson.h

@@ -55,9 +55,4 @@
 #include "simdjson/ondemand.h"
 #include "simdjson/convert.h"
 #include "simdjson/convert-inl.h"
-
-// Compile-time JSON parsing (C++26 P2996 reflection)
-#include "simdjson/compile_time_json.h"
-#include "simdjson/compile_time_json-inl.h"
-
 #endif // SIMDJSON_H

include/simdjson/arm64/stringparsing_defs.h

@@ -17,7 +17,7 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 32;
-  simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
+  simdjson_inline static backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
   simdjson_inline bool has_backslash() { return bs_bits != 0; }

include/simdjson/base.h

@@ -10,7 +10,6 @@
 #include "simdjson/error.h"
 #include "simdjson/portability.h"
 #include "simdjson/concepts.h"
-#include "simdjson/constevalutil.h"
 
 /**
  * @brief The top level simdjson namespace, containing everything the library provides.

include/simdjson/compile_time_json.h

@@ -1,75 +0,0 @@
-/**
- * @file compile_time_json.h
- * @brief Compile-time JSON parsing using C++26 reflection with
- * std::meta::substitute()
- */
-
-#ifndef SIMDJSON_GENERIC_COMPILE_TIME_JSON_H
-#define SIMDJSON_GENERIC_COMPILE_TIME_JSON_H
-
-#if SIMDJSON_STATIC_REFLECTION
-
-#include <algorithm>
-#include <array>
-#include <charconv>
-#include <cstdint>
-#include <expected>
-#include <meta>
-#include <string>
-#include <string_view>
-#include <vector>
-
-namespace simdjson {
-namespace compile_time {
-
-/**
- * @brief Compile-time JSON parser. This function parses the provided JSON
- * string at compile time and returns a custom struct type representing the JSON
- * object.
- *
- * We have a few limitations which trigger compile-time errors if violated:
- * - Only JSON objects and arrays are supported at the top level (no primitives).
- *   We will lift this limitation in the future.
- * - Strings are represented using the const char * in UTF-8, but they must not
- *   contain embedded nulls. We would prefer to represent them as std::string or
- *   std::string_view, and hope to do so in the future.
- * - Heterogeneous arrays are not supported yet. E.g., you need to have arrays of
- *   all integers, or all strings, all floats, all compatible objects, etc.
- *   For example, the following is accepted:
- *    [
- *     { "name": "Alice", "age": 30 },
- *     { "name": "Bob", "age": 25 },
- *     { "name": "Charlie", "age": 35 }
- *   ]
- *   but the following is not:
- *   [
- *     { "name": "Alice", "age": 30 },
- *     "Just a string",
- *     42,
- *     { "name": "Charlie", "age": 35 }
- *   ]
- *
- *    We may support heterogeneous arrays in the future with std::variant types.
- * - We parse the first JSON document encountered in the string. Trailing
- *   characters are ignored. Thus if your JSON begins with {"a":1}, everything
- *   after the closing } is ignored. This limitation will be lifted in the future,
- *   reporting an error.
- *
- * These limitations are safe in the sense that they result in compile-time errors.
- * Thus you will not get truncated strings or imprecise floats silently.
- *
- * This function is subject to change in the future.
- */
-template <constevalutil::fixed_string json_str> consteval auto parse_json();
-
-} // namespace compile_time
-} // namespace simdjson
-
-
-template <simdjson::constevalutil::fixed_string str>
-consteval auto operator ""_json() {
-  return simdjson::compile_time::parse_json<str>();
-}
-
-#endif // SIMDJSON_STATIC_REFLECTION
-#endif // SIMDJSON_GENERIC_COMPILE_TIME_JSON_H