documenting C++26 usage with iterate_many

* finishing up the new streaming

* fixed silly warnings.

* tweak

* adding more tests

* minor fixes

* more fixes

.appveyor.yml

@@ -1,29 +1,56 @@
 version: '{build}'
-branches:
+branches: { only: [ master ] }
-  only:
+configuration: Release
-  - master
+image: Visual Studio 2019
-image:
+platform: x64
-    - Visual Studio 2017
-clone_folder: c:\projects\simdjson
 
-platform:
+cache:
-- x64
+  - C:\dependencies -> dependencies\CMakeLists.txt
 
 environment:
+  # Forward slash is used because this is used in CMake as is
+  simdjson_DEPENDENCY_CACHE_DIR: C:/dependencies
+
   matrix:
-    - SIMDJSON_BUILD_STATIC: "OFF"
+    - job_name: VS2019
-      THREADS: "ON"
+      CMAKE_ARGS: -A %Platform%
-    - SIMDJSON_BUILD_STATIC: "OFF"
+    - job_name: VS2019ARM
-      THREADS: "OFF"
+      CMAKE_ARGS: -A ARM64   -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_CROSSCOMPILING=1 -D SIMDJSON_GOOGLE_BENCHMARKS=OFF # Does Google Benchmark builds under VS ARM?
-    - SIMDJSON_BUILD_STATIC: "ON"
+    - job_name: VS2017 (Static, No Threads)
-      THREADS: "ON"
+      image: Visual Studio 2017
-#    - SIMDJSON_BUILD_STATIC: "ON"
+      CMAKE_ARGS: -A %Platform%   -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_ENABLE_THREADS=OFF
-#      THREADS: "OFF"
+      CTEST_ARGS: -LE explicitonly
+    - job_name: VS2019 (Win32)
+      platform: Win32
+      CMAKE_ARGS: -A %Platform%   -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=ON -DSIMDJSON_ENABLE_THREADS=ON # This should be the default. Testing anyway.
+      CTEST_ARGS: -LE explicitonly
+    - job_name: VS2019 (Win32, No Exceptions)
+      platform: Win32
+      CMAKE_ARGS: -A %Platform%   -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=ON -DSIMDJSON_ENABLE_THREADS=ON -DSIMDJSON_EXCEPTIONS=OFF
+      CTEST_ARGS: -LE explicitonly
+    - job_name: VS2015
+      image: Visual Studio 2015
+      CMAKE_ARGS: -A %Platform%   -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_ENABLE_THREADS=OFF
+      CTEST_ARGS: -LE explicitonly
 
 build_script:
   - mkdir build
   - cd build
-  - ps: cmake -DSIMDJSON_BUILD_STATIC="$env:SIMDJSON_BUILD_STATIC" -DSIMDJSON_ENABLE_THREADS="$env:THREADS" -DCMAKE_BUILD_TYPE=Release -DCMAKE_GENERATOR_PLATFORM=x64 -DSIMDJSON_GOOGLE_BENCHMARKS=OFF ..
+  - cmake --version
-  - cmake --build .
+  - cmake %CMAKE_ARGS% ..
-  - ctest --verbose --output-on-failure
+  - cmake -LH ..
+  - cmake --build . --config %Configuration% --verbose --parallel
 
+for:
+-
+  matrix:
+    except:
+      - job_name: VS2019ARM
+
+  test_script:
+    - ctest --output-on-failure -C %Configuration% --verbose %CTEST_ARGS% --parallel
+
+clone_folder: c:\projects\simdjson
+
+matrix:
+  fast_finish: true

.circleci/config.yml

@@ -1,226 +0,0 @@
-version: 2.1
-
-# Reusable image / compiler definitions
-executors:
-  gcc7:
-    docker:
-      - image: gcc:7
-        environment:
-          CXX: g++
-  gcc8:
-    docker:
-      - image: gcc:8
-        environment:
-          CXX: g++
-  gcc9:
-    docker:
-      - image: gcc:9
-        environment:
-          CXX: g++
-  clang6:
-    docker:
-      - image: ubuntu:18.04
-        environment:
-          CXX: clang++-6.0
-
-# Reusable test commands (and initializer for clang 6)
-commands:
-  init_clang6:
-    steps:
-      - run: apt-get update -qq
-      - run: apt-get install -y clang build-essential git
-  make_test:
-    steps:
-      - checkout
-      - run: make
-      - run: make amalgamate
-      - run: ARCHFLAGS=-march=haswell make amalgamate # some users do this: https://github.com/lemire/simdjson/issues/444
-      - run: make test
-      - run: make checkperf
-      - run: make clean
-      - run: ARCHFLAGS=-march=haswell make test # this breaks runtime dispatch, but see https://github.com/lemire/simdjson/issues/444... this is a code robustness test
-      - run: make clean
-      - run: EXTRAFLAGS=-DSIMDJSON_NO_COMPUTED_GOTO=true make test # this should run tests with computed gotos disabled
-  make_test_strict: # this version fails when a warning is detected.
-    steps:
-      - checkout
-      - run: EXTRAFLAGS=-Werror make
-      - run: EXTRAFLAGS=-Werror make amalgamate
-      - run: ARCHFLAGS=-march=haswell make amalgamate # some users do this: https://github.com/lemire/simdjson/issues/444
-      - run: EXTRAFLAGS=-Werror make quicktests
-      - run: make clean
-  
-  cmake_simple_test: # this version just builds and test
-    steps:
-      - run: apt-get update -qq
-      - run: apt-get install -y cmake
-      - checkout
-      - run: cmake $CMAKE_TEST_FLAGS
-      - run: make all
-      - run: make test
-
-  cmake_test: # this version builds, install, test and then verifyi from the installation
-    steps:
-      - run: apt-get update -qq
-      - run: apt-get install -y cmake
-      - checkout
-      - run: cmake $CMAKE_TEST_FLAGS  -DCMAKE_INSTALL_PREFIX:PATH=destination
-      - run: make all install
-      - run: make test
-      - 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++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json # we not only want cmake to build and run tests, but we want also a succesful installation from which we can build, link and run programs
-
-jobs:
-
-  gcc-avx-unthreaded:
-    description: Build, run tests and check performance on GCC 7 and AVX 2 *without* threads
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
-    steps: [ cmake_test ]
-  gcc-avx-threaded:
-    description: Build, run tests and check performance on GCC 7 and AVX 2 with threads
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_ENABLE_THREADS=ON }
-    steps: [ cmake_test ]
-
-  clang-avx-unthreaded:
-    description: Build, run tests and check performance on Clang 6 and AVX 2 *without* threads
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
-    steps: [ init_clang6, cmake_test ]
-  clang-avx-threaded:
-    description: Build, run tests and check performance on Clang 6 and AVX 2 with threads
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_ENABLE_THREADS=ON }
-    steps: [ init_clang6, cmake_test ]
-
-  gcc9-avx:
-    description: Build, run tests and check performance on GCC 9 and AVX 2
-    executor: gcc9
-    steps: [ make_test_strict ]
-  gcc8-avx:
-    description: Build, run tests and check performance on GCC 8 and AVX 2
-    executor: gcc9
-    steps: [ make_test_strict ]
-  gcc-avx:
-    description: Build, run tests and check performance on GCC 7 and AVX 2
-    executor: gcc7
-    steps: [ make_test ]
-  gcc-avx-dynamic:
-    description: Build, run tests and check performance on GCC 7 and AVX 2 with a cmake dynamic build
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF }
-    steps: [ cmake_test ]
-  gcc-avx-static:
-    description: Build, run tests and check performance on GCC 7 and AVX 2 with a cmake static build
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=ON }
-    steps: [ cmake_test ]
-  gcc-avx-google-benchmarks:
-    description: Build, run tests and check performance on GCC 7 with google benchmarks enabled
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON }
-    steps: [ cmake_test ]
-  gcc-avx-sanitize:
-    description: Build, run tests and check performance on GCC 7 and AVX 2 with a cmake sanitize build
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON }
-    steps: [ cmake_simple_test ]
-
-  gcc-sse:
-    description: Build, run tests and check performance on GCC 7 and SSE 4.2
-    executor: gcc7
-    environment: { ARCHFLAGS: -march=nehalem }
-    steps: [ make_test ]
-  gcc-sse-dynamic:
-    description: Build, run tests and check performance on GCC 7 and SSE 4.2 with a cmake dynamic build
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF }
-    steps: [ cmake_test ]
-  gcc-sse-static:
-    description: Build, run tests and check performance on GCC 7 and SSE 4.2 with a cmake static build
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=ON }
-    steps: [ cmake_test ]
-  gcc-sse-sanitize:
-    description: Build, run tests and check performance on GCC 7 and SSE 4.2 with a cmake sanitize build
-    executor: gcc7
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON }
-    steps: [ cmake_simple_test ]
-
-  clang-avx:
-    description: Build, run tests and check performance on clang 6 and AVX 2
-    executor: clang6
-    steps: [ init_clang6, make_test ]
-  clang-avx-dynamic:
-    description: Build, run tests and check performance on clang 6 and AVX 2 with a cmake dynamic build
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF }
-    steps: [ init_clang6, cmake_test ]
-  clang-avx-static:
-    description: Build, run tests and check performance on clang 6 and AVX 2 with a cmake static build
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=ON }
-    steps: [ init_clang6, cmake_test ]
-  clang-avx-google-benchmarks:
-    description: Build, run tests and check performance on clang 6 with google benchmarks enabled
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON }
-    steps: [ init_clang6, cmake_test ]
-  clang-avx-sanitize:
-    description: Build, run tests and check performance on clang 6 and AVX 2 with a cmake sanitize build
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON }
-    steps: [ init_clang6, cmake_simple_test ]
-
-  clang-sse:
-    description: Build, run tests and check performance on Clang 6 and SSE 4.2
-    executor: clang6
-    environment: { ARCHFLAGS: -march=nehalem }
-    steps: [ init_clang6, make_test ]
-  clang-sse-dynamic:
-    description: Build, run tests and check performance on Clang 6 and SSE 4.2 with a cmake dynamic build
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF }
-    steps: [ init_clang6, cmake_test ]
-  clang-sse-static:
-    description: Build, run tests and check performance on Clang 6 and SSE 4.2 with a cmake static build
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=ON }
-    steps: [ init_clang6, cmake_test ]
-  clang-sse-sanitize:
-    description: Build, run tests and check performance on Clang 6 and SSE 4.2 with a cmake sanitize build
-    executor: clang6
-    environment: { CMAKE_TEST_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF -DSIMDJSON_SANITIZE=ON }
-    steps: [ init_clang6, cmake_simple_test ]
-
-workflows:
-  version: 2.1
-  build_and_test:
-    jobs:
-      - gcc9-avx
-      - gcc8-avx
-      - gcc-avx
-      - gcc-avx-dynamic
-      - gcc-avx-static
-      - gcc-avx-google-benchmarks
-      - gcc-avx-sanitize
-      - gcc-sse
-      - gcc-sse-dynamic
-      - gcc-sse-static
-      - gcc-sse-sanitize
-      - clang-avx
-      - clang-avx-dynamic
-      - clang-avx-static
-      - clang-avx-google-benchmarks
-      - clang-avx-sanitize
-      - clang-sse
-      - clang-sse-dynamic
-      - clang-sse-static
-      - clang-sse-sanitize
-      - gcc-avx-threaded
-      - gcc-avx-unthreaded
-      - clang-avx-threaded
-      - clang-avx-unthreaded
-
-      # TODO add windows: https://circleci.com/docs/2.0/configuration-reference/#windows
-

.cirrus.yml

@@ -0,0 +1,26 @@
+task:
+  timeout_in: 120m
+  freebsd_instance:
+    matrix:
+      - image_family: freebsd-13-0-snap
+
+  env:
+    ASSUME_ALWAYS_YES: YES
+    simdjson_DEPENDENCY_CACHE_DIR: $HOME/.dep_cache
+  dep_cache:
+    folder: $HOME/.dep_cache
+    reupload_on_changes: false
+    fingerprint_script: cat dependencies/CMakeLists.txt
+  setup_script:
+    - pkg update -f
+    - pkg install bash
+    - pkg install cmake
+    - pkg install git
+  build_script:
+    - mkdir build
+    - cd build
+    - cmake -DSIMDJSON_BASH=OFF  -DSIMDJSON_GIT=OFF ..
+    - make
+  test_script:
+    - cd build
+    - ctest --output-on-failure -LE explicitonly

.clangd

@@ -0,0 +1,47 @@
+CompileFlags:
+    CompilationDatabase: build
+    Add:
+        - -Werror -Wall -Wextra -Weffc++ -Wsign-compare -Wshadow -Wwrite-strings -Wpointer-arith -Winit-self -Wconversion -Wno-sign-conversion
+        - -Wundefined-inline
+Diagnostics:
+    Suppress:
+        - misc-unused-alias-decls
+        - misc-unused-using-decls
+        - misc-definitions-in-headers # TODO fix and remove these violations
+---
+If:
+    PathMatch:
+        - include/.*
+        - src/.*
+    PathExclude:
+        - include/simdjson.h
+        - src/simdjson.cpp
+CompileFlags:
+    Add:
+        - -Wno-unneeded-internal-declaration
+        - -Wno-undefined-internal # TODO fix and remove these violations
+        - -Wno-unused-function
+        - -Wno-unused-const-variable
+Diagnostics:
+    Suppress:
+        - pp_including_mainfile_in_preamble
+        - unused-includes
+---
+# Amalgamated files that require or partly define an implementation
+If:
+    PathMatch:
+        - .*/(arm64|fallback|haswell|icelake|ppc64|westmere)/begin.h
+        - .*/generic/.*
+Diagnostics:
+    Suppress:
+        - pragma_attribute_no_pop_eof
+---
+# clang has a bad time detecting the push/pop together in src/ for some reason
+If:
+    PathMatch:
+        - include/simdjson/.*/end.h
+        - src/(arm64|fallback|haswell|icelake|ppc64|westmere).cpp
+Diagnostics:
+    Suppress:
+        - pragma_attribute_no_pop_eof
+        - pragma_attribute_stack_mismatch

.dockerignore

@@ -1,7 +1,7 @@
 *
 !.git
 !Makefile
-!amalgamation.sh
+!amalgamate.py
 !benchmark
 !dependencies
 !include

.drone.yml

@@ -1,207 +1,420 @@
 kind: pipeline
-name: x64-quicktests-libc
+name: gcc9
-
+platform: { os: linux, arch: amd64 }
-platform:
-  os: linux
-  arch: amd64
-
 steps:
-- name: quicktests
+- name: Build and Test
-  image: conanio/clang8
+  image: gcc:9
+  environment:
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_IMPLEMENTATION=icelake;haswell;westmere;fallback
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
+    - apt-get update -qq
+    - apt-get -t buster-backports install -y cmake
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS -L acceptance -LE per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=icelake ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=haswell ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=westmere ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation
+    - ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
+---
+kind: pipeline
+name: clang6
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: conanio/clang60
   user: root
-  commands: [ EXTRAFLAGS=-stdlib=libc++ make quicktests ]
+  environment:
+    CC: clang-6.0
+    CXX: clang++-6.0
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_IMPLEMENTATION=icelake;haswell;westmere;fallback
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+  commands:
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS -L acceptance -LE per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=icelake ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=haswell ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=westmere ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation
+    - ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
 ---
 kind: pipeline
-name: x64-quicktests
+name: dynamic-gcc9
-
+platform: { os: linux, arch: amd64 }
-platform:
-  os: linux
-  arch: amd64
-
 steps:
-- name: quicktests
+- name: Build and Test
-  image: gcc:8
+  image: gcc:9
-  commands: [ make quicktests ]
+  environment:
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
+    - apt-get update -qq
+    - apt-get -t buster-backports install -y cmake
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
 ---
 kind: pipeline
-name: x64-checkperf
+name: dynamic-clang9
-
+platform: { os: linux, arch: amd64 }
-platform:
-  os: linux
-  arch: amd64
-
 steps:
-- name: checkperf
+- name: Build and Test
+  image: conanio/clang9
+  user: root
+  environment:
+    CC: clang-9
+    CXX: clang++-9
+    CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON
+    BUILD_FLAGS: -- -j
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+  commands:
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
+---
+kind: pipeline
+name: sanitize-gcc9
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: gcc:9
+  environment:
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_IMPLEMENTATION=icelake;haswell;westmere;fallback
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
+    - apt-get update -qq
+    - apt-get -t buster-backports install -y cmake
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L acceptance -LE per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=icelake ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=haswell ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=westmere ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=fallback ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
+---
+kind: pipeline
+name: sanitize-clang9
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: conanio/clang9
+  user: root
+  environment:
+    CC: clang-9
+    CXX: clang++-9
+    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON -DSIMDJSON_IMPLEMENTATION=icelake;haswell;westmere;fallback
+    BUILD_FLAGS: -- -j
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+  commands:
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L acceptance -LE per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=icelake ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=haswell ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=westmere ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=fallback ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
+---
+kind: pipeline
+name: cpp20-clang11-libcpp
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: pauldreik/llvm-11
+  user: root
+  environment:
+    CC: clang-11
+    CXX: clang++-11
+    CMAKE_FLAGS: -GNinja
+    BUILD_FLAGS:
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+    CXXFLAGS: -std=c++20 -stdlib=libc++
+  commands:
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
+---
+kind: pipeline
+name: arm64-gcc8
+platform: { os: linux, arch: arm64 }
+steps:
+- name: Build and Test
   image: gcc:8
   environment:
-    CHECKPERF_REPOSITORY: https://github.com/lemire/simdjson
+    CC: gcc
-  commands: [ sed '/^$/Q' /proc/cpuinfo, make checkperf ]
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_IMPLEMENTATION=arm64;fallback
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
+    - apt-get update -qq
+    - apt-get -t buster-backports install -y cmake
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS -L acceptance -LE per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=arm64 ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation
+    - ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
 ---
 kind: pipeline
-name: x64-build
+name: arm64-clang6
-
+platform: { os: linux, arch: arm64 }
-platform:
-  os: linux
-  arch: amd64
-
 steps:
-- name: build
+- name: Build and Test
-  image: gcc:8
+  image: debian:buster-backports
-  commands: [ make, make amalgamate ]
+  environment:
+    CC: clang-6.0
+    CXX: clang++-6.0
+    CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON
+    BUILD_FLAGS: -- -j
+    CTEST_FLAGS: -j4 --output-on-failure  -LE explicitonly
+  commands:
+    - apt-get -qq update
+    - apt-get -t buster-backports install -y cmake
+    - apt-get install -y clang-6.0 git
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
 ---
 kind: pipeline
-name: x64-slowtests
+name: arm64-dynamic-gcc8
-
+platform: { os: linux, arch: arm64 }
-platform:
-  os: linux
-  arch: amd64
-
 steps:
-- name: slowtests
+- name: Build and Test
-  image: gcc:8
-  commands: [ make slowtests ]
----
-kind: pipeline
-name: x64-noexceptions-quicktests
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: quicktests
   image: gcc:8
   environment:
-    EXTRA_FLAGS: -fno-exceptions
+    CC: gcc
-  commands: [ make quicktests ]
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
+    - apt-get update -qq
+    - apt-get -t buster-backports install -y cmake
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
 ---
 kind: pipeline
-name: x64-noexceptions-build
+name: arm64-dynamic-clang6
-
+platform: { os: linux, arch: arm64 }
-platform:
-  os: linux
-  arch: amd64
-
 steps:
-- name: build
+- name: Build and Test
+  image: debian:buster-backports
+  environment:
+    CC: clang-6.0
+    CXX: clang++-6.0
+    CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON
+    BUILD_FLAGS: -- -j
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+  commands:
+    - apt-get -qq update
+    - apt-get -t buster-backports install -y cmake
+    - apt-get install -y clang-6.0 git
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
+---
+kind: pipeline
+name: arm64-sanitize-gcc8
+platform: { os: linux, arch: arm64 }
+steps:
+- name: Build and Test
   image: gcc:8
   environment:
-    EXTRA_FLAGS: -fno-exceptions
+    BUILD_FLAGS: -- -j
-  commands: [ make, make amalgamate ]
+    CMAKE_FLAGS: -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_IMPLEMENTATION=arm64;fallback
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+    CC: gcc
+    CXX: g++
+  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
+    - apt-get update -qq
+    - apt-get -t buster-backports install -y cmake
+    - apt-get install -y libstdc++6
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L acceptance -LE per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=arm64 ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=fallback ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
 ---
 kind: pipeline
-name: x64-noexceptions-slowtests
+name: arm64-sanitize-clang6
-
+platform: { os: linux, arch: arm64 }
-platform:
-  os: linux
-  arch: amd64
-
 steps:
-- name: slowtests
+- name: Build and Test
-  image: gcc:8
+  image: debian:buster-backports
   environment:
-    EXTRA_FLAGS: -fno-exceptions
+    CC: clang-6.0
-  commands: [ make slowtests ]
+    CXX: clang++-6.0
+    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON -DSIMDJSON_IMPLEMENTATION=arm64;fallback
+    BUILD_FLAGS: -- -j
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+  commands:
+    - apt-get -qq update
+    - apt-get -t buster-backports install -y cmake
+    - apt-get install -y clang-6.0 git
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L acceptance -LE per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=arm64 ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - SIMDJSON_FORCE_IMPLEMENTATION=fallback ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -L per_implementation
+    - ASAN_OPTIONS="detect_leaks=0" ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
 ---
 kind: pipeline
-name: arm64-quicktests
+name: ninja-clang9
-
+platform: { os: linux, arch: amd64 }
-platform:
-  os: linux
-  arch: arm64
-
 steps:
-- name: quicktests
+- name: Build and Test
-  image: gcc:8
+  image: conanio/clang9
-  commands: [ make quicktests ]
+  user: root
----
-kind: pipeline
-name: arm64-checkperf
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: checkperf
-  image: gcc:8
   environment:
-    CHECKPERF_REPOSITORY: https://github.com/lemire/simdjson
+    CC: clang-9
-  commands: [ cat /proc/cpuinfo, make checkperf ]
+    CXX: clang++-9
+    BUILD_FLAGS: -- -j 4
+    CMAKE_FLAGS: -GNinja -DBUILD_SHARED_LIBS=OFF
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+    CXXFLAGS: -stdlib=libc++
+  commands:
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
 ---
 kind: pipeline
-name: arm64-build
+name: libcpp-clang9
-
+platform: { os: linux, arch: amd64 }
-platform:
-  os: linux
-  arch: arm64
-
 steps:
-- name: build
+- name: Build and Test
-  image: gcc:8
+  image: conanio/clang9
-  commands: [ make, make amalgamate ]
+  user: root
----
-kind: pipeline
-name: arm64-slowtests
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: slowtests
-  image: gcc:8
-  commands: [ make slowtests ]
----
-kind: pipeline
-name: x64-amalgamated-build
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: build
-  image: gcc:8
   environment:
-    SIMDJSON_TEST_AMALGAMATED_HEADERS: 1
+    CC: clang-9
-  commands: [ make amalgamate, make ]
+    CXX: clang++-9
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DBUILD_SHARED_LIBS=OFF
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+    CXXFLAGS: -stdlib=libc++
+  commands:
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
 ---
 kind: pipeline
-name: x64-amalgamated-quicktests
+name: libcpp-clang7
-
+platform: { os: linux, arch: amd64 }
-platform:
-  os: linux
-  arch: amd64
-
 steps:
-- name: quicktests
+- name: Build and Test
-  image: gcc:8
+  image: conanio/clang7
+  user: root
   environment:
-    SIMDJSON_TEST_AMALGAMATED_HEADERS: 1
+    CC: clang-7
-  commands: [ make amalgamate, make quicktests ]
+    CXX: clang++-7
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DBUILD_SHARED_LIBS=OFF
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+    CXXFLAGS: -stdlib=libc++
+  commands:
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
 ---
 kind: pipeline
-name: x64-amalgamated-slowtests
+name: noexceptions-gcc9
-
+platform: { os: linux, arch: amd64 }
-platform:
-  os: linux
-  arch: amd64
-
 steps:
-- name: slowtests
+- name: Build and Test
-  image: gcc:8
+  image: gcc:9
   environment:
-    SIMDJSON_TEST_AMALGAMATED_HEADERS: 1
+    CC: gcc
-  commands: [ make amalgamate, make slowtests ]
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly
+  commands:
+    - echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
+    - apt-get update -qq
+    - apt-get -t buster-backports install -y cmake
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS
+---
+kind: pipeline
+name: arm64-fuzz
+platform: { os: linux, arch: arm64 }
+steps:
+- name: Build and run fuzzers shortly
+  image: ubuntu:20.04
+  environment:
+    CC: clang
+    CXX: clang++
+    DEBIAN_FRONTEND: noninteractive
+    ASAN_OPTIONS: detect_leaks=0
+  commands:
+    - apt-get -qq update
+    - apt-get install -q -y clang cmake git wget zip ninja-build
+    - wget -O corpus.tar.gz https://readonly:readonly@www.pauldreik.se/fuzzdata/index.php?project=simdjson
+    - tar xf corpus.tar.gz && rm corpus.tar.gz
+    - fuzz/build_like_ossfuzz.sh
+    - mkdir -p common_out
+    - for fuzzer in build/fuzz/fuzz_* ; do echo $fuzzer;$fuzzer common_out out/* -max_total_time=40; done
 ---
 kind: pipeline
 name: stylecheck
-
+platform: { os: linux, arch: amd64 }
-platform:
-  os: linux
-  arch: amd64
-
 steps:
 - name: Build and Test
   image: ubuntu:18.04
@@ -209,350 +422,3 @@ steps:
     - apt-get update -y
     - apt-get install -y python clang-format
     - ./style/run-clang-format.py -r include/ benchmark/ src/ tests/
----
-kind: pipeline
-name: amd64_clang_cmake_dynamic
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
-  commands:
-    - apt-get update -qq
-    - apt-get install -y clang make cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
----
-  kind: pipeline
-  name: amd64_clang_cmake_no_exceptions
-  
-  platform:
-    os: linux
-    arch: amd64
-  
-  steps:
-  - name: Build and Test
-    image: ubuntu:18.04
-    environment:
-      CC: clang
-      CXX: clang++
-      CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
-    commands:
-      - apt-get update -qq
-      - apt-get install -y clang make cmake
-      - $CC --version
-      - mkdir build && cd build
-      - cmake $CMAKE_FLAGS ..
-      - make -j
-      - ctest --output-on-failure
-kind: pipeline
-name: amd64_clang_cmake_static
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y clang make cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
----
-kind: pipeline
-name: amd64_gcc_cmake_static
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake 
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
----
-kind: pipeline
-name: amd64_gcc_cmake_dynamic
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
----
-kind: pipeline
-name: arm64_clang_cmake_dynamic
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
-  commands:
-    - apt-get update -qq
-    - apt-get install -y clang make cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
----
-kind: pipeline
-name: arm64_gcc_cmake_dynamic
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
----
-kind: pipeline
-name: arm64_clang_cmake_static
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y clang make cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
----
-kind: pipeline
-name: arm64_gcc_cmake_static
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ctest --output-on-failure
-
----
-kind: pipeline
-name: arm64_clang_cmake_sanitize
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y clang make cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ASAN_OPTIONS="detect_leaks=0" ctest --output-on-failure
----
-kind: pipeline
-name: arm64_gcc_cmake_sanitize
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ASAN_OPTIONS="detect_leaks=0" ctest --output-on-failure
-
----
-kind: pipeline
-name: amd64_clang_cmake_sanitize
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON
-  commands:
-    - apt-get update -y
-    - apt-get install -y make $CC g++ cmake 
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ASAN_OPTIONS="detect_leaks=0" ctest --output-on-failure
----
-kind: pipeline
-name: amd64_gcc_cmake_sanitize
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ASAN_OPTIONS="detect_leaks=0" ctest --output-on-failure
-
----
-kind: pipeline
-name: amd64_clang_cmake_sanitize_noavx
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: Build and Test
-  image: ubuntu:18.04
-  environment:
-    CC: clang
-    CXX: clang++
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON -DSIMDJSON_IMPLEMENTATION_HASWELL=OFF
-  commands:
-    - apt-get update -qq
-    - apt-get install -y clang make cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ASAN_OPTIONS="detect_leaks=0" ctest --output-on-failure
----
-kind: pipeline
-name: amd64_gcc_cmake_sanitize_noavx
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: Build and Test
-  image: gcc:8
-  environment:
-    CC: gcc
-    CXX: g++
-    CMAKE_FLAGS: -DSIMDJSON_SANITIZE=ON -DSIMDJSON_IMPLEMENTATION_HASWELL=OFF
-  commands:
-    - apt-get update -qq
-    - apt-get install -y cmake
-    - $CC --version
-    - mkdir build && cd build
-    - cmake $CMAKE_FLAGS ..
-    - make -j
-    - ASAN_OPTIONS="detect_leaks=0" ctest --output-on-failure

.editorconfig

@@ -0,0 +1,12 @@
+# https://editorconfig.org/
+root = true
+# Conservatively avoid changing defaults for other file types, e.g. raw json files for test cases,
+# Makefiles, etc.
+[*.{cpp,h,md}]
+charset                  = utf-8
+end_of_line              = lf
+indent_size              = 2
+indent_style             = space
+insert_final_newline     = true
+tab_width                = 2
+trim_trailing_whitespace = true

.gitattributes

@@ -3,7 +3,7 @@
 * text=auto
 
 # we don't want json files to be modified for this project
-*.json binary 
+*.json binary diff=astextplain
 
 
 # Common settings that generally should always be used with your language specific settings
@@ -78,17 +78,18 @@
 
 .gitattributes export-ignore
 .gitignore     export-ignore
+.editorconfig  export-ignore
 
 # Sources
-*.c     text diff=c
+*.c     text eol=lf diff=c
-*.cc    text diff=cpp
+*.cc    text eol=lf diff=cpp
-*.cxx   text diff=cpp
+*.cxx   text eol=lf diff=cpp
-*.cpp   text diff=cpp
+*.cpp   text eol=lf diff=cpp
-*.c++   text diff=cpp
+*.c++   text eol=lf diff=cpp
-*.hpp   text diff=cpp
+*.hpp   text eol=lf diff=cpp
-*.h     text diff=c
+*.h     text eol=lf diff=c
-*.h++   text diff=cpp
+*.h++   text eol=lf diff=cpp
-*.hh    text diff=cpp
+*.hh    text eol=lf diff=cpp
 
 # Compiled Object files
 *.slo   binary

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,69 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug (unverified)
+assignees: ''
+
+---
+
+Before submitting an issue, please ensure that you have read the documentation:
+
+* Basics is an overview of how to use simdjson and its APIs to parse JSON: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
+* Builder is an overview of how to use simdjson to generate JSON: https://github.com/simdjson/simdjson/blob/master/doc/builder.md
+* Performance shows some more advanced scenarios and how to tune for them: https://github.com/simdjson/simdjson/blob/master/doc/performance.md
+* Contributing: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
+* We follow the [JSON specification as described by RFC 8259](https://www.rfc-editor.org/rfc/rfc8259.txt) (T. Bray, 2017). If you wish to support features that are not part of RFC 8259, then you should not refer to your issue as a bug.
+
+
+**Describe the bug**
+A clear and concise description of what the bug is. A bug is a failure to build with normal compiler settings or a misbehaviour: when running the code, you get a result that differs from the expected result from our documentation.
+
+A compiler or static-analyzer warning is not a bug. It is possible with tools such as Visual Studio to require that rarely enabled warnings are considered errors. Do not report such cases as bugs. We do accept pull requests if you want to silence warnings issued by code analyzers, however.
+
+We are committed to providing good documentation. We accept the lack of documentation or a misleading documentation as a bug (a 'documentation bug').
+
+An unexpected poor software performance can be accepted as a bug (a 'performance bug').
+
+We accept the identification of an issue by a sanitizer or some checker tool (e.g., valgrind) as a bug, but you must first ensure that it is not a false positive.
+
+We recommend that you run your tests using different optimization levels. In particular, we recommend your run tests with the simdjson library and you code compiled in debug mode. The simdjson then sets the SIMDJSON_DEVELOPMENT_CHECKS macro to 1, and this triggers additional checks on your code and on the internals of the library. If possible, we recommend that you run tests with sanitizers (e.g., see [No more leaks with sanitize flags in gcc and clang](https://lemire.me/blog/2016/04/20/no-more-leaks-with-sanitize-flags-in-gcc-and-clang/)).  You can compile the library with sanitizers for debugging purposes (e.g., set SIMDJSON_SANITIZE to ON using CMake), but you should also turn on sanitizers on your own code. You may also use tools like valgrind or the commercial equivalent.
+
+Mixing debug and release simdjson code is unsafe: you either build all your code using simdjson in
+release mode or all of it in debug mode.
+
+Before reporting a bug, please ensure that you have read our documentation.
+
+**To Reproduce**
+Steps to reproduce the behaviour: provide a code sample if possible. Please provide a complete test with data. Remember that a bug is either a failure to build or an unexpected result when running the code.
+
+If we cannot reproduce the issue, then we cannot address it. Note that a stack trace from your own program is not enough. A sample of your source code is insufficient: please provide a complete test for us to reproduce the issue. Please reduce the issue: use as small and as simple an example of the bug as possible.
+
+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**
+
+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.
+
+It is fine to report bugs against our main branch, but if that is what you are doing, please be explicit.
+
+**Configuration (please complete the following information if relevant)**
+ - OS: [e.g. Ubuntu 16.04.6 LTS]
+ - Compiler* [e.g. Apple clang version 11.0.3 (clang-1103.0.32.59) x86_64-apple-darwin19.4.0]
+ - Version [e.g. 22]
+ - Optimization setting (e.g., -O3)
+
+We support up-to-date 64-bit ARM and x64 FreeBSD, macOS, Windows and Linux systems. Please ensure that your configuration is supported before labelling the issue as a bug.
+
+* We do not support unreleased or experimental compilers. If you encounter an issue with a
+pre-release version of a compiler, do not report it as a bug to simdjson. However, we always
+invite contributions either in the form an analysis or of a code contribution.
+* Vendors (e.g., Apple and Microsoft) stop supporting old systems. Once a compiler system is no longer supported by its vendor, we no longer support it. We will gladly accept code contributions, but we do not consider it a *bug* if you have issues with an obsolete compiler systems. This policy extends to obsolete standard libraries, linkers and other build tools. Please do not report it as an issue. If you cannot resolve the issue yourself, we encourage you to reach out to the vendor for legacy support.
+
+Under Windows, we support Visual Studio (both with LLVM and without). We do not support MinGW and other alternate compiler systems. Windows users should be aware that there [is a long-running bug with GCC under Windows](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412).
+
+**Indicate whether you are willing or able to provide a bug fix as a pull request**
+
+If you plan to contribute to simdjson, please read our guide:
+* 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/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,38 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Before submitting an issue, please ensure that you have read the documentation:
+
+* Basics is an overview of how to use simdjson and its APIs to parse JSON: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
+* Builder is an overview of how to use simdjson to generate JSON: https://github.com/simdjson/simdjson/blob/master/doc/builder.md
+* Performance shows some more advanced scenarios and how to tune for them: https://github.com/simdjson/simdjson/blob/master/doc/performance.md
+* Contributing: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
+* We follow the [JSON specification as described by RFC 8259](https://www.rfc-editor.org/rfc/rfc8259.txt) (T. Bray, 2017).
+
+We do not make changes to simdjson without clearly identifiable benefits, which typically means either performance improvements, bug fixes or new features. Avoid bike-shedding: we all have opinions about how to write code, but we want to focus on what makes simdjson objectively better.
+
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+ Please provide a clear rationale for the feature. Be advised that simdjson is a community-based project: you should consider providing help.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
+
+**Are you willing to contribute code or documentation toward this new feature?**
+If you plan to contribute to simdjson, please read our
+* 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/ISSUE_TEMPLATE/standard-issue-template.md

@@ -0,0 +1,33 @@
+---
+name: Standard issue template
+about: Issue
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Before submitting an issue, please ensure that you have read the documentation:
+
+* Basics is an overview of how to use simdjson and its APIs to parse JSON: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
+* Builder is an overview of how to use simdjson to generate JSON: https://github.com/simdjson/simdjson/blob/master/doc/builder.md
+* Performance shows some more advanced scenarios and how to tune for them: https://github.com/simdjson/simdjson/blob/master/doc/performance.md
+* Contributing: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
+* We follow the [JSON specification as described by RFC 8259](https://www.rfc-editor.org/rfc/rfc8259.txt) (T. Bray, 2017).
+
+We do not make changes to simdjson without clearly identifiable benefits, which typically means either performance improvements, bug fixes or new features. Avoid bike-shedding: we all have opinions about how to write code, but we want to focus on what makes simdjson objectively better.
+
+Is your issue:
+
+1. A bug report? If so, please point at a reproducible test. Indicate whether you are willing or able to provide a bug fix as a pull request. As a matter of policy, we do not consider a compiler warning to be a bug.
+
+2. A build issue? If so, provide all possible details regarding your system configuration. If we cannot reproduce your issue, we cannot fix it.
+
+3. A feature request? Please provide a clear rationale for the feature. Be advised that simdjson is a community-based project: you should consider providing help.
+
+4. A documentation issue? Can you suggest an improvement?
+
+
+If you plan to contribute to simdjson, please read our
+* 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/pull_request_template.md

@@ -0,0 +1,54 @@
+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
+- [ ] Optimization
+- [ ] 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
+- AI Usage Policy: https://github.com/simdjson/simdjson/blob/master/AI_USAGE_POLICY.md
+
+
+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!
+

.github/workflows/aarch64.yml

@@ -0,0 +1,29 @@
+name: Ubuntu aarch64 (GCC 13)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v3
+        name: Test
+        id: runcmd
+        with:
+          arch: aarch64
+          distro: ubuntu_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update -q -y
+            apt-get install -y cmake make g++
+          run: |
+            cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
+            cmake --build build -j=2
+            ctest --output-on-failure --test-dir build

.github/workflows/alpine.yml

@@ -0,0 +1,34 @@
+name: Alpine Linux
+
+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-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: start docker
+        run: |
+          docker run -w /src -dit --name alpine -v $PWD:/src alpine:latest
+          echo 'docker exec alpine "$@";' > ./alpine.sh
+          chmod +x ./alpine.sh
+      - name: install packages
+        run: |
+          ./alpine.sh apk update
+          ./alpine.sh apk add build-base cmake g++ linux-headers git bash
+      - name: cmake
+        run: |
+          ./alpine.sh cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build_for_alpine
+      - name: build
+        run: |
+          ./alpine.sh cmake --build build_for_alpine
+      - name: test
+        run: |
+          ./alpine.sh bash -c "cd build_for_alpine && ctest  -LE explicitonly --output-on-failure"

.github/workflows/cifuzz.yml

@@ -0,0 +1,24 @@
+name: CIFuzz
+on: [pull_request]
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Build Fuzzers
+      id: build
+      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'simdjson'
+        dry-run: false
+    - name: Run Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'simdjson'
+        fuzz-seconds: 600
+        dry-run: false
+    - name: Upload Crash
+      uses: actions/upload-artifact@v4
+      if: failure() && steps.build.outcome == 'success'
+      with:
+        name: artifacts
+        path: ./out/artifacts

.github/workflows/debian.yaml

@@ -0,0 +1,33 @@
+name: Debian
+
+on: [push, pull_request]
+
+defaults:
+  run:
+    shell: sh
+
+permissions:
+  contents: read
+
+jobs:
+  pkg-config:
+    runs-on: ubuntu-latest
+    container:
+      image: debian:testing
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install dependencies
+      run: |
+        apt -y update
+        apt -y --no-install-recommends install g++ cmake make pkg-config
+
+    - name: Build and install
+      run: |
+        cmake -B build
+        cmake --build build
+        cmake --install build
+
+    - name: Test pkg-config
+      run: g++ examples/quickstart/quickstart.cpp $(pkg-config --cflags --libs simdjson)

.github/workflows/documentation.yml

@@ -0,0 +1,39 @@
+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
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pages: write
+  id-token: write
+
+jobs:
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Doxygen
+        run: sudo apt-get install doxygen graphviz -y
+      - run: mkdir docs
+      - name: Install theme
+        run: ./tools/prepare_doxygen.sh
+      - name: Generate Doxygen Documentation
+        run: doxygen
+      - name: Deploy to GitHub Pages
+        uses: peaceiris/actions-gh-pages@v4
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: doc/api/html

.github/workflows/emscripten.yml

@@ -0,0 +1,17 @@
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+      - uses: mymindstorm/setup-emsdk@6ab9eb1bda2574c4ddb79809fc9247783eaf9021 # v14
+      - name: Verify
+        run: emcc -v
+      - name: Checkout
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v3.6.0
+      - name: Configure
+        run: emcmake cmake -B build
+      - name: Build # We build but do not test
+        run: cmake --build build

.github/workflows/fix-trailing-whitespace.yml

@@ -0,0 +1,34 @@
+name: Detect trailing whitespace
+
+on: [push, pull_request]
+
+jobs:
+  whitespace:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - name: Remove whitespace and check the diff
+        run: |
+          set -eu
+          scripts/remove_trailing_whitespace.sh
+          git diff >whitespace.patch
+          cat whitespace.patch
+          if [ $(wc -c <whitespace.patch) -ne 0 ] ; then
+             echo " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! "
+             echo "You have trailing whitespace, please download the artifact"
+             echo "and apply with git apply <whitespace.patch or"
+             echo "run scripts/remove_trailing_whitespace.sh locally."
+             echo " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! "
+             exit 1
+          else
+             echo "no trailing whitespace found, good!"
+          fi
+      - name: Archive whitespace patch
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: whitespace-patch
+          path: |
+            whitespace.patch
+          if-no-files-found: ignore
+

.github/workflows/fuzzers.yml

@@ -1,127 +1,167 @@
-name: Run fuzzers on stored corpus and test it with valgrind
+name: Fuzz and run valgrind
 
-# In the case of a pull request happening at the same time as a cron
-# job, there is a risk two jobs run at the same time. Therefore,
-# the corpus is only uploaded for the master branch. Pull requests will
-# fuzz for a short while, but the results are not uploaded.
 on:
   push:
+    branches:
+      - master
   pull_request:
+    branches:
+      - master
   schedule:
     - cron: 23 */8 * * *
 
 jobs:
   build:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-latest
     env:
-      allfuzzers: parser dump dump_raw_tape print_json
+      # fuzzers that change behaviour with SIMDJSON_FORCE_IMPLEMENTATION
-      artifactsprefix: -artifact_prefix=fuzzfailure/
+      defaultimplfuzzers: atpointer dump dump_raw_tape element minify parser print_json
+      # fuzzers that loop over the implementations themselves, or don't need to switch.
+      implfuzzers: implementations minifyimpl ndjson ondemand padded utf8
+      implementations: haswell westmere fallback
+      UBSAN_OPTIONS: halt_on_error=1
+      MAXLEN: -max_len=4000
+      CLANGVERSION: 19
+      # which optimization level to use for the sanitizer build (see build_fuzzer.variants.sh)
+      OPTLEVEL: -O3
+
     steps:
     - name: Install packages necessary for building
       run: |
         sudo apt update
-        sudo apt-get install --quiet ninja-build valgrind zip unzip
+        sudo apt-get install --quiet ninja-build valgrind zip unzip lsb-release wget software-properties-common gnupg
         wget https://apt.llvm.org/llvm.sh
+        sudo apt-get purge --auto-remove llvm python3-lldb-15 llvm-15
         chmod +x llvm.sh
-        sudo ./llvm.sh 8
+        sudo ./llvm.sh $CLANGVERSION
+
+    - uses: actions/checkout@v4
+
+    - uses: actions/cache@v4
+      with:
+        path: dependencies/.cache
+        key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+
+    - uses: actions/cache@v4
+      id: cache-corpus
+      with:
+        path: out/
+        key: corpus-${{ github.run_id }}
+        restore-keys: corpus-
+
+    - name: show statistics for the cached corpus
+      run: |
+        echo number of files in github action corpus cache:
+        find out -type f |wc -l
 
-    - uses: actions/checkout@v1
     - name: Create and prepare the initial seed corpus
       run: |
         fuzz/build_corpus.sh
         mv corpus.zip seed_corpus.zip
-    - name: Download the corpus from the last run
+        mkdir seedcorpus
-      run: |
+        unzip -q -d seedcorpus seed_corpus.zip
-        wget --quiet https://dl.bintray.com/pauldreik/simdjson-fuzz-corpus/corpus/corpus.tar
+
-        tar xf corpus.tar
-        rm corpus.tar
     - name: List clang versions
       run: |
         ls /usr/bin/clang*
         which clang++
         clang++ --version
+
     - name: Build all the variants
-      run: fuzz/build_fuzzer_variants.sh
+      run: CLANGSUFFIX=-$CLANGVERSION fuzz/build_fuzzer_variants.sh
-    - name: Verify that the oss-fuzz seed corpus passes without problems
+
+    - name: Explore fast (release build, default implementation)
       run: |
-        mkdir seedcorpus
+        set -eux
-        unzip -q -d seedcorpus seed_corpus.zip
+        for fuzzer in $defaultimplfuzzers $implfuzzers; do
-        for buildvariant in noavx withavx; do
+          mkdir -p out/$fuzzer # in case this is a new fuzzer, or the github action cached corpus is broken
-          for fuzzer in $allfuzzers; do
+          # get input from everyone else (corpus cross pollination)
-            build-ossfuzz-$buildvariant/fuzz/fuzz_$fuzzer seedcorpus -max_total_time=1
+          others=$(find out -type d -not -name $fuzzer -not -name out -not -name cmin)
+          build-fast/fuzz/fuzz_$fuzzer out/$fuzzer $others seedcorpus -max_total_time=30 $MAXLEN
+        done
+
+    - name: Fuzz default impl. fuzzers with sanitizer+asserts (good at detecting errors)
+      run: |
+        set -eux
+        for fuzzer in $defaultimplfuzzers; do
+          # get input from everyone else (corpus cross pollination)
+          others=$(find out -type d -not -name $fuzzer -not -name out -not -name cmin)
+          for implementation in $implementations; do
+            export SIMDJSON_FORCE_IMPLEMENTATION=$implementation
+            build-sanitizers$OPTLEVEL/fuzz/fuzz_$fuzzer out/$fuzzer $others seedcorpus -max_total_time=20 $MAXLEN
           done
-        done
-    - name: Run the fastest fuzzer to explore fast
-      run: |
-        for fuzzer in $allfuzzers; do
-          mkdir -p out/$fuzzer # in case this is a new fuzzer, or corpus.tar is broken
-          build-ossfuzz-fast8/fuzz/fuzz_$fuzzer         out/$fuzzer -max_total_time=30 $artifactsprefix || touch failed
-          # make sure the failing output is visible in the log
-          if [ -e failed ] ; then
-            ls fuzzfailure/* |xargs -n1 base64
-            exit 1
-          fi
-        done
-    - name: Run the other fuzzer variants for $fuzzer, with sanitizers etc
-      run: |
-        set -x
-        for fuzzer in $allfuzzers; do
-          build-ossfuzz-withavx/fuzz/fuzz_$fuzzer       out/$fuzzer -max_total_time=20 $artifactsprefix || touch failed
-          build-ossfuzz-noavx/fuzz/fuzz_$fuzzer         out/$fuzzer -max_total_time=10 $artifactsprefix || touch failed
-          build-ossfuzz-noavx8/fuzz/fuzz_$fuzzer        out/$fuzzer -max_total_time=10 $artifactsprefix || touch failed
-          if [ -e failed ] ; then
-            # make sure the failing output is visible in the log
-            ls fuzzfailure/* |xargs -n1 base64
-            exit 1
-          fi
-          echo disable msan runs, it fails inside the fuzzing engine and not the fuzzed code!
-          echo build-ossfuzz-msan-noavx8/fuzz/fuzz_$fuzzer   out/$fuzzer -max_total_time=10 -reload=0 $artifactsprefix
-          echo build-ossfuzz-msan-withavx8/fuzz/fuzz_$fuzzer out/$fuzzer -max_total_time=10 -reload=0 $artifactsprefix
           echo now have $(ls out/$fuzzer |wc -l) files in corpus
         done
-    - name: Minimize the corpus with the fast fuzzer
+
+    - name: Fuzz differential impl. fuzzers with sanitizer+asserts (good at detecting errors)
       run: |
-        for fuzzer in $allfuzzers; do      
+        set -eux
+        for fuzzer in $implfuzzers; do
+          # get input from everyone else (corpus cross pollination)
+          others=$(find out -type d -not -name $fuzzer -not -name out -not -name cmin)
+          build-sanitizers$OPTLEVEL/fuzz/fuzz_$fuzzer out/$fuzzer $others seedcorpus -max_total_time=20 $MAXLEN
+          echo now have $(ls out/$fuzzer |wc -l) files in corpus
+        done
+
+    - name: Minimize the corpus with the fast fuzzer on the default implementation
+      run: |
+        set -eux
+        for fuzzer in $defaultimplfuzzers $implfuzzers; do
           mkdir -p out/cmin/$fuzzer
-          build-ossfuzz-fast8/fuzz/fuzz_$fuzzer -merge=1  out/cmin/$fuzzer out/$fuzzer
+          # get input from everyone else (corpus cross pollination)
+          others=$(find out -type d -not -name $fuzzer -not -name out -not -name cmin)
+          build-fast/fuzz/fuzz_$fuzzer -merge=1 $MAXLEN out/cmin/$fuzzer out/$fuzzer $others seedcorpus
           rm -rf out/$fuzzer
           mv out/cmin/$fuzzer out/$fuzzer
         done
+
     - name: Package the corpus into an artifact
       run: |
-        for fuzzer in $allfuzzers; do      
+        for fuzzer in $defaultimplfuzzers $implfuzzers; do
           tar rf corpus.tar out/$fuzzer
         done
+
     - name: Save the corpus as a github artifact
-      uses: actions/upload-artifact@v1
+      uses: actions/upload-artifact@v4
       with:
         name: corpus
         path: corpus.tar
-    - name: Run the corpus through valgrind (normal build)
+
+    - name: Store the corpus externally
       run: |
-        for fuzzer in $allfuzzers; do      
+        gzip --keep corpus.tar
-          find out/$fuzzer -type f |sort|xargs valgrind build-plain-noavx/fuzz/fuzz_$fuzzer  2>&1|tee valgrind-$fuzzer-noavx.txt
+        curl -F"filedata=@corpus.tar.gz" https://simdjson:${{ secrets.fuzzdatapassword }}@www.pauldreik.se/fuzzdata/index.php
-        done
+
-    - name: Run the corpus through valgrind (noavx build)
+    # This takes a subset of the minimized corpus and run it through valgrind. It is slow,
+    # therefore take a "random" subset. The random selection is accomplished by sorting on filenames,
+    # which are hashes of the content.
+    - name: Run some of the minimized corpus through valgrind (replay build, default implementation)
       run: |
-        for fuzzer in $allfuzzers; do      
+        for fuzzer in $defaultimplfuzzers $implfuzzers; do
-          find out/$fuzzer -type f |sort|xargs valgrind build-plain-normal/fuzz/fuzz_$fuzzer 2>&1|tee valgrind-$fuzzer-normal.txt      
+          find out/$fuzzer -type f |sort|head -n200|xargs -n40 valgrind build-replay/fuzz/fuzz_$fuzzer 2>&1|tee valgrind-$fuzzer.txt
         done
+
     - name: Compress the valgrind output
       run: tar cf valgrind.tar valgrind-*.txt
+
     - name: Save valgrind output as a github artifact
-      uses: actions/upload-artifact@v1
+      uses: actions/upload-artifact@v4
+      if: always()
       with:
         name: valgrindresults
         path: valgrind.tar
-    - name: Upload the corpus and results to bintray if we are on master
+        if-no-files-found: ignore
-      run: |
+
-        if [ $(git rev-parse --verify HEAD) = $(git rev-parse --verify origin/master) ] ; then
+    - name: Archive any crashes as an artifact
-          echo uploading each artifact twice, otherwise it will not be published
+      uses: actions/upload-artifact@v4
-          curl -T corpus.tar -upauldreik:${{ secrets.bintrayApiKey }} https://api.bintray.com/content/pauldreik/simdjson-fuzz-corpus/corpus/0/corpus/corpus.tar";publish=1;override=1"
+      if: always()
-          curl -T corpus.tar -upauldreik:${{ secrets.bintrayApiKey }} https://api.bintray.com/content/pauldreik/simdjson-fuzz-corpus/corpus/0/corpus/corpus.tar";publish=1;override=1"
+      with:
-          curl -T valgrind.tar -upauldreik:${{ secrets.bintrayApiKey }} https://api.bintray.com/content/pauldreik/simdjson-fuzz-corpus/corpus/0/corpus/valgrind.tar";publish=1;override=1"
+        name: crashes
-          curl -T valgrind.tar -upauldreik:${{ secrets.bintrayApiKey }} https://api.bintray.com/content/pauldreik/simdjson-fuzz-corpus/corpus/0/corpus/valgrind.tar";publish=1;override=1"
+        path: |
-        else
+          crash-*
-          echo "not on master, won't upload to bintray"
+          leak-*
-        fi
+          timeout-*
+        if-no-files-found: ignore

.github/workflows/loongarch64.yml

@@ -0,0 +1,50 @@
+name: LoongArch64-CI
+
+on: [push, pull_request]
+
+jobs:
+  loongarch64:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - { toolchain-version: 2023.08.08 }
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install build requirements
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y --no-install-recommends cmake
+
+      - uses: actions/cache/restore@v4
+        id: restore-cache
+        with:
+          path: /opt/cross-tools
+          key: loongarch64-${{ matrix.platform.toolchain-version }}
+
+      - name: Download LoongArch64 gcc+glibc toolchain
+        if: ${{ !steps.restore-cache.outputs.cache-hit }}
+        run: |
+          url="https://github.com/loongson/build-tools/releases/download/${{ matrix.platform.toolchain-version }}/x86_64-cross-tools-loongarch64-gcc-libc.tar.xz"
+
+          wget "$url" -O /tmp/toolchain.tar.xz
+
+          mkdir -p /opt
+          tar -C /opt -x -f /tmp/toolchain.tar.xz
+
+      - uses: actions/cache/save@v3
+        if: ${{ !steps.restore-cache.outputs.cache-hit }}
+        with:
+          path: /opt/cross-tools
+          key: loongarch64-${{ matrix.platform.toolchain-version }}
+
+      - name: setup Loongarch64 build environment
+        run: |
+          echo "/opt/cross-tools/bin" >> $GITHUB_PATH
+          echo "CC=loongarch64-unknown-linux-gnu-gcc" >> $GITHUB_ENV
+          echo "CXX=loongarch64-unknown-linux-gnu-g++" >> $GITHUB_ENV
+      - name: configure
+        run: cmake -B build -DCMAKE_SYSTEM_PROCESSOR=loongarch64 -DARCH=lonngarch64 -DCMAKE_SYSTEM_NAME=Linux -DCMAKE_C_COMPILER=loongarch64-unknown-linux-gnu-gcc -DCMAKE_CXX_COMPILER=loongarch64-unknown-linux-gnu-g++
+      - name: build
+        run: cmake --build build

.github/workflows/macos.yml

@@ -0,0 +1,44 @@
+name: Macos
+
+on: [push, pull_request]
+
+jobs:
+  macos-build:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir builddebug &&
+          cd builddebug &&
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cd .. &&
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cmake --install . &&
+          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 &&
+          cd ../tests/installation_tests/find &&
+          mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .
+      - name: Use cmake (shared)
+        run: |
+          mkdir buildshared &&
+          cd buildshared &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cmake --install . &&
+          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 &&
+          cd ../tests/installation_tests/find &&
+          mkdir buildshared && cd buildshared && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../buildshared/destination .. &&  cmake --build .

.github/workflows/msys2-clang.yml

@@ -0,0 +1,46 @@
+name: MSYS2-CLANG-CI
+
+on: [push, pull_request]
+
+
+jobs:
+  windows-mingw:
+    name: ${{ matrix.msystem }}
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - msystem: "MINGW64"
+            install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
+            type: Release
+          - msystem: "MINGW64"
+            install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
+            type: Debug
+          - msystem: "MINGW64"
+            install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
+            type: RelWithDebInfo
+    env:
+      CMAKE_GENERATOR: Ninja
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - uses: msys2/setup-msys2@v2
+        with:
+          update: true
+          msystem: ${{ matrix.msystem }}
+          install: ${{ matrix.install }}
+      - name: Build and Test
+        run: |
+          mkdir build
+          cd build
+          cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_BUILD_TYPE=${{ matrix.type }} -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_DO_NOT_USE_THREADS_NO_MATTER_WHAT=ON ..
+          cmake --build . --verbose
+          ctest -j4 --output-on-failure -LE explicitonly

.github/workflows/msys2.yml

@@ -0,0 +1,48 @@
+name: MSYS2-CI
+
+on: [push, pull_request]
+
+jobs:
+  windows-mingw:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    name: ${{ matrix.msystem }}
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - msystem: "MINGW64"
+            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
+            type: Release
+          - msystem: "MINGW64"
+            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
+            type: Debug
+          - msystem: "MINGW64"
+            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
+            type: RelWithDebInfo
+    env:
+      CMAKE_GENERATOR: Ninja
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - uses: msys2/setup-msys2@v2
+        with:
+          update: true
+          msystem: ${{ matrix.msystem }}
+          install: ${{ matrix.install }}
+      - name: Build and Test
+        run: |
+          mkdir build
+          cd build
+          cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_BUILD_TYPE=${{ matrix.type }} -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_DO_NOT_USE_THREADS_NO_MATTER_WHAT=ON ..
+          cmake --build . --verbose
+          ctest -j4 --output-on-failure -LE explicitonly

.github/workflows/ppc64.yml

@@ -0,0 +1,29 @@
+name: Ubuntu ppc64le (GCC 11)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v3
+        name: Test
+        id: runcmd
+        with:
+          arch: ppc64le
+          distro: ubuntu_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update -q -y
+            apt-get install -y cmake make g++
+          run: |
+            cmake -DCMAKE_BUILD_TYPE=Release -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF  -B build
+            cmake --build build -j=2
+            ctest --output-on-failure --test-dir build

.github/workflows/riscv64.yml

@@ -0,0 +1,29 @@
+name: Ubuntu riscv64 (GCC 11)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v3
+        name: Test
+        id: runcmd
+        with:
+          arch: riscv64
+          distro: ubuntu_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update -q -y
+            apt-get install -y cmake make g++
+          run: |
+            cmake -DCMAKE_BUILD_TYPE=Release -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF  -B build
+            cmake --build build -j=2
+            ctest --output-on-failure --test-dir build

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

@@ -0,0 +1,29 @@
+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: |
+        CC=clang-18 CXX=clang++-18 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvbb" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --build build/ -j$(nproc) --config Release
+    - name: Test VLEN=1024
+      run: |
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        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

@@ -0,0 +1,24 @@
+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: |
+        CC=clang-17 CXX=clang++-17 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --build build/ -j$(nproc) --config Release

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

@@ -0,0 +1,39 @@
+name: Ubuntu rvv VLEN=128 (clang 20)
+
+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-20
+    - name: Build
+      run: |
+        CC=clang-20 CXX=clang++-20 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --build build/ -j$(nproc) --config Release
+    - name: Test VLEN=128
+      run: |
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        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)
+    - name: Build VLS
+      run: |
+        CC=clang-20 CXX=clang++-20 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvl128b_zba_zbb_zbc -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build-vls
+        cmake --build build-vls/ -j$(nproc) --config Release
+    - name: Test VLEN=128 VLS
+      run: |
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        QEMU_CPU="rv64,v=on,zba=on,zbb=on,zbc=on,vlen=128,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
+        ctest --timeout 1800 --output-on-failure --test-dir build-vls -j $(nproc)

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

@@ -0,0 +1,39 @@
+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: |
+        CC=riscv64-linux-gnu-gcc-14 CXX=riscv64-linux-gnu-g++-14 CFLAGS=-march=rv64gcv CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --build build/ -j$(nproc) --config Release
+    - name: Test VLEN=256
+      run: |
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        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)
+    - name: Build VLS
+      run: |
+        CC=riscv64-linux-gnu-gcc-14 CXX=riscv64-linux-gnu-g++-14 CFLAGS="-march=rv64gcv_zvl256b -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build-vls
+        cmake --build build-vls/ -j$(nproc) --config Release
+    - name: Test VLEN=256 VLS
+      run: |
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        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-vls -j $(nproc)

.github/workflows/rvv-512-clang-19.yml

@@ -0,0 +1,39 @@
+name: Ubuntu rvv VLEN=512 (clang 19)
+
+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-19
+    - name: Build
+      run: |
+        CC=clang-19 CXX=clang++-19 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --build build/ -j$(nproc) --config Release
+    - name: Test VLEN=512
+      run: |
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        QEMU_CPU="rv64,v=on,vlen=512,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
+        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)
+    - name: Build VLS
+      run: |
+        CC=clang-19 CXX=clang++-19 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvl512b_zba_zbb_zbc -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build-vls
+        cmake --build build-vls/ -j$(nproc) --config Release
+    - name: Test VLEN=512 VLS
+      run: |
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        QEMU_CPU="rv64,v=on,zba=on,zbb=on,zbc=on,vlen=512,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
+        ctest --timeout 1800 --output-on-failure --test-dir build-vls -j $(nproc)

.github/workflows/s390x.yml

@@ -0,0 +1,29 @@
+name: Ubuntu s390x (GCC 11)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v3
+        name: Test
+        id: runcmd
+        with:
+          arch: s390x
+          distro: ubuntu_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update -q -y
+            apt-get install -y cmake make g++
+          run: |
+            cmake -DCMAKE_BUILD_TYPE=Release  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
+            cmake --build build -j=2
+            ctest --output-on-failure --test-dir build

.github/workflows/ubuntu22-clang13.yml

@@ -0,0 +1,23 @@
+name: Ubuntu 22.04 CI (CLANG 13)
+
+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-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          CXX=clang++-13 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j

.github/workflows/ubuntu22-clang14.yml

@@ -0,0 +1,23 @@
+name: Ubuntu 22.04 CI (CLANG 14)
+
+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-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          CXX=clang++-14 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j

.github/workflows/ubuntu22-cxx20.yml

@@ -0,0 +1,65 @@
+name: Ubuntu 22.04 CI (GCC 12, CXX 20)
+
+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-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+
+      - name: Configure Debug Build
+        run: |
+          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20 -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -B builddebug
+
+      - name: Compile Debug Build
+        run: |
+          cmake --build builddebug
+
+      - name: Test Debug Build
+        run: |
+          ctest --output-on-failure -LE explicitonly -j --test-dir builddebug
+
+      - name: Configure Release Build
+        run: |
+          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20 -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination -B build
+
+      - name: Compile Release Build
+        run: |
+          cmake --build build
+
+      - name: Test Release Build
+        run: |
+          ctest --output-on-failure -LE explicitonly -j --test-dir build
+
+      - name: Install Release Build
+        run: |
+          cmake --install build
+
+      - name: Generate Example Code
+        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
+
+      - name: Compile Example Code
+        run: |
+          c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson
+
+      - name: Run Example Code
+        run: |
+          ./linkandrun jsonexamples/twitter.json
+
+      - name: Configure Find Tests
+        run: |
+          cd tests/installation_tests/find && \
+          cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../destination -B build
+
+      - name: Compile Find Tests
+        run: |
+          cd tests/installation_tests/find && cmake --build build

.github/workflows/ubuntu22-gcc12.yml

@@ -0,0 +1,23 @@
+name: Ubuntu 22.04 CI (GCC 12)
+
+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-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          CXX=g++-12 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j

.github/workflows/ubuntu22-glibcxxassertions.yml

@@ -0,0 +1,24 @@
+name: Ubuntu 22.04 CI GCC 12 with GLIBCXX_ASSERTIONS
+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-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Install gcc12
+        run: sudo apt-get install -y g++-12
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          CXX=g++-12 cmake -DCMAKE_BUILD_TYPE=Debug  -DSIMDJSON_GLIBCXX_ASSERTIONS=ON -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
+          cmake --build .   &&
+          ctest . -E avoid_

.github/workflows/ubuntu22-threadsani.yml

@@ -0,0 +1,24 @@
+name: Ubuntu 22.04 CI (GCC 12) with Thread Sanitizer
+
+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-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          CXX=g++-12 cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE_THREADS=ON ..  &&
+          cmake --build . --target document_stream_tests  --target ondemand_document_stream_tests --target parse_many_test  &&
+          ctest --output-on-failure  -R parse_many_test  &&
+          ctest --output-on-failure  -R document_stream_tests

.github/workflows/ubuntu22.yml

@@ -0,0 +1,47 @@
+name: Ubuntu 22.04 CI (GCC 11)
+
+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-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake to build just the library
+        run: |
+          mkdir buildjustlib &&
+          cd buildjustlib &&
+          cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_DEVELOPER_MODE=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          cmake --install . &&
+          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 &&
+          cd ../tests/installation_tests/find &&
+          mkdir buildjustlib &&
+          cd buildjustlib &&
+          cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../buildjustlib/destination .. &&
+          cmake --build .
+      - name: Use cmake
+        run: |
+          mkdir builddebug &&
+          cd builddebug &&
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cd .. &&
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cmake --install . &&
+          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 &&
+          cd ../tests/installation_tests/find &&
+          mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .

.github/workflows/ubuntu24-checkperf.yml

@@ -0,0 +1,29 @@
+name: Performance check on Ubuntu 24.04 CI (GCC 13)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+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
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_ENABLE_DOM_CHECKPERF=ON -DCMAKE_CXX_FLAGS="-Werror=old-style-cast -pedantic -Wpedantic" -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build . --target checkperf  &&
+          ctest --output-on-failure -R checkperf

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

@@ -0,0 +1,22 @@
+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-cxx20.yml

@@ -0,0 +1,22 @@
+name: Ubuntu 24.04 CI (CXX 20)
+
+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_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

@@ -0,0 +1,34 @@
+name: Ubuntu 24.04 CI (GCC 13) without exceptions
+
+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
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir builddebug &&
+          cd builddebug &&
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cd .. &&
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          make install  &&
+          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 .

.github/workflows/ubuntu24-nothread.yml

@@ -0,0 +1,34 @@
+name: Ubuntu 24.04 CI (GCC 13) Without Threads
+
+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
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir builddebug &&
+          cd builddebug &&
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF  -DSIMDJSON_ENABLE_THREADS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cd .. &&
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_ENABLE_THREADS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          make install  &&
+          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 .

.github/workflows/ubuntu24-sani.yml

@@ -0,0 +1,41 @@
+name: Ubuntu 24.04 CI (GCC 13) With Memory Sanitizer
+
+on: [push, pull_request]
+
+jobs:
+  ubuntu-build-address-sanitizer:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake with address sanitizer
+        run: |
+          mkdir builddebug &&
+          cd builddebug &&
+          cmake -DSIMDJSON_SANITIZE=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j
+  ubuntu-build-undefined-sanitizer:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake with undefined sanitizer
+        run: |
+          mkdir builddebugundefsani &&
+          cd builddebugundefsani &&
+          cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j

.github/workflows/ubuntu24.yml

@@ -0,0 +1,25 @@
+name: Ubuntu 24.04 CI
+
+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:
+        shared: [ON, OFF]
+        cxx: [g++-13, clang++-16]
+        sanitizer: [ON, OFF]
+        build_type: [RelWithDebInfo, Debug, Release]
+    steps:
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
+      - name: Prepare
+        run: cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE=${{matrix.sanitizer}} -DBUILD_SHARED_LIBS=${{matrix.shared}}  -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/vs17-arm-ci.yml

@@ -0,0 +1,21 @@
+name: VS17-ARM-CI
+
+on: [push, pull_request]
+
+jobs:
+   ci:
+     name: windows-vs17
+     runs-on: windows-latest
+     strategy:
+       fail-fast: false
+       matrix:
+         include:
+           - {arch: ARM64}
+           - {arch: ARM64EC}
+     steps:
+       - name: checkout
+         uses: actions/checkout@v4
+       - name: Use cmake
+         run: |
+           cmake -A ${{ matrix.arch }} -DCMAKE_SYSTEM_VERSION="10.0.22621.0" -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -B build  &&
+           cmake --build build --verbose

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

@@ -0,0 +1,44 @@
+name: VS17-CI CXX20
+
+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: Win32, shared: ON}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: ON}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF}
+    steps:
+    - name: checkout
+      uses: actions/checkout@v4
+    - name: Configure
+      run: |
+        cmake -DSIMDJSON_CXX_STANDARD=20 -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
+    - name: Build Debug
+      run: cmake --build build --config Debug --verbose
+    - name: Build Release
+      run: cmake --build build --config Release --verbose
+    - name: Run Release tests
+      run: |
+        cd build
+        ctest -C Release  -LE explicitonly  --output-on-failure
+    - name: Run Debug tests
+      run: |
+        cd build
+        ctest -C Debug  -LE explicitonly  --output-on-failure
+    - name: Install
+      run: |
+        cmake --install build --config Release
+    - name: Test Installation
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
+        cmake --build build_install_test --config Release

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

@@ -0,0 +1,30 @@
+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

.github/workflows/vs17-ci.yml

@@ -0,0 +1,40 @@
+name: VS17-CI
+
+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: Win32, shared: ON, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: ON, build_type: Release}
+          - {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}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
+    - name: Build Debug
+      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
+    - name: Install
+      run: |
+        cmake --install build --config ${{matrix.build_type}}
+    - name: Test Installation
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
+        cmake --build build_install_test --config ${{matrix.build_type}}

.github/workflows/vs17-clang-ci-cxx20.yml

@@ -0,0 +1,37 @@
+name: VS17-CLANG-CI
+
+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, build_type: Debug}
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: RelWithDebInfo}
+    steps:
+    - name: checkout
+      uses: actions/checkout@v4
+    - name: Configure
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -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
+    - name: Install
+      run: |
+        cmake --install build --config ${{matrix.build_type}}
+    - name: Test Installation
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
+        cmake --build build_install_test --config ${{matrix.build_type}}

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

@@ -0,0 +1,37 @@
+name: VS17-CLANG-CI
+
+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, build_type: Debug}
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: RelWithDebInfo}
+    steps:
+    - name: checkout
+      uses: actions/checkout@v4
+    - name: Configure
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -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
+    - name: Install
+      run: |
+        cmake --install build --config ${{matrix.build_type}}
+    - name: Test Installation
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
+        cmake --build build_install_test --config ${{matrix.build_type}}

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

@@ -0,0 +1,30 @@
+name: VS17-NoExcept-CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    name: windows-vs17
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/cache@v4
+      with:
+        path: dependencies/.cache
+        key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+    - name: 'Run CMake with VS17'
+      uses: lukka/run-cmake@v3
+      with:
+        cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+        cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
+        buildDirectory: "${{ github.workspace }}/../../_temp/windows"
+        cmakeBuildType: Release
+        buildWithCMake: true
+        cmakeGenerator: VS16Win64
+        cmakeAppendedArgs: -DSIMDJSON_COMPETITION=OFF -DSIMDJSON_DEVELOPER_MODE=ON  -DSIMDJSON_EXCEPTIONS=OFF
+        buildWithCMakeArgs: --config Release
+
+    - name: 'Run CTest'
+      run: ctest -C Release  -LE explicitonly  --output-on-failure
+      working-directory: "${{ github.workspace }}/../../_temp/windows"
+

.gitignore

@@ -1,8 +1,3 @@
-visual_studio
-
-/benchbranch/
-/submodules/
-
 # eclipse project files
 .cproject
 .project
@@ -43,7 +38,7 @@ cmake-build-release/
 .history/
 
 # Visual Studio artifacts
-/VS/
+/.vs/
 
 # C/C++ build outputs
 .build/
@@ -52,85 +47,6 @@ gens
 libs
 objs
 
-# Build outputs (TODO build to a subdir so we can exclude that instead)
-/allparserscheckfile
-/allparsingcompetition
-/basictests
-/benchfeatures
-/benchmark/bench_dom_api
-/benchmark/bench_parse_call
-/benchmark/get_corpus_benchmark
-/benchmark/parse
-/benchmark/parse_stream
-/benchmark/perfdiff
-/benchmark/statisticalmodel
-/build/
-/build-ossfuzz-*/
-/build-plain-*/
-/corpus.zip
-/distinctuseridcompetition
-/errortests
-/examples/quickstart/quickstart
-/examples/quickstart/simdjson.cpp
-/examples/quickstart/simdjson.h
-/examples/quickstart/twitter.json
-/fuzz/fuzz_dump
-/fuzz/fuzz_dump_raw_tape
-/fuzz/fuzz_parser
-/fuzz/fuzz_print_json
-/get_corpus_benchmark
-/json2json
-/jsoncheck
-/jsoncheck_westmere
-/jsoncheck_fallback
-/jsonpointer
-/jsonstats
-/integer_tests
-/libsimdjson.so*
-/minifiercompetition
-/minify
-/numberparsingcheck
-/ossfuzz-out
-/out
-/parse
-/parse_many_test
-/parse_nonumberparsing
-/parse_nostringparsing
-/parse_noutf8validation
-/parse_stream
-/parseandstatcompetition
-/parsingcompetition
-/perfdiff
-/pointercheck
-/readme_examples
-/readme_examples_noexceptions
-/statisticalmodel
-/stringparsingcheck
-/submodules
-/ujdecode.o
-/amalgamation_demo.cpp
-/simdjson.cpp
-/simdjson.h
-/singleheader/amalgamation_demo
-/singleheader/demo
-/tests/basictests
-/tests/errortests
-/tests/jsoncheck
-/tests/pointercheck
-/tests/integer_tests
-/tests/parse_many_test
-/tests/readme_examples
-/tests/readme_examples_noexceptions
-/tools/json2json
-/tools/jsonstats
-/tools/minify
-
-# Don't check in generated API docs
-/doc/api
-
-# Don't check in generated examples
-/jsonexamples/generated
-
 # C++ ignore from https://github.com/github/gitignore/blob/master/C%2B%2B.gitignore
 
 # Prerequisites
@@ -167,23 +83,27 @@ objs
 *.app
 
 
-### https://raw.github.com/github/gitignore/e92f8db7a027af8cc25da2dc0758317e39697684/CMake.gitignore
-
-CMakeLists.txt.user
-CMakeCache.txt
-CMakeFiles
-CMakeScripts
-Testing
-Makefile
-cmake_install.cmake
-install_manifest.txt
-compile_commands.json
-CTestTestfile.cmake
-_deps
-
 # CMake files that may be specific to our installation
-/CPackConfig.cmake
-/CPackSourceConfig.cmake
-# We check in a custom version of root Makefile that is not generated by CMake
-!/Makefile
 
+# Build outputs
+/build*/
+/visual_studio/
+
+# Fuzzer outputs generated by instructions in fuzz/Fuzzing.md
+/corpus.zip
+/ossfuzz-out/
+/out/
+
+# Generated docs
+/doc/api
+*.orig
+
+# VSCode workspace files
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+# clangd
+.cache

.gitmodules

@@ -1,33 +0,0 @@
-[submodule "scalarvssimd/rapidjson"]
-	path = dependencies/rapidjson
-	url = https://github.com/Tencent/rapidjson.git
-[submodule "dependencies/sajson"]
-	path = dependencies/sajson
-	url = https://github.com/chadaustin/sajson.git
-[submodule "dependencies/json11"]
-	path = dependencies/json11
-	url = https://github.com/dropbox/json11.git
-[submodule "dependencies/fastjson"]
-	path = dependencies/fastjson
-	url = https://github.com/mikeando/fastjson.git
-[submodule "dependencies/gason"]
-	path = dependencies/gason
-	url = https://github.com/vivkin/gason.git
-[submodule "dependencies/ujson4c"]
-	path = dependencies/ujson4c
-	url = https://github.com/esnme/ujson4c.git
-[submodule "dependencies/jsmn"]
-	path = dependencies/jsmn
-	url = https://github.com/zserge/jsmn.git
-[submodule "dependencies/cJSON"]
-	path = dependencies/cJSON
-	url = https://github.com/DaveGamble/cJSON.git
-[submodule "dependencies/jsoncpp"]
-	path = dependencies/jsoncpp
-	url = https://github.com/open-source-parsers/jsoncpp.git
-[submodule "dependencies/json"]
-	path = dependencies/json
-	url = https://github.com/nlohmann/json.git
-[submodule "dependencies/benchmark"]
-	path = dependencies/benchmark
-	url = https://github.com/google/benchmark.git

.travis.yml

@@ -1,30 +1,190 @@
 language: cpp
-sudo: false
+
-addons:
+dist: bionic
-  apt:
+
-    sources:
+arch:
-      - ubuntu-toolchain-r-test
+  - ppc64le
-    packages:
+
-      - gcc-7
+cache:
-      - g++-7
+  directories:
-      - clang-format
+    - $HOME/.dep_cache
-      - python
+
-branches:
+env:
-  only:
+  global:
-    - master
+    - simdjson_DEPENDENCY_CACHE_DIR=$HOME/.dep_cache
+
+matrix:
+  include:
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-8
+      env:
+        - COMPILER="CC=gcc-8 && CXX=g++-8"
+      compiler: gcc-8
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-9
+      env:
+        - COMPILER="CC=gcc-9 && CXX=g++-9"
+      compiler: gcc-9
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-10
+      env:
+        - COMPILER="CC=gcc-10 && CXX=g++-10"
+      compiler: gcc-10
+
+# The sanitizer runs fail systematically
+#    - os: linux
+#      addons:
+#        apt:
+#          sources:
+#            - ubuntu-toolchain-r-test
+#          packages:
+#            - g++-10
+#      env:
+#        - COMPILER="CC=gcc-10 && CXX=g++-10"
+#        - SANITIZE="on"
+#      compiler: gcc-10-sanitize
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-10
+      env:
+        - COMPILER="CC=gcc-10 && CXX=g++-10"
+        - STATIC="on"
+      compiler: gcc-10-static
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-6.0
+          packages:
+            - clang-6.0
+      env:
+        - COMPILER="CC=clang-6.0 && CXX=clang++-6.0"
+      compiler: clang-6
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-7
+          packages:
+            - clang-7
+      env:
+        - COMPILER="CC=clang-7 && CXX=clang++-7"
+      compiler: clang-7
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-8
+          packages:
+            - clang-8
+      env:
+        - COMPILER="CC=clang-8 && CXX=clang++-8"
+      compiler: clang-8
+
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-9
+          packages:
+            - clang-9
+      env:
+        - COMPILER="CC=clang-9 && CXX=clang++-9"
+      compiler: clang-9
+
+    - os: linux
+      addons:
+        apt:
+          packages:
+            - clang-10
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+      env:
+        - COMPILER="CC=clang-10 && CXX=clang++-10"
+      compiler: clang-10
+
+    - os: linux
+      addons:
+        apt:
+          packages:
+            - clang-10
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+      env:
+        - COMPILER="CC=clang-10 && CXX=clang++-10"
+        - STATIC="on"
+      compiler: clang-10-static
+
+# The clang sanitizer runs fail frequently at setup time
+#    - os: linux
+#      addons:
+#        apt:
+#          packages:
+#            - clang-10
+#          sources:
+#            - ubuntu-toolchain-r-test
+#            - sourceline: 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
+#              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+#      env:
+#        - COMPILER="CC=clang-10 && CXX=clang++-10"
+#        - SANITIZE="on"
+#      compiler: clang-10-sanitize
+
+before_install:
+  - eval "${COMPILER}"
+
+install:
+  - wget -q -O - "https://raw.githubusercontent.com/simdjson/debian-ppa/master/key.gpg" | sudo apt-key add -
+  - sudo apt-add-repository "deb https://raw.githubusercontent.com/simdjson/debian-ppa/master simdjson main"
+  - sudo apt-get -qq update
+  - sudo apt-get purge cmake cmake-data
+  - sudo apt-get -t simdjson -y install cmake
+  - export CMAKE_CXX_FLAGS="-maltivec -mcpu=power9 -mtune=power9"
+  - export CMAKE_C_FLAGS="${CMAKE_CXX_FLAGS}"
+  - export CMAKE_FLAGS="-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS} -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} -DSIMDJSON_IMPLEMENTATION=ppc64;fallback";
+  - if [[ "${SANITIZE}" == "on" ]]; then
+      export CMAKE_FLAGS="${CMAKE_FLAGS} -DSIMDJSON_SANITIZE=ON";
+      export ASAN_OPTIONS="detect_leaks=0";
+    fi
+  - if [[ "${STATIC}" == "on" ]]; then
+      export CMAKE_FLAGS="${CMAKE_FLAGS} -DBUILD_SHARED_LIBS=OFF";
+    fi
+  - export CTEST_FLAGS="-j4 --output-on-failure -LE explicitonly"
 
 script:
-   - export CXX=g++-7
+  - mkdir build
-   - export CC=gcc-7
+  - cd build
-   - make
+  - cmake $CMAKE_FLAGS ..
-   - make test 
+  - cmake --build . -- -j2
-   - make everything
+  - SIMDJSON_FORCE_IMPLEMENTATION=ppc64 ctest $CTEST_FLAGS -L per_implementation
-   - make amalgamate
+  - SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation
-   - make clean
+  - ctest $CTEST_FLAGS -LE "acceptance|per_implementation"
-   - make SANITIZEGOLD=1 test
-   - make clean
-   - ARCHFLAGS="-march=nehalem" make 
-   - ARCHFLAGS="-march=nehalem" make test
-   - ARCHFLAGS="-march=nehalem" make everything
-   - ./style/run-clang-format.py -r include/ benchmark/ src/ tests/
-

.vscode/extensions.json

@@ -0,0 +1,22 @@
+{
+	// See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.
+	// Extension identifier format: ${publisher}.${name}. Example: vscode.csharp
+
+	// List of extensions which should be recommended for users of this workspace.
+	"recommendations": [
+		// C++
+		"llvm-vs-code-extensions.vscode-clangd",
+		"xaver.clang-format",
+		// Python
+		"ms-python.python",
+		// .github/*
+		"github.vscode-github-actions",
+		// cmake
+		"ms-vscode.cmake-tools",
+		"twxs.cmake"
+	],
+	// List of extensions recommended by VS Code that should not be recommended for users of this workspace.
+	"unwantedRecommendations": [
+
+	]
+}

.vscode/settings.json

@@ -0,0 +1,134 @@
+{
+    "editor.rulers": [
+        {"column": 95 },
+        {"column": 120 }
+    ],
+    "cmake.configureArgs": [
+        "-DSIMDJSON_DEVELOPER_MODE=ON"
+    ],
+    "files.trimTrailingWhitespace": true,
+    "files.associations": {
+        ".clangd": "yaml",
+        "array": "cpp",
+        "iterator": "cpp",
+        "chrono": "cpp",
+        "optional": "cpp",
+        "__locale": "cpp",
+        "__tuple": "cpp",
+        "__bit_reference": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__functional_base": "cpp",
+        "__hash_table": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__nullptr": "cpp",
+        "__split_buffer": "cpp",
+        "__string": "cpp",
+        "__threading_support": "cpp",
+        "__tree": "cpp",
+        "algorithm": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "cinttypes": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "codecvt": "cpp",
+        "complex": "cpp",
+        "condition_variable": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "exception": "cpp",
+        "forward_list": "cpp",
+        "fstream": "cpp",
+        "functional": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "list": "cpp",
+        "locale": "cpp",
+        "map": "cpp",
+        "memory": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numeric": "cpp",
+        "ostream": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "regex": "cpp",
+        "set": "cpp",
+        "sstream": "cpp",
+        "stack": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "thread": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "unordered_set": "cpp",
+        "utility": "cpp",
+        "valarray": "cpp",
+        "vector": "cpp",
+        "*.ipp": "cpp",
+        "__functional_base_03": "cpp",
+        "filesystem": "cpp",
+        "*.inc": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "variant": "cpp",
+        "__bits": "cpp",
+        "csignal": "cpp",
+        "future": "cpp",
+        "queue": "cpp",
+        "shared_mutex": "cpp",
+        "ranges": "cpp",
+        "span": "cpp",
+        "__verbose_abort": "cpp",
+        "charconv": "cpp",
+        "source_location": "cpp",
+        "strstream": "cpp",
+        "typeindex": "cpp",
+        "*.tcc": "cpp",
+        "memory_resource": "cpp",
+        "numbers": "cpp",
+        "semaphore": "cpp",
+        "stop_token": "cpp",
+        "cfenv": "cpp",
+        "format": "cpp",
+        "xlocmes": "cpp",
+        "xlocmon": "cpp",
+        "xlocnum": "cpp",
+        "xloctime": "cpp",
+        "xutility": "cpp",
+        "coroutine": "cpp",
+        "xfacet": "cpp",
+        "xhash": "cpp",
+        "xiosbase": "cpp",
+        "xlocale": "cpp",
+        "xlocbuf": "cpp",
+        "xlocinfo": "cpp",
+        "xmemory": "cpp",
+        "xstring": "cpp",
+        "xtr1common": "cpp",
+        "xtree": "cpp"
+    }
+}

AI_USAGE_POLICY.md

@@ -0,0 +1,56 @@
+# AI Usage Policy
+
+Contributors can use whatever tools they would like to
+craft their contributions, but there must be a **human in the loop**.
+**Contributors must read and review all LLM-generated code or text before they
+ask other project members to review it.** The contributor is always the author
+and is fully accountable for their contributions. Contributors should be
+sufficiently confident that the contribution is high enough quality that asking
+for a review is a good use of scarce maintainer time, and they should be **able
+to answer questions about their work** during review.
+
+We expect that new contributors will be less confident in their contributions,
+and our guidance to them is to **start with small contributions** that they can
+fully understand to build confidence. We aspire to be a welcoming community
+that helps new contributors grow their expertise, but learning involves taking
+small steps, getting feedback, and iterating. Passing maintainer feedback to an
+LLM doesn't help anyone grow, and does not sustain our community.
+
+This policy includes, but is not limited to, the following kinds of
+contributions:
+
+- Code, usually in the form of a pull request
+- Issues or security vulnerabilities
+- Comments and feedback on pull requests
+
+## Extractive Contributions
+
+The reason for our "human-in-the-loop" contribution policy is that processing
+patches, PRs, RFCs, and comments is not free -- it takes a lot of
+maintainer time and energy to review those contributions! Sending the
+unreviewed output of an LLM to open source project maintainers *extracts* work
+from them in the form of design and code review, so we call this kind of
+contribution an "extractive contribution".
+
+## Transparency
+
+For contributions involving significant AI assistance, we encourage you to disclose
+its use and explain your process. If a submission appears to rely heavily on AI
+without disclosure, we may doubt that the **human-in-the-loop** requirement has
+been met. Please show awareness of your use of AI.
+
+## Copyright
+
+Artificial intelligence systems raise many questions around copyright that have
+yet to be answered. Our policy on AI tools is similar to our copyright policy:
+Contributors are responsible for ensuring that they have the right to
+contribute code under the terms of our license, typically meaning that either
+they, their employer, or their collaborators hold the copyright. Using AI tools
+to regenerate copyrighted material does not remove the copyright, and
+contributors are responsible for ensuring that such material does not appear in
+their contributions. Contributions found to violate this policy will be removed
+just like any other offending contribution.
+
+## Reference
+
+- [LLVM AI Tool Use Policy](https://discourse.llvm.org/t/rfc-llvm-ai-tool-policy-human-in-the-loop/89159)

AUTHORS

@@ -1,3 +1,4 @@
-# List of authors for copyright purposes
+# List of authors for copyright purposes, in no particular order
 Daniel Lemire
 Geoff Langdale
+John Keiser

CMakeLists.txt

@@ -1,103 +1,479 @@
-cmake_minimum_required(VERSION 3.9) # CMP0069 NEW
+cmake_minimum_required(VERSION 3.14)
 
-if (NOT CMAKE_BUILD_TYPE)
+# Build performance optimizations
-  message(STATUS "No build type selected, default to Release")
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "Export compile commands for faster IDE integration")
-  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+# Enable parallel compilation on MSVC
+if(MSVC)
+  add_compile_options(/MP)
 endif()
 
-project(simdjson
+project(
-  DESCRIPTION "Parsing gigabytes of JSON per second"
+    simdjson
-  LANGUAGES CXX
+    # The version number is modified by tools/release.py
+    VERSION 4.6.1
+    DESCRIPTION "Parsing gigabytes of JSON per second"
+    HOMEPAGE_URL "https://simdjson.org/"
+    LANGUAGES CXX C
 )
 
-# LTO seems to create all sorts of fun problems. Let us
+set(SIMDJSON_GITHUB_REPOSITORY "https://github.com/simdjson/simdjson")
-# disable temporarily.
-#include(CheckIPOSupported)
-#check_ipo_supported(RESULT ltoresult)
-#if(ltoresult)
-#  set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
-#endif()
 
-set(CMAKE_CXX_STANDARD 17)
+string(
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+    COMPARE EQUAL
-set(CMAKE_MACOSX_RPATH OFF)
+    "${CMAKE_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}"
-set(CMAKE_THREAD_PREFER_PTHREAD ON)
+    is_top_project
-set(THREADS_PREFER_PTHREAD_FLAG ON)
+)
 
-set(SIMDJSON_LIB_NAME simdjson)
+# ---- Options, variables ----
-set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 3)
-set(PROJECT_VERSION_PATCH 1)
-set(SIMDJSON_LIB_VERSION "0.3.1" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "1" CACHE STRING "simdjson library soversion")
 
-option(SIMDJSON_IMPLEMENTATION_HASWELL "Include the haswell implementation" ON)
+# These version numbers are modified by tools/release.py
-option(SIMDJSON_IMPLEMENTATION_WESTMERE "Include the westmere implementation" ON)
+set(SIMDJSON_LIB_VERSION "33.0.0" CACHE STRING "simdjson library version")
-option(SIMDJSON_IMPLEMENTATION_ARM64 "Include the arm64 implementation" ON)
+set(SIMDJSON_LIB_SOVERSION "33" CACHE STRING "simdjson library soversion")
-option(SIMDJSON_IMPLEMENTATION_FALLBACK "Include the fallback implementation" ON)
+
-if(NOT MSVC)
+option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson (only makes sense if BUILD_SHARED_LIBS=ON)" OFF)
-  option(SIMDJSON_BUILD_STATIC "Build a static library" OFF) # turning it on disables the production of a dynamic library
+if(SIMDJSON_BUILD_STATIC_LIB AND NOT BUILD_SHARED_LIBS)
+  message(WARNING "SIMDJSON_BUILD_STATIC_LIB only makes sense if BUILD_SHARED_LIBS is set to ON")
+  message(WARNING "You might be building and installing a two identical static libraries.")
+endif()
+
+option(SIMDJSON_ENABLE_THREADS "Link with thread support" ON)
+
+include(cmake/simdjson-props.cmake)
+include(cmake/implementation-flags.cmake)
+include(cmake/exception-flags.cmake)
+
+option(SIMDJSON_DISABLE_DEPRECATED_API "Disables deprecated APIs" OFF)
+if(SIMDJSON_DISABLE_DEPRECATED_API)
+  simdjson_add_props(
+      target_compile_definitions PUBLIC
+      SIMDJSON_DISABLE_DEPRECATED_API=1
+  )
+endif()
+
+if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.25.0")
+    option(SIMDJSON_STATIC_REFLECTION "Enables static reflection (experimental), requires C++26" OFF)
 else()
-  option(SIMDJSON_BUILD_STATIC "Build a static library" ON) # turning it on disables the production of a dynamic library
+    set(SIMDJSON_STATIC_REFLECTION OFF CACHE BOOL "Enables static reflection (experimental)" FORCE)
+    message(WARNING "SIMDJSON_STATIC_REFLECTION is disabled because your CMake version is below 3.25")
 endif()
-option(SIMDJSON_SANITIZE "Sanitize addresses" OFF)
-option(SIMDJSON_GOOGLE_BENCHMARKS "compile the Google Benchmark benchmarks" OFF)
-option(SIMDJSON_ENABLE_THREADS "enable threaded operation" ON)
-option(SIMDJSON_EXCEPTIONS "Enable simdjson's exception-throwing interface" ON)
 
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/tools/cmake")
+if(SIMDJSON_STATIC_REFLECTION)
+  simdjson_add_props(
+      target_compile_definitions PUBLIC
+      SIMDJSON_STATIC_REFLECTION=1
+  )
+endif()
 
-find_package(CTargets)
+option(SIMDJSON_DEVELOPMENT_CHECKS "Enable development-time aids, such as \
-find_package(Options)
+checks for incorrect API usage. Enabled by default in DEBUG." OFF)
+if(SIMDJSON_DEVELOPMENT_CHECKS)
+  simdjson_add_props(
+      target_compile_definitions PUBLIC
+      SIMDJSON_DEVELOPMENT_CHECKS
+  )
+endif()
 
-# We used to have install(DIRECTORY include/${SIMDJSON_LIB_NAME} DESTINATION include)
+if(is_top_project)
-# alone.
+  option(SIMDJSON_INSTALL "Enable target install" ON)
-# However, this fails because we also need the root level simdjson.h file.
+  option(SIMDJSON_DEVELOPER_MODE "Enable targets for developing simdjson" OFF)
-install(DIRECTORY include/${SIMDJSON_LIB_NAME} DESTINATION include)
+  option(BUILD_SHARED_LIBS "Build simdjson as a shared library" OFF)
-install(FILES include/${SIMDJSON_LIB_NAME}.h DESTINATION include)
+  option(SIMDJSON_SINGLEHEADER "Disable singleheader generation" ON)
-set (TEST_DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/jsonchecker/")
+else()
-set (BENCHMARK_DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/jsonexamples/")
+  option(SIMDJSON_INSTALL "Enable target install" ${BUILD_SHARED_LIBS})
-add_definitions(-DSIMDJSON_TEST_DATA_DIR="${TEST_DATA_DIR}")
+endif()
-add_definitions(-DSIMDJSON_BENCHMARK_DATA_DIR="${TEST_DATA_DIR}")
-enable_testing()
-include(include/CMakeLists.txt)
-add_subdirectory(src)
-add_subdirectory(tools)
-add_subdirectory(tests)
-add_subdirectory(benchmark)
 
-if (SIMDJSON_GOOGLE_BENCHMARKS)
+include(cmake/handle-deprecations.cmake)
-  if(NOT EXISTS dependencies/benchmark/CMakeLists.txt)
+include(cmake/developer-options.cmake)
-    # message(STATUS "Unable to find dependencies/benchmark/CMakeLists.txt")
+
-    execute_process(COMMAND git submodule update --init -- dependencies/benchmark
+# ---- simdjson library ----
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(SIMDJSON_SOURCES src/simdjson.cpp)
+
+add_library(simdjson ${SIMDJSON_SOURCES})
+add_library(simdjson::simdjson ALIAS simdjson)
+set(SIMDJSON_LIBRARIES simdjson)
+
+# Check for <bit> header compatibility
+include(CheckIncludeFileCXX)
+check_include_file_cxx(bit SIMDJSON_HAS_BIT_HEADER)
+
+# Enable precompiled headers for faster builds
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
+  set(SIMDJSON_PRECOMPILE_HEADERS
+    <algorithm>
+    <array>
+    <atomic>
+    <cassert>
+    <cctype>
+    <cerrno>
+    <cstddef>
+    <cstdint>
+    <cstdlib>
+    <cstring>
+    <memory>
+    <string>
+    <utility>
+    <vector>
+  )
+
+  if(SIMDJSON_HAS_BIT_HEADER)
+    list(APPEND SIMDJSON_PRECOMPILE_HEADERS <bit>)
   endif()
-  option(BENCHMARK_ENABLE_TESTING OFF)
+
-  set(BENCHMARK_ENABLE_TESTING OFF)
+  target_precompile_headers(simdjson PRIVATE ${SIMDJSON_PRECOMPILE_HEADERS})
-  option(BENCHMARK_ENABLE_INSTALL OFF)
-  set(BENCHMARK_ENABLE_INSTALL OFF)
-  add_subdirectory(dependencies/benchmark)
 endif()
 
-# for fuzzing, read the comments in the fuzz/CMakeLists.txt file
+if(SIMDJSON_BUILD_STATIC_LIB)
-option(ENABLE_FUZZING "enable building the fuzzers" ON)
+  add_library(simdjson_static STATIC ${SIMDJSON_SOURCES})
-if(ENABLE_FUZZING)
+  add_library(simdjson::simdjson_static ALIAS simdjson_static)
-  add_subdirectory(fuzz)
+  list(APPEND SIMDJSON_LIBRARIES simdjson_static)
+
+  # Reuse precompiled headers for static library
+  if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
+    target_precompile_headers(simdjson_static REUSE_FROM simdjson)
+  endif()
 endif()
 
-set(CPACK_PACKAGE_VENDOR "Daniel Lemire")
+set_target_properties(
-set(CPACK_PACKAGE_CONTACT "lemire@gmail.com")
+    simdjson PROPERTIES
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Parsing gigabytes of JSON per second")
+    VERSION "${SIMDJSON_LIB_VERSION}"
-set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
+    SOVERSION "${SIMDJSON_LIB_SOVERSION}"
-set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
+    # FIXME: symbols should be hidden by default
-set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
+    WINDOWS_EXPORT_ALL_SYMBOLS YES
-set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
+)
-set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
 
-set(CPACK_RPM_PACKAGE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
+# FIXME: Use proper CMake integration for exports
+if(WIN32 AND BUILD_SHARED_LIBS)
+  target_compile_definitions(
+      simdjson
+      PRIVATE SIMDJSON_BUILDING_WINDOWS_DYNAMIC_LIBRARY=1
+      INTERFACE SIMDJSON_USING_WINDOWS_DYNAMIC_LIBRARY=1
+  )
+endif()
 
-set(CPACK_SOURCE_GENERATOR "TGZ;ZIP")
+simdjson_add_props(
+    target_include_directories
+    PUBLIC "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>"
+    PRIVATE "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>"
+)
 
-include(CPack)
+# Optimize linker settings for faster builds
+if(MSVC)
+  target_link_options(simdjson PRIVATE /INCREMENTAL)
+  if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    target_link_options(simdjson PRIVATE /DEBUG:FASTLINK)
+  endif()
+endif()
 
 
+
+if(SIMDJSON_STATIC_REFLECTION)
+
+
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION MATCHES "^21")
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} --version
+        OUTPUT_VARIABLE CLANG_VERSION_OUTPUT
+        ERROR_VARIABLE CLANG_VERSION_ERROR
+        RESULT_VARIABLE CLANG_VERSION_RESULT
+    )
+    if(CLANG_VERSION_RESULT EQUAL 0 AND CLANG_VERSION_OUTPUT MATCHES "https://github.com/bloomberg/clang-p2996.git")
+        set(IS_BLOOMBERG_P2996_CLANG ON)
+        message(STATUS "Using Bloomberg P2996 Clang fork")
+    endif()
+  endif()
+
+  # We would like to require C++26, but no compiler supports that!
+  # This is a hack:
+  if(IS_BLOOMBERG_P2996_CLANG)
+  simdjson_add_props(
+      target_compile_options PUBLIC
+      -freflection -fexpansion-statements -stdlib=libc++ -std=c++26
+  )
+  else()
+  simdjson_add_props(
+      target_compile_options PUBLIC
+      -freflection -std=c++26
+  )
+  endif()
+else()
+  simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
+endif()
+
+# workaround for GNU GCC poor AVX load/store code generation
+if(
+    CMAKE_CXX_COMPILER_ID STREQUAL "GNU"
+    AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(i.86|x86(_64)?)$"
+)
+  simdjson_add_props(
+      target_compile_options PRIVATE
+      -mno-avx256-split-unaligned-load -mno-avx256-split-unaligned-store
+  )
+endif()
+
+option(SIMDJSON_MINUS_ZERO_AS_FLOAT "Treat -0 as a floating-point value" OFF)
+
+if(SIMDJSON_MINUS_ZERO_AS_FLOAT)
+  simdjson_add_props(target_compile_definitions PRIVATE SIMDJSON_MINUS_ZERO_AS_FLOAT=1)
+endif(SIMDJSON_MINUS_ZERO_AS_FLOAT)
+
+# GCC and Clang have horrendous Debug builds when using SIMD.
+# A common fix is to use '-Og' instead.
+# bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412
+if(
+    (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR
+        CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR
+        CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+)
+  message(STATUS "Adding -Og to compile flag")
+  simdjson_add_props(
+      target_compile_options PRIVATE
+      $<$<CONFIG:DEBUG>:-Og>
+  )
+  # We still want to enable development checks in Debug mode
+  simdjson_add_props(
+      target_compile_definitions PUBLIC
+      SIMDJSON_DEVELOPMENT_CHECKS
+  )
+  endif()
+
+if(SIMDJSON_ENABLE_THREADS)
+  find_package(Threads REQUIRED)
+  simdjson_add_props(target_link_libraries PUBLIC Threads::Threads)
+  simdjson_add_props(target_compile_definitions PUBLIC SIMDJSON_THREADS_ENABLED=1)
+endif()
+
+simdjson_apply_props(simdjson)
+if(SIMDJSON_BUILD_STATIC_LIB)
+  simdjson_apply_props(simdjson_static)
+endif()
+
+# ---- Install rules ----
+
+if(SIMDJSON_INSTALL)
+    include(CMakePackageConfigHelpers)
+    include(GNUInstallDirs)
+
+    if(SIMDJSON_SINGLEHEADER)
+      install(
+          FILES singleheader/simdjson.h
+          DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+          COMPONENT simdjson_Development
+      )
+    endif()
+
+    install(
+        TARGETS simdjson
+        EXPORT simdjsonTargets
+        RUNTIME COMPONENT simdjson_Runtime
+        LIBRARY COMPONENT simdjson_Runtime
+        NAMELINK_COMPONENT simdjson_Development
+        ARCHIVE COMPONENT simdjson_Development
+        INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+    )
+    configure_file(cmake/simdjson-config.cmake.in simdjson-config.cmake @ONLY)
+
+    write_basic_package_version_file(
+        simdjson-config-version.cmake
+        COMPATIBILITY SameMinorVersion
+    )
+
+    set(
+        SIMDJSON_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/simdjson"
+        CACHE STRING "CMake package config location relative to the install prefix"
+    )
+    mark_as_advanced(SIMDJSON_INSTALL_CMAKEDIR)
+
+    install(
+        FILES
+        "${PROJECT_BINARY_DIR}/simdjson-config.cmake"
+        "${PROJECT_BINARY_DIR}/simdjson-config-version.cmake"
+        DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
+        COMPONENT simdjson_Development
+    )
+
+    install(
+        EXPORT simdjsonTargets
+        NAMESPACE simdjson::
+        DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
+        COMPONENT simdjson_Development
+    )
+
+    if(SIMDJSON_BUILD_STATIC_LIB)
+      install(
+          TARGETS simdjson_static
+          EXPORT simdjson_staticTargets
+          ARCHIVE COMPONENT simdjson_Development
+          INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+      )
+      install(
+          EXPORT simdjson_staticTargets
+          NAMESPACE simdjson::
+          DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
+          COMPONENT simdjson_Development
+      )
+    endif()
+
+    # pkg-config
+    include(cmake/JoinPaths.cmake)
+    join_paths(PKGCONFIG_INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
+    join_paths(PKGCONFIG_LIBDIR "\${prefix}" "${CMAKE_INSTALL_LIBDIR}")
+
+    if(SIMDJSON_ENABLE_THREADS)
+      set(PKGCONFIG_CFLAGS "-DSIMDJSON_THREADS_ENABLED=1")
+      if(CMAKE_THREAD_LIBS_INIT)
+        set(PKGCONFIG_LIBS_PRIVATE "Libs.private: ${CMAKE_THREAD_LIBS_INIT}")
+      endif()
+    endif()
+
+    configure_file("simdjson.pc.in" "simdjson.pc" @ONLY)
+    install(
+        FILES "${CMAKE_CURRENT_BINARY_DIR}/simdjson.pc"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
+    )
+endif()
+
+#
+# CPack
+#
+if(is_top_project)
+  set(CPACK_PACKAGE_VENDOR "Daniel Lemire")
+  set(CPACK_PACKAGE_CONTACT "lemire@gmail.com")
+  set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE")
+  set(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README.md")
+
+  set(CPACK_RPM_PACKAGE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE")
+
+  set(CPACK_SOURCE_GENERATOR "TGZ;ZIP")
+
+  include(CPack)
+endif()
+
+# ---- Developer mode extras ----
+
+if(is_top_project AND NOT SIMDJSON_DEVELOPER_MODE)
+  message(STATUS "Building only the library. Advanced users and contributors may want to turn SIMDJSON_DEVELOPER_MODE to ON, e.g., via -D SIMDJSON_DEVELOPER_MODE=ON.")
+elseif(SIMDJSON_DEVELOPER_MODE AND NOT is_top_project)
+  message(AUTHOR_WARNING "Developer mode in simdjson is intended for the developers of simdjson")
+endif()
+
+if(NOT SIMDJSON_DEVELOPER_MODE)
+  return()
+endif()
+
+simdjson_apply_props(simdjson-internal-flags)
+
+set(
+    SIMDJSON_USER_CMAKECACHE
+    "${CMAKE_BINARY_DIR}/.simdjson-user-CMakeCache.txt"
+)
+add_custom_target(
+    simdjson-user-cmakecache
+    COMMAND "${CMAKE_COMMAND}"
+    -D "BINARY_DIR=${CMAKE_BINARY_DIR}"
+    -D "USER_CMAKECACHE=${SIMDJSON_USER_CMAKECACHE}"
+    -P "${PROJECT_SOURCE_DIR}/cmake/simdjson-user-cmakecache.cmake"
+    VERBATIM
+)
+
+# Setup tests
+enable_testing()
+# So we can build just tests with "make all_tests"
+add_custom_target(all_tests)
+
+add_subdirectory(windows)
+include(cmake/CPM.cmake)
+add_subdirectory(dependencies) ## This needs to be before tools because of cxxopts
+add_subdirectory(tools)  ## This needs to be before tests because of cxxopts
+
+# Data: jsonexamples is left with only the bare essential.
+# most of the data has been moved to https://github.com/simdjson/simdjson-data
+add_subdirectory(jsonexamples)
+
+if(SIMDJSON_SINGLEHEADER)
+add_subdirectory(singleheader)
+endif()
+
+
+
+#
+# Compile tools / tests / benchmarks
+#
+add_subdirectory(tests)
+add_subdirectory(examples)
+if(CMAKE_SIZEOF_VOID_P EQUAL 8) # we only include the benchmarks on 64-bit systems.
+  add_subdirectory(benchmark)
+endif()
+add_subdirectory(fuzz)
+
+#
+# Source files should be just ASCII
+#
+find_program(FIND_CMD find)
+find_program(FILE_CMD file)
+find_program(GREP_CMD grep)
+if(FIND_CMD AND FILE_CMD AND GREP_CMD)
+  add_test(
+      NAME just_ascii
+      COMMAND sh -c "\
+non_ascii=$(${FIND_CMD} include src windows tools singleheader tests examples benchmark \
+  -path benchmark/checkperf-reference -prune -name '*.h' -o -name '*.cpp' \
+  -type f -exec ${FILE_CMD} '{}' \; | ${GREP_CMD} -v ASCII); \
+if [ -n \"$non_ascii\" ]; then \
+  echo 'The following files contain non-ASCII characters:'; \
+  echo \"$non_ascii\"; \
+  exit 1; \
+fi"
+      WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
+  )
+else()
+  message(WARNING "just_ascii test disabled because required tools were not found: find='${FIND_CMD}', file='${FILE_CMD}', grep='${GREP_CMD}'")
+endif()
+
+##
+## In systems like R, libraries must not use stderr or abort to be acceptable.
+## Thus we make it a hard rule that one is not allowed to call abort or stderr.
+## The sanitized builds are allowed to abort.
+##
+if(NOT SIMDJSON_SANITIZE)
+  find_program(GREP grep)
+  find_program(NM nm)
+  if((NOT GREP) OR (NOT NM))
+    message("grep and nm are unavailable on this system.")
+  else()
+    add_test(
+      NAME "avoid_abort"
+      # Under FreeBSD, the __cxa_guard_abort symbol may appear but it is fine.
+      # So we want to look for <space><possibly _>abort as a test.
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdjson> |  ${GREP} ' _*abort' || exit 0  && exit 1"
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+    add_test(
+      NAME "avoid_cout"
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdjson> |  ${GREP} ' _*cout' || exit 0  && exit 1"
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+    add_test(
+      NAME "avoid_cerr"
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdjson> |  ${GREP} ' _*cerr' || exit 0  && exit 1"
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+    add_test(
+      NAME "avoid_printf"
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdjson> |  ${GREP} ' _*printf' || exit 0  && exit 1"
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+    add_test(
+      NAME "avoid_stdout"
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdjson> |  ${GREP} stdout || exit 0 && exit 1"
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+    add_test(
+      NAME "avoid_stderr"
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdjson> |  ${GREP} stderr || exit 0 && exit 1"
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+  endif()
+endif()

CONTRIBUTING.md

@@ -32,25 +32,79 @@ We discourage the following types of contributions:
 
 In short, most code changes should either bring new features or better performance. We want to avoid unmotivated code changes.
 
-Guidelines
+
+Specific rules
+----------
+
+We have few hard rules, but we have some:
+
+- Printing to standard output or standard error (`stderr`, `stdout`, `std::cerr`, `std::cout`) in the core library is forbidden. This follows from the [Writing R Extensions](https://cran.r-project.org/doc/manuals/R-exts.html) manual which states that "Compiled code should not write to stdout or stderr".
+- Calls to `abort()` are forbidden in the core library. This follows from the [Writing R Extensions](https://cran.r-project.org/doc/manuals/R-exts.html) manual which states that "Under no circumstances should your compiled code ever call abort or exit".
+- All source code files (.h, .cpp) must be ASCII.
+- All C macros introduced in public headers need to be prefixed with either `SIMDJSON_` or `simdjson_`.
+- We avoid trailing white space characters within lines. That is, your lines of code should not terminate with unnecessary spaces. Generally, please avoid making unnecessary changes to white-space characters when contributing code.
+
+Tools, tests and benchmarks are not held to these same strict rules.
+
+General Guidelines
 ----------
 
 Contributors are encouraged to :
 
 - Document their changes. Though we do not enforce a rule regarding code comments, we prefer that non-trivial algorithms and techniques be somewhat documented in the code.
-- Follow as much as possible the existing code style. We do not enforce a specific code style, but we prefer consistency.
+- Follow as much as possible the existing code style. We do not enforce a specific code style, but we prefer consistency. We avoid contractions (isn't, aren't) in the comments.
 - Modify as few lines of code as possible when working on an issue. The more lines you modify, the harder it is for your fellow human beings to understand what is going on.
-- Tools may report "problems" with the code, but we never delegate programming to tools: if there is a problem with the code, we need to understand it. Thus we will not "fix" code merely to please a static analyzer if we do not understand.
+- Tools may report "problems" with the code, but we never delegate programming to tools: if there is a problem with the code, we need to understand it. Thus we will not "fix" code merely to please a static analyzer.
 - Provide tests for any new feature. We will not merge a new feature without tests.
+- Run before/after benchmarks so that we can appreciate the effect of the changes on the performance.
+
+Pull Requests
+--------------
+
+Pull requests are always invited. However, we ask that you follow these guidelines:
+
+- It is wise to discuss your ideas first as part of an issue before you start coding. If you omit this step and code first, be prepared to have your code receive scrutiny and be dropped.
+- Users should provide a rationale for their changes. Does it improve performance? Does it add a feature? Does it improve maintainability? Does it fix a bug? This must be explicitly stated as part of the pull request. Do not propose changes based on taste or intuition. We do not delegate programming to tools: that some tool suggested a code change is not reason enough to change the code.
+   1. When your code improves performance, please document the gains with a benchmark using hard numbers.
+   2. If your code fixes a bug, please either fix a failing test, or propose a new test.
+   3. Other types of changes must be clearly motivated. We openly discourage changes with no identifiable benefits.
+- Changes should be focused and minimal. You should change as few lines of code as possible. Please do not reformat or touch files needlessly.
+- New features must be accompanied by new tests, in general.
+- Your code should pass our continuous-integration tests. It is your responsibility to ensure that your proposal pass the tests. We do not merge pull requests that would break our build.
+   - An exception to this would be changes to non-code files, such as documentation and assets, or trivial changes to code, such as comments, where it is encouraged to explicitly ask for skipping a CI run using the `[skip ci]` prefix in your Pull Request title **and** in the first line of the most recent commit in a push. Example for such a commit: `[skip ci] Fixed typo in power_of_ten's docs`
+   This benefits the project in such a way that the CI pipeline is not burdened by running jobs on changes that don't change any behavior in the code, which reduces wait times for other Pull Requests that do change behavior and require testing.
+
+If the benefits of your proposed code remain unclear, we may choose to discard your code: that is not an insult, we frequently discard our own code. We may also consider various alternatives and choose another path. Again, that is not an insult or a sign that you have wasted your time.
+
+Style
+-----
+
+Our formatting style is inspired by the LLVM style.
+The simdjson library is written using the snake case: when a variable or a function is a phrase,  each space is replaced by an underscore character, and the first letter of each word written in lowercase.  Compile-time constants are written entirely in uppercase with the same underscore convention.
 
 Code of Conduct
 ---------------
 
 Though we do not have a formal code of conduct, we will not tolerate bullying, bigotry or
-intimidation. Everyone is welcome to contribute.
+intimidation. Everyone is welcome to contribute. If you have concerns, you can raise them privately with the core team members (e.g., D. Lemire, J. Keiser).
+
+We welcome contributions from women and less represented groups. If you need help, please reach out.
+
+Consider the following points when engaging with the project:
+
+- We discourage arguments from authority: ideas are discussed on their own merits and not based on who stated it.
+- Be mindful that what you may view as an aggression is maybe merely a difference of opinion or a misunderstanding.
+- Be mindful that a collection of small aggressions, even if mild in isolation, can become harmful.
 
 Getting Started Hacking
 -----------------------
 
 An overview of simdjson's directory structure, with pointers to architecture and design
 considerations and other helpful notes, can be found at [HACKING.md](HACKING.md).
+
+
+
+AI Usage Policy
+---------------
+
+Please also review our [AI Usage Policy](AI_USAGE_POLICY.md).

CONTRIBUTORS

@@ -31,5 +31,15 @@ Paul Dreik
 Jeremie Piotte
 Matthew Wilson
 Dušan Jovanović
+Matjaž Ostroveršnik
+Nong Li
+Furkan Taşkale
+Brendan Knapp
+Danila Kutenin
+Pavel Pavlov
+Hao Chen
+Nicolas Boyer
+Kim Walisch and Jatin Bhateja (AVX-512 bitset decoder)
+Fangzheng Zhang and Weiqiang Wan (AVX-512 kernel)
 # if you have contributed to the project and your name does not
 # appear in this list, please let us know!

Dockerfile

@@ -1,10 +0,0 @@
-# docker build -t simdjson . && docker run --privileged -t simdjson
-FROM gcc:8.3
-COPY . /usr/src/
-WORKDIR /usr/src/
-RUN make clean
-RUN make amalgamate
-RUN make
-RUN make test
-RUN make parsingcompetition
-CMD ["bash", "scripts/selectparser.sh"]

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         =
+PROJECT_NUMBER         = "4.6.1"
 
 # 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
@@ -51,7 +51,7 @@ PROJECT_BRIEF          = "Ridiculously Fast JSON"
 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
 # the logo to the output directory.
 
-PROJECT_LOGO           =
+PROJECT_LOGO           = images/logotiny.png
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
 # into which the generated documentation will be written. If a relative path is
@@ -829,7 +829,7 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = include
+INPUT                  = doc include/simdjson include/simdjson/dom include/simdjson/generic
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -1026,7 +1026,7 @@ FILTER_SOURCE_PATTERNS =
 # (index.html). This can be useful if you have a project on for instance GitHub
 # and want to reuse the introduction page also for the doxygen output.
 
-USE_MDFILE_AS_MAINPAGE =
+USE_MDFILE_AS_MAINPAGE = doc/basics_doxygen.md
 
 #---------------------------------------------------------------------------
 # Configuration options related to source browsing
@@ -1246,7 +1246,10 @@ HTML_STYLESHEET        =
 # list). For an example see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_EXTRA_STYLESHEET  =
+
+HTML_EXTRA_STYLESHEET  = theme/doxygen-awesome.css \
+                         theme/doxygen-awesome-sidebar-only.css \
+                         theme/doxygen-awesome-sidebar-only-darkmode-toggle.css
 
 # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the HTML output directory. Note
@@ -1256,7 +1259,10 @@ HTML_EXTRA_STYLESHEET  =
 # files will be copied as-is; there are no commands or markers available.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_EXTRA_FILES       =
+HTML_EXTRA_FILES       = theme/doxygen-awesome-darkmode-toggle.js \
+                         theme/doxygen-awesome-interactive-toc.js \
+                         theme/doxygen-awesome-fragment-copy-button.js \
+                         theme/doxygen-awesome-paragraph-link.js
 
 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
 # will adjust the colors in the style sheet and background images according to
@@ -1543,7 +1549,7 @@ DISABLE_INDEX          = NO
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-GENERATE_TREEVIEW      = NO
+GENERATE_TREEVIEW      = YES
 
 # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
 # doxygen will group on one line in the generated HTML documentation.

HACKING.md

@@ -1,363 +1,385 @@
+
 Hacking simdjson
 ================
 
-Here is wisdom about how to build, test and run simdjson from within the repository. *Users* of
+Here is wisdom about how to build, test and run simdjson from within the repository. This is mostly useful for people who plan to contribute simdjson, or maybe study the design.
-simdjson should use the released simdjson.h and simdjson.cpp files.
 
-Directory Structure and Source
+If you plan to contribute to simdjson, please read our [CONTRIBUTING](https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md) guide.
+
+- [Hacking simdjson](#hacking-simdjson)
+  - [Build Quickstart](#build-quickstart)
+  - [Design notes](#design-notes)
+  - [Developer mode](#developer-mode)
+  - [Directory Structure and Source](#directory-structure-and-source)
+  - [Runtime Dispatching](#runtime-dispatching)
+  - [Regenerating Single-Header Files](#regenerating-single-header-files)
+  - [Usage (CMake on 64-bit platforms like Linux, FreeBSD or macOS)](#usage-cmake-on-64-bit-platforms-like-linux-freebsd-or-macos)
+  - [Usage (CMake on 64-bit Windows using Visual Studio 2019 or better)](#usage-cmake-on-64-bit-windows-using-visual-studio-2019-or-better)
+  - [Various References](#various-references)
+
+Build Quickstart
 ------------------------------
 
-simdjson's source structure, from the top level, looks like this:
+For non-Windows system,
-
-* **Makefile:** The main Makefile for Linux. This is not the same as CMakeLists.txt.
-* **CMakeLists.txt:** A Makefile generator for non-default cases and options.
-* **include:** User-facing declarations and inline definitions (most user-facing functions are inlined).
-  * simdjson.h: A "master include" that includes files from include/simdjson/. This is equivalent to
-    the distributed simdjson.h.
-  * simdjson/*.h: Declarations for public simdjson classes and functions.
-  * simdjson/inline/*.h: Definitions for public simdjson classes and functions.
-* **src:** The source files for non-inlined functionality (e.g. the architecture-specific parser
-  implementations).
-  * simdjson.cpp: A "master source" that includes all implementation files from src/. This is
-    equivalent to the distributed simdjson.cpp.
-  * arm64/|fallback/|haswell/|westmere/: Architecture-specific implementations. All functions are 
-    Each architecture defines its own namespace, e.g. simdjson::haswell.
-  * generic/: Generic implementations of the simdjson parser. These files may be included and
-    compiled multiple times, from whichever architectures use them. They assume they are already
-    enclosed in a namespace, e.g.:
-    ```c++
-    namespace simdjson::haswell {
-      #include "generic/stage1_find_marks.h"
-    }
-    ```
-
-Other important files and directories:
-* **.drone.yml:** Definitions for Drone CI.
-* **.appveyor.yml:** Definitions for Appveyor CI (Windows).
-* **.circleci:** Definitions for Circle CI.
-* **amalgamation.sh:** Generates singleheader/simdjson.h and singleheader/simdjson.cpp for release.
-* **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. If you're not sure what else to do to check your performance, this is always a good start:
-  ```bash
-  make parse && ./parse jsonexamples/twitter.json
-  ```
-* **fuzz:** The source for fuzz testing. This lets us explore important edge and middle cases
-  automatically, and is run in CI.
-* **jsonchecker:** A set of JSON files used to check different functionality of the parser.
-  * **pass*.json:** Files that should pass validation.
-  * **fail*.json:** Files that should fail validation.
-* **jsonexamples:** A wide spread of useful, real-world JSON files with different characteristics
-  and sizes.
-* **singleheader:** Contains generated simdjson.h and simdjson.cpp that we release.
-* **test:** The tests are here. basictests.cpp and errortests.cpp are the primary ones.
-* **tools:** Source for executables that can be distributed with simdjson
-
-> **Don't modify the files in singleheader/ directly; these are automatically generated.**
-> 
-> While we distribute those files on release, we *maintain* the files under include/ and src/.
-
-While simdjson distributes just two files from the singleheader/ directory, we *maintain* the code in
-multiple files under include/ and src/. include/simdjson.h and src/simdjson.cpp are the "spine" for
-these, and you can include
-
-Regenerating Single Headers From Master
----------------------------------------
-
-simdjson.h and simdjson.cpp are not always up to date in master. To ensure you have the latest copy,
-you can regenerate them by running this at the top level:
 
 ```bash
-make amalgamate
+cmake -B -D SIMDJSON_DEVELOPER_MODE=ON ..
+cmake --build build
+ctest --test-dir build
 ```
 
-The amalgamator is at `amalgamation.sh` at the top level. It generates singleheader/simdjson.h by
+It is similar for Visual Studio users, please see the CMake or Visual Studio documentation.
-reading through include/simdjson.h, copy/pasting each header file into the amalgamated file at the
-point it gets included (but only once per header). singleheader/simdjson.cpp is generated from
-src/simdjson.cpp the same way, except files under generic/ may be included and copy/pasted multiple
-times.
 
-### Usage (old-school Makefile on platforms like Linux or macOS)
+By default the library is built in Release mode.
 
-Requirements: recent clang or gcc, and make. We recommend at least GNU GCC/G++ 7 or LLVM clang 6. A 64-bit system like Linux or macOS is expected.
 
-To test:
+Assertions and development checks
+------------------------------
 
-```
+We do not use conventional `assert` in simdjson. Instead we use the macro
-make
+`SIMDJSON_ASSUME`:
-make test
+
+```cpp
+SIMDJSON_ASSUME(something_that_is_true());
 ```
 
-To run benchmarks:
+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
-make parse
+#if SIMDJSON_DEVELOPMENT_CHECKS
-./parse jsonexamples/twitter.json
+// do sanity checks here
 ```
 
-Under Linux, the `parse` command gives a detailed analysis of the performance counters.
 
-To run comparative benchmarks (with other parsers):
+Working with sanitizers
+------------------------------
 
-```
+The simdjson library must be memory-safe. We cannot allow buffer overruns.
-make benchmark
+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
 ```
 
-### Usage (CMake on 64-bit platforms like Linux or macOS)
 
-Requirements: We require a recent version of cmake. On macOS, the easiest way to install cmake might be to use [brew](https://brew.sh) and then type
+Design notes
-
+------------------------------
-```
-brew install cmake
-```
-
-There is an [equivalent brew on Linux which works the same way as well](https://linuxbrew.sh).
-
-You need a recent compiler like clang or gcc. We recommend at least GNU GCC/G++ 7 or LLVM clang 6. For example, you can install a recent compiler with brew:
-
-```
-brew install gcc@8
-```
-
-Optional: You need to tell cmake which compiler you wish to use by setting the CC and CXX variables. Under bash, you can do so with commands such as `export CC=gcc-7` and `export CXX=g++-7`.
-
-Building: While in the project repository, do the following:
-
-```
-mkdir build
-cd build
-cmake ..
-make
-make test
-```
-
-CMake will build a library. By default, it builds a shared library (e.g., libsimdjson.so on Linux).
-
-You can build a static library:
-
-```
-mkdir buildstatic
-cd buildstatic
-cmake -DSIMDJSON_BUILD_STATIC=ON ..
-make
-make test
-```
-
-In some cases, you may want to specify your compiler, especially if the default compiler on your system is too old. You may proceed as follows:
-
-```
-brew install gcc@8
-mkdir build
-cd build
-export CXX=g++-8 CC=gcc-8
-cmake ..
-make
-make test
-```
-
-### Usage (CMake on 64-bit Windows using Visual Studio)
-
-We assume you have a common 64-bit Windows PC with at least Visual Studio 2017 and an x64 processor with AVX2 support (2013 Intel Haswell or later) or SSE 4.2 + CLMUL (2010 Westmere or later).
-
-- Grab the simdjson code from GitHub, e.g., by cloning it using [GitHub Desktop](https://desktop.github.com/).
-- Install [CMake](https://cmake.org/download/). When you install it, make sure to ask that `cmake` be made available from the command line. Please choose a recent version of cmake.
-- Create a subdirectory within simdjson, such as `VisualStudio`.
-- Using a shell, go to this newly created directory.
-- Type `cmake -DCMAKE_GENERATOR_PLATFORM=x64 ..` in the shell while in the `VisualStudio` repository. (Alternatively, if you want to build a DLL, you may use the command line `cmake -DCMAKE_GENERATOR_PLATFORM=x64 -DSIMDJSON_BUILD_STATIC=OFF ..`.)
-- This last command (`cmake ...`) created a Visual Studio solution file in the newly created directory (e.g., `simdjson.sln`). Open this file in Visual Studio. You should now be able to build the project and run the tests. For example, in the `Solution Explorer` window (available from the `View` menu), right-click `ALL_BUILD` and select `Build`. To test the code, still in the `Solution Explorer` window, select `RUN_TESTS` and select `Build`.
-
-### Usage (Using `vcpkg` on 64-bit Windows, Linux and macOS)
-
-[vcpkg](https://github.com/Microsoft/vcpkg) users on Windows, Linux and macOS can download and install `simdjson` with one single command from their favorite shell.
-
-On 64-bit Linux and macOS:
-
-```
-$ ./vcpkg install simdjson
-```
-
-will build and install `simdjson` as a static library.
-
-On Windows (64-bit):
-
-```
-.\vcpkg.exe install simdjson:x64-windows
-```
-
-will build and install `simdjson` as a shared library.
-
-```
-.\vcpkg.exe install simdjson:x64-windows-static  
-```
-
-will build and install `simdjson` as a static library.
-
-These commands will also print out instructions on how to use the library from MSBuild or CMake-based projects.
-
-If you find the version of `simdjson` shipped with `vcpkg` is out-of-date, feel free to report it to
-`vcpkg` community either by submitting an issue or by creating a PR.
-
-### Usage (Docker)
-
-One can run tests and benchmarks using docker. It especially makes sense under Linux. Privileged
-access may be needed to get performance counters.
-
-```
-git clone https://github.com/simdjson/simdjson.git
-cd simdjson
-docker build -t simdjson .
-docker run --privileged -t simdjson
-```
-
-## Architecture and Design Notes
-
-### Requirements
-
-- 64-bit platforms like Linux or macOS, as well as Windows through Visual Studio 2017 or later.
-- Any 64-bit processor:
-  - AVX2 (i.e., Intel processors starting with the Haswell microarchitecture released 2013 and AMD
-    processors starting with the Zen microarchitecture released 2017),
-  - SSE 4.2 and CLMUL (i.e., Intel processors going back to Westmere released in 2010 or AMD
-    processors starting with the Jaguar used in the PS4 and XBox One),
-  - 64-bit ARM processor (ARMv8-A NEON): this covers a wide range of mobile processors, including
-    all Apple processors currently available for sale, going as far back as the iPhone 5s (2013).
-  - Any 64-bit processor (simdjson has a fallback generic 64-bit implementation that is still super
-    fast).
-- A recent C++ compiler (e.g., GNU GCC or LLVM CLANG or Visual Studio 2017), we assume C++17. GNU
-  GCC 7 or better or LLVM's clang 6 or better.
-- Some benchmark scripts assume bash and other common utilities, but they are optional.
-
-### Scope
-
-We provide a fast parser, that fully validates an input according to various specifications.
-The parser builds a useful immutable (read-only) DOM (document-object model) which can be later accessed.
-
-To simplify the engineering, we make some assumptions.
-
-- We support UTF-8 (and thus ASCII), nothing else (no Latin, no UTF-16). We do not believe this is a
-  genuine limitation, because we do not think there is any serious application that needs to process
-  JSON data without an ASCII or UTF-8 encoding. If the UTF-8 contains a leading BOM, it should be
-  omitted: the user is responsible for detecting and skipping the BOM; UTF-8 BOMs are discouraged.
-- All strings in the JSON document may have up to 4294967295 bytes in UTF-8 (4GB). To enforce this
-  constraint, we refuse to parse a document that contains more than 4294967295 bytes (4GB). This
-  should accommodate most JSON documents.
-- As allowed by the specification, we allow repeated keys within an object (other parsers like
-  sajson do the same).
-- [The simdjson library is fast for JSON documents spanning a few bytes up to many megabytes](https://github.com/lemire/simdjson/issues/312).
-
-_We do not aim to provide a general-purpose JSON library._ A library like RapidJSON offers much more
-than just parsing, it helps you generate JSON and offers various other convenient functions. We
-merely parse the document. This may change in the future.
-
-### Features
-
-- The input string is unmodified. (Parsers like sajson and RapidJSON use the input string as a buffer.)
-- We parse integers and floating-point numbers as separate types which allows us to support large signed 64-bit integers in [-9223372036854775808,9223372036854775808), like a Java `long` or a C/C++ `long long` and large unsigned integers up to the value 18446744073709551615. Among the parsers that differentiate between integers and floating-point numbers, not all support 64-bit integers. (For example, sajson rejects JSON files with integers larger than or equal to 2147483648. RapidJSON will parse a file containing an overly long integer like 18446744073709551616 as a floating-point number.) When we cannot represent exactly an integer as a signed or unsigned 64-bit value, we reject the JSON document.
-- We support the full range of 64-bit floating-point numbers (binary64). The values range from ` std::numeric_limits<double>::lowest()`  to `std::numeric_limits<double>::max()`, so from -1.7976e308 all the way to 1.7975e308. Extreme values (less or equal to -1e308, greater or equal to 1e308) are rejected: we refuse to parse the input document.
-- We test for accurate float parsing with a perfect accuracy (ULP 0). Many parsers offer only approximate floating parsing. For example, RapidJSON also offers the option of accurate float parsing (`kParseFullPrecisionFlag`) but it comes at a significant performance penalty compared to the default settings. By default, RapidJSON tolerates an error of 3 ULP.
-- We do full UTF-8 validation as part of the parsing. (Parsers like fastjson, gason and dropbox json11 do not do UTF-8 validation. The sajson parser does incomplete UTF-8 validation, accepting code point
-sequences like 0xb1 0x87.)
-- We fully validate the numbers. (Parsers like gason and ultranjson will accept `[0e+]` as valid JSON.)
-- We validate string content for unescaped characters. (Parsers like fastjson and ultrajson accept unescaped line breaks and tabs in strings.)
-- We fully validate the white-space characters outside of the strings. Parsers like RapidJSON will accept JSON documents with null characters outside of strings.
-
-### Architecture
 
 The parser works in two stages:
 
 - Stage 1. (Find marks) Identifies quickly structure elements, strings, and so forth. We validate UTF-8 encoding at that stage.
 - Stage 2. (Structure building) Involves constructing a "tree" of sort (materialized as a tape) to navigate through the data. Strings and numbers are parsed at this stage.
 
-### Remarks on JSON parsing
 
-- The JSON spec defines what a JSON parser is:
+The role of stage 1 is to identify pseudo-structural characters as quickly as possible. A character is pseudo-structural if and only if:
-  > A JSON parser transforms a JSON text into another representation. A JSON parser MUST accept all texts that conform to the JSON grammar. A JSON parser MAY accept non-JSON forms or extensions. An implementation may set limits on the size of texts that it accepts. An implementation may set limits on the maximum depth of nesting. An implementation may set limits on the range and precision of numbers. An implementation may set limits on the length and character contents of strings.
-
-* JSON is not JavaScript:
-
-  > All JSON is Javascript but NOT all Javascript is JSON. So {property:1} is invalid because property does not have double quotes around it. {'property':1} is also invalid, because it's single quoted while the only thing that can placate the JSON specification is double quoting. JSON is even fussy enough that {"property":.1} is invalid too, because you should have of course written {"property":0.1}. Also, don't even think about having comments or semicolons, you guessed it: they're invalid. (credit:https://github.com/elzr/vim-json)
-
-* The structural characters are:
-
-      begin-array     =  [ left square bracket
-      begin-object    =  { left curly bracket
-      end-array       =  ] right square bracket
-      end-object      =  } right curly bracket
-      name-separator  = : colon
-      value-separator = , comma
-
-### Pseudo-structural elements
-
-A character is pseudo-structural if and only if:
 
 1. Not enclosed in quotes, AND
 2. Is a non-whitespace character, AND
 3. Its preceding character is either:
    (a) a structural character, OR
-   (b) whitespace.
+   (b) whitespace OR
+   (c) the final quote in a string.
 
 This helps as we redefine some new characters as pseudo-structural such as the characters 1, G, n in the following:
 
 > { "foo" : 1.5, "bar" : 1.5 GEOFF_IS_A_DUMMY bla bla , "baz", null }
 
-## About the Project
+Stage 1 also does unicode validation.
 
-### Bindings and Ports of simdjson
+Stage 2 handles all of the rest: number parsings, recognizing atoms like true, false, null, and so forth.
 
-We distinguish between "bindings" (which just wrap the C++ code) and a port to another programming language (which reimplements everything).
+Developer mode
+--------------
+
+Build system targets that are only useful for developers of the simdjson
+library are behind the `SIMDJSON_DEVELOPER_MODE` option. Enabling this option
+makes tests, examples, benchmarks and other developer targets available. Not
+enabling this option means that you are a consumer of simdjson and thus you
+only get the library targets and options.
+
+Developer mode is forced to be on when the `CI` environment variable is set to
+a value that CMake recognizes as "on", which is set to `true` in all of the CI
+workflows used by simdjson.
+
+Directory Structure and Source
+------------------------------
+
+Before diving into the directory structure, here are key concepts used in the codebase:
+
+- **Amalgamated File**: A file that is conditionally included in the amalgamation process. These are wrapped in `#ifndef SIMDJSON_CONDITIONAL_INCLUDE` blocks and are included based on the target implementation (e.g., ARM64, x86). They include implementation-specific files (e.g., `arm64.h`) and generic files (e.g., under `generic/`). Amalgamated files have associated dependency files (`dependencies.h`) to track includes.
+
+- **Amalgamator File**: A file that orchestrates the inclusion of amalgamated files. Examples: `arm64.h`, `arm64/implementation.h`, `generic/amalgamated.h`. These are not themselves amalgamated but control conditional inclusions.
+
+- **Free Dependency File**: A top-level header that is always included unconditionally. These do not have dependency files and represent the public API (e.g., main headers).
+
+- **Implementation-Specific File**: A file tied to a specific CPU architecture or instruction set (e.g., `arm64/`, `haswell/`). These must be amalgamated.
+
+- **Generic File**: A shared file (under `generic/` or `simdjson/generic/`) that contains common code included once per implementation.
+
+- **Builtin File**: Special files under `simdjson/builtin/` that handle the builtin implementation, a fallback/default implementation used when no optimized implementation is available.
+
+- **Conditional Include Block**: A section wrapped in `#ifndef SIMDJSON_CONDITIONAL_INCLUDE` for editor-only or implementation-specific content.
+
+The script `singleheader/amalgation_helper.py` will generate an HTML report which you can use to visualize the status of each file.
+
+simdjson's source structure, from the top level, looks like this:
+
+* **CMakeLists.txt:** The main build system.
+* **include:** User-facing declarations and inline definitions (most user-facing functions are inlined).
+  * simdjson.h: the `simdjson` namespace. A "main include" that includes files from include/simdjson/. This is equivalent to
+    the distributed simdjson.h.
+    * simdjson/*.h: Declarations for public simdjson classes and functions.
+    * simdjson/*-inl.h: Definitions for public simdjson classes and functions.
+    * simdjson/internal/*.h: the `simdjson::internal` namespace. Private classes and functions used by the rest of simdjson.
+  * simdjson/dom.h: the `simdjson::dom` namespace. Includes all public DOM classes.
+    * simdjson/dom/*.h: Declarations/definitions for individual DOM classes.
+  * simdjson/arm64|fallback|haswell|icelake|ppc64|westmere.h: `simdjson::<implementation>` namespace. Common implementation-specific tools like number and string parsing, as well as minification.
+    * simdjson/arm64|fallback|haswell|icelake|ppc64|westmere/*.h: implementation-specific functions such as , etc.
+    * simdjson/generic/*.h: the bulk of the actual code, written generically and compiled for each implementation, using functions defined in the implementation's .h files.
+      * simdjson/generic/dependencies.h: dependencies on common, non-implementation-specific simdjson classes. This will be included before including amalgamated.h.
+      * simdjson/generic/amalgamated.h: all generic ondemand classes for an implementation.
+  * simdjson/ondemand.h: the `simdjson::ondemand` namespace. Includes all public ondemand classes.
+    * simdjson/builtin.h: the `simdjson::builtin` namespace. Aliased to the most universal implementation available.
+    * simdjson/builtin/ondemand.h: the `simdjson::builtin::ondemand` namespace.
+    * simdjson/arm64|fallback|haswell|icelake|ppc64|westmere/ondemand.h: the `simdjson::<implementation>::ondemand` namespace. On-Demand compiled for the specific implementation.
+    * simdjson/generic/ondemand/*.h: individual On-Demand classes, generically written.
+      * simdjson/generic/ondemand/dependencies.h: dependencies on common, non-implementation-specific simdjson classes. This will be included before including amalgamated.h.
+      * simdjson/generic/ondemand/amalgamated.h: all generic ondemand classes for an implementation.
+  * simdjson/builder.h: the `simdjson::builder` namespace. Includes all public builder classes.
+    * simdjson/builtin/builder.h: the `simdjson::builtin::builder` namespace.
+    * simdjson/arm64|fallback|haswell|icelake|ppc64|westmere/builder.h: the `simdjson::<implementation>::builder` namespace. Builder compiled for the specific implementation.
+    * simdjson/generic/builder/*.h: individual Builder classes, generically written.
+      * simdjson/generic/builder/dependencies.h: dependencies on common, non-implementation-specific simdjson classes. This will be included before including amalgamated.h.
+      * simdjson/generic/builder/amalgamated.h: all generic builder classes for an implementation.
+* **src:** The source files for non-inlined functionality (e.g. the architecture-specific parser
+  implementations).
+  * simdjson.cpp: A "main source" that includes all implementation files from src/. This is
+    equivalent to the distributed simdjson.cpp.
+  * *.cpp: other misc. implementations, such as `simdjson::implementation` and the minifier.
+  * arm64|fallback|haswell|icelake|ppc64|westmere.cpp: Architecture-specific parser implementations.
+    * generic/*.h: `simdjson::<implementation>` namespace. Generic implementation of the parser, particularly the `dom_parser_implementation`.
+    * generic/stage1/*.h: `simdjson::<implementation>::stage1` namespace. Generic implementation of the simd-heavy tokenizer/indexer pass of the simdjson parser. Used for the On-Demand interface
+    * 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:
+* **.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/amalgation_helper.py:** Generates and `amalgamation_report.html` that helps you understand the status of each file.
+* **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:
+  ```bash
+  mkdir build
+  cd build
+  cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
+  cmake --build . --config Release
+  benchmark/dom/parse ../jsonexamples/twitter.json
+  ```
+  The last line becomes `./benchmark/Release/parse.exe ../jsonexample/twitter.json` under Windows. You may also use Google Benchmark:
+  ```bash
+  mkdir build
+  cd build
+  cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
+  cmake --build . --target bench_parse_call --config Release
+  ./benchmark/bench_parse_call
+  ```
+  The last line becomes `./benchmark/Release/bench_parse_call.exe` under Windows. Under Windows, you can also build with the clang compiler by adding `-T ClangCL` to the call to `cmake ..`: `cmake -T ClangCL ..`.
+* **fuzz:** The source for fuzz testing. This lets us explore important edge and middle cases
+* **fuzz:** The source for fuzz testing. This lets us explore important edge and middle cases
+  automatically, and is run in CI.
+* **jsonchecker:** A set of JSON files used to check different functionality of the parser.
+  * **pass*.json:** Files that should pass validation.
+  * **fail*.json:** Files that should fail validation.
+  * **jsonchecker/minefield/y_*.json:** Files that should pass validation.
+  * **jsonchecker/minefield/n_*.json:** Files that should fail validation.
+* **jsonexamples:** A wide spread of useful, real-world JSON files with different characteristics
+  and sizes.
+* **test:** The tests are here. basictests.cpp and errortests.cpp are the primary ones.
+* **tools:** Source for executables that can be distributed with simdjson. Some examples:
+  * `json2json mydoc.json` parses the document, constructs a model and then dumps back the result to standard output.
+  * `json2json -d mydoc.json` parses the document, constructs a model and then dumps model (as a tape) to standard output. The tape format is described in the accompanying file `tape.md`.
+  * `minify mydoc.json` minifies the JSON document, outputting the result to standard output. Minifying means to remove the unneeded white space characters.
+  * `jsonpointer mydoc.json <jsonpath> <jsonpath> ... <jsonpath>` parses the document, constructs a model and then processes a series of [JSON Pointer paths](https://tools.ietf.org/html/rfc6901). The result is itself a JSON document.
 
 
-- [ZippyJSON](https://github.com/michaeleisel/zippyjson): Swift bindings for the simdjson project.
+> **Don't modify the files in singleheader/ directly; these are automatically generated.**
-- [pysimdjson](https://github.com/TkTech/pysimdjson): Python bindings for the simdjson project.
-- [simdjson-rs](https://github.com/Licenser/simdjson-rs): Rust port.
-- [simdjson-rust](https://github.com/SunDoge/simdjson-rust): Rust wrapper (bindings).
-- [SimdJsonSharp](https://github.com/EgorBo/SimdJsonSharp): C# version for .NET Core (bindings and full port).
-- [simdjson_nodejs](https://github.com/luizperes/simdjson_nodejs): Node.js bindings for the simdjson project.
-- [simdjson_php](https://github.com/crazyxman/simdjson_php): PHP bindings for the simdjson project.
-- [simdjson_ruby](https://github.com/saka1/simdjson_ruby): Ruby bindings for the simdjson project.
-- [simdjson-go](https://github.com/minio/simdjson-go): Go port using Golang assembly.
-- [rcppsimdjson](https://github.com/eddelbuettel/rcppsimdjson): R bindings.
 
-### Tools
 
-- `json2json mydoc.json` parses the document, constructs a model and then dumps back the result to standard output.
+While simdjson distributes just two files from the singleheader/ directory, we *maintain* the code in
-- `json2json -d mydoc.json` parses the document, constructs a model and then dumps model (as a tape) to standard output. The tape format is described in the accompanying file `tape.md`.
+multiple files under include/ and src/. The files include/simdjson.h and src/simdjson.cpp are the "spine" for
-- `minify mydoc.json` minifies the JSON document, outputting the result to standard output. Minifying means to remove the unneeded white space characters.
+these, and you can include them as if they were the corresponding singleheader/ files.
-- `jsonpointer mydoc.json <jsonpath> <jsonpath> ... <jsonpath>` parses the document, constructs a model and then processes a series of [JSON Pointer paths](https://tools.ietf.org/html/rfc6901). The result is itself a JSON document.
 
-### In-depth comparisons
 
-If you want to see how a wide range of parsers validate a given JSON file:
 
-```
+Runtime Dispatching
-make allparserscheckfile
+--------------------
-./allparserscheckfile myfile.json
+
+A key feature of simdjson is the ability to compile different processing kernels, optimized for specific instruction sets, and to select
+the most appropriate kernel at runtime. This ensures that users get the very best performance while still enabling simdjson to run everywhere.
+This technique is frequently called runtime dispatching. The simdjson achieves runtime dispatching entirely in C++: we do not assume
+that the user is building the code using CMake, for example.
+
+To make runtime dispatching work, it is critical that the code be compiled for the lowest supported processor. In particular, you should
+not use flags such as -mavx2, /arch:AVX2 and so forth while compiling simdjson. When you do so, you allow the compiler to use advanced
+instructions. In turn, these advanced instructions present in the code may cause a runtime failure if the runtime processor does not
+support them. Even a simple loop, compiled with these flags, might generate binary code that only run on advanced processors.
+
+So we compile simdjson for a generic processor. Our users should do the same if they want simdjson's runtime dispatch to work. It is important
+to understand that if runtime dispatching does not work, then simdjson will cause crashes on older processors. Of course, if a user chooses
+to compile their code for a specific instruction set (e.g., AVX2), they are responsible for the failures if they later run their code
+on a processor that does not support AVX2. Yet, if we were to entice these users to do so, we would share the blame: thus we carefully instruct
+users to compile their code in a generic way without doing anything to enable advanced instructions.
+
+
+We only use runtime dispatching on x64 (AMD/Intel) platforms, at the moment. On ARM processors, we would need a standard way to query, at runtime,
+the processor for its supported features. We do not know how to do so on ARM systems in general. Thankfully it is not yet a concern: 64-bit ARM
+processors are fairly uniform as far as the instruction sets they support.
+
+
+In all cases, simdjson uses advanced instructions by relying on  "intrinsic functions": we do not write assembly code. The intrinsic functions
+are special functions that the compiler might recognize and translate into fast code. To make runtime dispatching work, we rely on the fact that
+the header providing these instructions
+(intrin.h under Visual Studio, x86intrin.h elsewhere) defines all of the intrinsic functions, including those that are not supported
+processor.
+
+At this point, we are require to use one of two main strategies.
+
+1. On POSIX systems, the main compilers (LLVM clang, GNU gcc) allow us to use any intrinsic function after including the header, but they fail to inline the resulting instruction if the target processor does not support them. Because we compile for a generic processor, we would not be able to use most intrinsic functions. Thankfully, more recent versions of these compilers allow us to flag a region of code with a specific target, so that we can compile only some of the code with support for advanced instructions. Thus in our C++, one might notice macros like `TARGET_HASWELL`. It is then our responsibility, at runtime, to only run the regions of code (that we call kernels) matching the properties of the runtime processor. The benefit of this approach is that the compiler not only let us use intrinsic functions, but it can also optimize the rest of the code in the kernel with advanced instructions we enabled.
+
+2. Under Visual Studio, the problem is somewhat simpler. Visual Studio will not only provide the intrinsic functions, but it will also allow us to use them. They will compile just fine. It is at runtime that they may cause a crash. So we do not need to mark regions of code for compilation toward advanced processors (e.g., with  `TARGET_HASWELL` macros). The downside of the Visual Studio approach is that the compiler is not allowed to use advanced instructions others than those we specify. In principle, this means that Visual Studio has weaker optimization opportunities.
+
+
+
+We also handle the special case where a user is compiling using LLVM clang under Windows, [using the Visual Studio toolchain](https://devblogs.microsoft.com/cppblog/clang-llvm-support-in-visual-studio/). If you compile with LLVM clang under Visual Studio, then the header files (intrin.h or x86intrin.h) no longer provides the intrinsic functions that are unsupported by the processor. This appears to be deliberate on the part of the LLVM engineers. With a few lines of code, we handle this scenario just like LLVM clang under a POSIX system, but forcing the inclusion of the specific headers, and rolling our own intrinsic function as needed.
+
+
+
+
+
+Regenerating Single-Header Files
+---------------------------------------
+
+The simdjson.h and simdjson.cpp files in the singleheader directory are not always up-to-date with the rest of the code; they are only ever
+systematically regenerated on releases. To ensure you have the latest code, you can regenerate them by running this at the top level:
+
+```bash
+mkdir build
+cd build
+cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
+cmake --build . # needed, because currently dependencies do not work fully for the amalgamate target
+cmake --build . --target amalgamate
 ```
 
-For performance comparisons:
+You need to have python3 installed on your system.
 
+The amalgamator script `amalgamate.py` generates singleheader/simdjson.h by
+reading through include/simdjson.h, copy/pasting each header file into the amalgamated file at the
+point it gets included (but only once per header). singleheader/simdjson.cpp is generated from
+src/simdjson.cpp the same way, except files under generic/ may be included and copy/pasted multiple
+times.
+
+## Usage (CMake on 64-bit platforms like Linux, FreeBSD or macOS)
+
+Requirements: In addition to git, we require a recent version of CMake as well as bash.
+
+1. On macOS, the easiest way to install cmake might be to use [brew](https://brew.sh) and then type
 ```
-make parsingcompetition
+brew install cmake
-./parsingcompetition myfile.json
+```
+2. Under Linux, you might be able to install CMake as follows:
+```
+apt-get update -qq
+apt-get install -y cmake
+```
+3. On FreeBSD, you might be able to install bash and CMake as follows:
+```
+pkg update -f
+pkg install bash
+pkg install cmake
 ```
 
-For broader comparisons:
+You need a recent compiler like clang or gcc. We recommend at least GNU GCC/G++ 7 or LLVM clang 6.
+
+
+Building: While in the project repository, do the following:
 
 ```
-make allparsingcompetition
+mkdir build
-./allparsingcompetition myfile.json
+cd build
+cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
+cmake --build .
+ctest
 ```
 
-Both the `parsingcompetition` and `allparsingcompetition` tools take a `-t` flag which produces
+CMake will build a library. By default, it builds a static library (e.g., libsimdjson.a on Linux).
-a table-oriented output that can be conveniently parsed by other tools.
 
-### Various References
+You can build a shared library:
+
+```
+mkdir buildshared
+cd buildshared
+cmake -D BUILD_SHARED_LIBS=ON -D SIMDJSON_DEVELOPER_MODE=ON ..
+cmake --build .
+ctest
+```
+
+In some cases, you may want to specify your compiler, especially if the default compiler on your system is too old.  You need to tell cmake which compiler you wish to use by setting the CC and CXX variables. Under bash, you can do so with commands such as `export CC=gcc-7` and `export CXX=g++-7`. You can also do it as part of the `cmake` command: `cmake -DCMAKE_CXX_COMPILER=g++ ..`.  You may proceed as follows:
+
+```
+brew install gcc@8
+mkdir build
+cd build
+export CXX=g++-8 CC=gcc-8
+cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
+cmake --build .
+ctest
+```
+
+If your compiler does not default on C++11 support or better you may get failing tests. If so, you may be able to exclude the failing  tests by replacing `ctest` with `ctest  -E "^quickstart$"`.
+
+Note that the name of directory (`build`) is arbitrary, you can name it as you want (e.g., `buildgcc`) and you can have as many different such directories as you would like (one per configuration).
+
+## Usage (CMake on 64-bit Windows using Visual Studio 2019 or better)
+
+Recent versions of Visual Studio support CMake natively, [please refer to the Visual Studio documentation](https://learn.microsoft.com/en-us/cpp/build/cmake-projects-in-visual-studio?view=msvc-170).
+
+We assume you have a common 64-bit Windows PC with at least Visual Studio 2019.
+
+- Grab the simdjson code from GitHub, e.g., by cloning it using [GitHub Desktop](https://desktop.github.com/).
+- Install [CMake](https://cmake.org/download/). When you install it, make sure to ask that `cmake` be made available from the command line. Please choose a recent version of cmake.
+- Create a subdirectory within simdjson, such as `build`.
+- Using a shell, go to this newly created directory. You can start a shell directly from GitHub Desktop (Repository > Open in Command Prompt).
+- Type `cmake  ..` in the shell while in the `build` repository.
+- This last command (`cmake ...`) created a Visual Studio solution file in the newly created directory (e.g., `simdjson.sln`). Open this file in Visual Studio. You should now be able to build the project and run the tests. For example, in the `Solution Explorer` window (available from the `View` menu), right-click `ALL_BUILD` and select `Build`. To test the code, still in the `Solution Explorer` window, select `RUN_TESTS` and select `Build`.
+
+
+Though having Visual Studio installed is necessary, one can build simdjson using only cmake commands:
+
+- `mkdir build`
+- `cd build`
+- `cmake ..`
+- `cmake --build . --config Release`
+
+
+Furthermore, if you have installed LLVM clang on Windows, for example as a component of Visual Studio 2019, you can configure and build simdjson using LLVM clang on Windows using cmake:
+
+- `mkdir build`
+- `cd build`
+- `cmake -T ClangCL ..`
+- `cmake --build . --config Release`
+
+## Various References
 
-- [Google double-conv](https://github.com/google/double-conversion/)
 - [How to implement atoi using SIMD?](https://stackoverflow.com/questions/35127060/how-to-implement-atoi-using-simd)
 - [Parsing JSON is a Minefield 💣](http://seriot.ch/parsing_json.php)
 - https://tools.ietf.org/html/rfc7159
-- The Mison implementation in rust https://github.com/pikkr/pikkr
 - http://rapidjson.org/md_doc_sax.html
 - https://github.com/Geal/parser_benchmarks/tree/master/json
 - Gron: A command line tool that makes JSON greppable https://news.ycombinator.com/item?id=16727665
@@ -371,31 +393,3 @@ Inspiring links:
 - https://auth0.com/blog/beating-json-performance-with-protobuf/
 - https://gist.github.com/shijuvar/25ad7de9505232c87034b8359543404a
 - https://github.com/frankmcsherry/blog/blob/master/posts/2018-02-11.md
-
-Validating UTF-8 takes no more than 0.7 cycles per byte:
-
-- https://github.com/lemire/fastvalidate-utf-8 https://lemire.me/blog/2018/05/16/validating-utf-8-strings-using-as-little-as-0-7-cycles-per-byte/
-
-### Academic References
-
-- T.Mühlbauer, W.Rödiger, R.Seilbeck, A.Reiser, A.Kemper, and T.Neumann. Instant loading for main memory databases. PVLDB, 6(14):1702–1713, 2013. (SIMD-based CSV parsing)
-- Mytkowicz, Todd, Madanlal Musuvathi, and Wolfram Schulte. "Data-parallel finite-state machines." ACM SIGARCH Computer Architecture News. Vol. 42. No. 1. ACM, 2014.
-- Lu, Yifan, et al. "Tree structured data processing on GPUs." Cloud Computing, Data Science & Engineering-Confluence, 2017 7th International Conference on. IEEE, 2017.
-- Sidhu, Reetinder. "High throughput, tree automata based XML processing using FPGAs." Field-Programmable Technology (FPT), 2013 International Conference on. IEEE, 2013.
-- Dai, Zefu, Nick Ni, and Jianwen Zhu. "A 1 cycle-per-byte XML parsing accelerator." Proceedings of the 18th annual ACM/SIGDA international symposium on Field programmable gate arrays. ACM, 2010.
-- Lin, Dan, et al. "Parabix: Boosting the efficiency of text processing on commodity processors." High Performance Computer Architecture (HPCA), 2012 IEEE 18th International Symposium on. IEEE, 2012. http://parabix.costar.sfu.ca/export/1783/docs/HPCA2012/final_ieee/final.pdf
-- Deshmukh, V. M., and G. R. Bamnote. "An empirical evaluation of optimization parameters in XML parsing for performance enhancement." Computer, Communication and Control (IC4), 2015 International Conference on. IEEE, 2015.
-- Moussalli, Roger, et al. "Efficient XML Path Filtering Using GPUs." ADMS@ VLDB. 2011.
-- Jianliang, Ma, et al. "Parallel speculative dom-based XML parser." High Performance Computing and Communication & 2012 IEEE 9th International Conference on Embedded Software and Systems (HPCC-ICESS), 2012 IEEE 14th International Conference on. IEEE, 2012.
-- Li, Y., Katsipoulakis, N.R., Chandramouli, B., Goldstein, J. and Kossmann, D., 2017. Mison: a fast JSON parser for data analytics. Proceedings of the VLDB Endowment, 10(10), pp.1118-1129. http://www.vldb.org/pvldb/vol10/p1118-li.pdf
-- Cameron, Robert D., et al. "Parallel scanning with bitstream addition: An xml case study." European Conference on Parallel Processing. Springer, Berlin, Heidelberg, 2011.
-- Cameron, Robert D., Kenneth S. Herdy, and Dan Lin. "High performance XML parsing using parallel bit stream technology." Proceedings of the 2008 conference of the center for advanced studies on collaborative research: meeting of minds. ACM, 2008.
-- Shah, Bhavik, et al. "A data parallel algorithm for XML DOM parsing." International XML Database Symposium. Springer, Berlin, Heidelberg, 2009.
-- Cameron, Robert D., and Dan Lin. "Architectural support for SWAR text processing with parallel bit streams: the inductive doubling principle." ACM Sigplan Notices. Vol. 44. No. 3. ACM, 2009.
-- Amagasa, Toshiyuki, Mana Seino, and Hiroyuki Kitagawa. "Energy-Efficient XML Stream Processing through Element-Skipping Parsing." Database and Expert Systems Applications (DEXA), 2013 24th International Workshop on. IEEE, 2013.
-- Medforth, Nigel Woodland. "icXML: Accelerating Xerces-C 3.1. 1 using the Parabix Framework." (2013).
-- Zhang, Qiang Scott. Embedding Parallel Bit Stream Technology Into Expat. Diss. Simon Fraser University, 2010.
-- Cameron, Robert D., et al. "Fast Regular Expression Matching with Bit-parallel Data Streams."
-- Lin, Dan. Bits filter: a high-performance multiple string pattern matching algorithm for malware detection. Diss. School of Computing Science-Simon Fraser University, 2010.
-- Yang, Shiyang. Validation of XML Document Based on Parallel Bit Stream Technology. Diss. Applied Sciences: School of Computing Science, 2013.
-- N. Nakasato, "Implementation of a parallel tree method on a GPU", Journal of Computational Science, vol. 3, no. 3, pp. 132-141, 2012.

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2018-2019 The simdjson authors 
+   Copyright 2018-2025 The simdjson authors
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

LICENSE-MIT

@@ -0,0 +1,18 @@
+Copyright 2018-2025 The simdjson authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Makefile

@@ -1,301 +0,0 @@
-REFERENCE_VERSION = master
-
-.SUFFIXES:
-#
-.SUFFIXES: .cpp .o .c .h
-
-
-.PHONY: clean cleandist
-COREDEPSINCLUDE = -Idependencies/json/single_include -Idependencies/rapidjson/include -Idependencies/sajson/include -Idependencies/cJSON  -Idependencies/jsmn
-EXTRADEPSINCLUDE =  -Idependencies/jsoncppdist -Idependencies/json11 -Idependencies/fastjson/src -Idependencies/fastjson/include -Idependencies/gason/src -Idependencies/ujson4c/3rdparty -Idependencies/ujson4c/src
-# users can provide their own additional flags with make EXTRAFLAGS=something
-architecture:=$(shell arch)
-
-####
-# If you want to specify your own target architecture,
-# then define ARCHFLAGS. Otherwise, we set good default.
-# E.g., type ' ARCHFLAGS="-march=westmere" make parse '
-###
-
-CXXFLAGS = $(ARCHFLAGS) -std=c++17  -pthread -Wall -Wextra -Wshadow -Ibenchmark/linux
-CFLAGS =  $(ARCHFLAGS) -Idependencies/ujson4c/3rdparty -Idependencies/ujson4c/src $(EXTRAFLAGS)
-
-# This is a convenience flag
-ifdef SANITIZEGOLD
-    SANITIZE = 1
-    LINKER = gold
-endif
-
-ifdef LINKER
-	CXXFLAGS += -fuse-ld=$(LINKER)
-	CFLAGS += -fuse-ld=$(LINKER)
-endif
-
-
-# SANITIZE *implies* DEBUG
-ifeq ($(MEMSANITIZE),1)
-	CXXFLAGS += -g3 -O0  -fsanitize=memory -fno-omit-frame-pointer -fsanitize=undefined
-	CFLAGS += -g3 -O0  -fsanitize=memory -fno-omit-frame-pointer -fsanitize=undefined
-else
-ifeq ($(SANITIZE),1)
-	CXXFLAGS += -g3 -O0  -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined
-	CFLAGS += -g3 -O0  -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined
-else
-ifeq ($(DEBUG),1)
-	CXXFLAGS += -g3 -O0
-	CFLAGS += -g3 -O0
-else
-# we opt for  -O3 for regular builds
-	CXXFLAGS += -O3
-	CFLAGS += -O3
-endif # ifeq ($(DEBUG),1)
-endif # ifeq ($(SANITIZE),1)
-endif # ifeq ($(MEMSANITIZE),1)
-
-# Headers and sources
-SRCHEADERS_GENERIC=src/generic/atomparsing.h src/generic/numberparsing.h src/generic/json_scanner.h src/generic/json_string_scanner.h src/generic/json_structural_indexer.h src/generic/json_minifier.h src/generic/buf_block_reader.h src/generic/stage2_build_tape.h src/generic/stringparsing.h src/generic/stage2_streaming_build_tape.h src/generic/utf8_fastvalidate_algorithm.h src/generic/utf8_lookup_algorithm.h src/generic/utf8_lookup2_algorithm.h src/generic/utf8_range_algorithm.h src/generic/utf8_zwegner_algorithm.h
-SRCHEADERS_ARM64=      src/arm64/bitmanipulation.h    src/arm64/bitmask.h    src/arm64/intrinsics.h    src/arm64/numberparsing.h    src/arm64/simd.h    src/arm64/stage1_find_marks.h    src/arm64/stage2_build_tape.h    src/arm64/stringparsing.h
-SRCHEADERS_HASWELL=  src/haswell/bitmanipulation.h  src/haswell/bitmask.h  src/haswell/intrinsics.h  src/haswell/numberparsing.h  src/haswell/simd.h  src/haswell/stage1_find_marks.h  src/haswell/stage2_build_tape.h  src/haswell/stringparsing.h
-SRCHEADERS_FALLBACK=  src/fallback/bitmanipulation.h src/fallback/implementation.h src/fallback/numberparsing.h src/fallback/stage1_find_marks.h src/fallback/stage2_build_tape.h src/fallback/stringparsing.h
-SRCHEADERS_WESTMERE=src/westmere/bitmanipulation.h src/westmere/bitmask.h src/westmere/intrinsics.h src/westmere/numberparsing.h src/westmere/simd.h src/westmere/stage1_find_marks.h src/westmere/stage2_build_tape.h src/westmere/stringparsing.h
-SRCHEADERS_SRC=src/isadetection.h src/jsoncharutils.h src/simdprune_tables.h src/implementation.cpp src/stage1_find_marks.cpp src/stage2_build_tape.cpp src/document_parser_callbacks.h
-SRCHEADERS=$(SRCHEADERS_SRC) $(SRCHEADERS_GENERIC) $(SRCHEADERS_ARM64) $(SRCHEADERS_HASWELL) $(SRCHEADERS_WESTMERE) $(SRCHEADERS_FALLBACK)
-
-INCLUDEHEADERS=include/simdjson.h include/simdjson/common_defs.h include/simdjson/internal/jsonformatutils.h include/simdjson/jsonioutil.h include/simdjson/jsonparser.h include/simdjson/padded_string.h include/simdjson/inline/padded_string.h include/simdjson/document.h include/simdjson/inline/document.h include/simdjson/parsedjson_iterator.h include/simdjson/inline/parsedjson_iterator.h include/simdjson/document_stream.h include/simdjson/inline/document_stream.h include/simdjson/implementation.h include/simdjson/parsedjson.h include/simdjson/portability.h include/simdjson/error.h include/simdjson/inline/error.h include/simdjson/simdjson.h include/simdjson/simdjson_version.h
-
-ifeq ($(SIMDJSON_TEST_AMALGAMATED_HEADERS),1)
-	HEADERS=singleheader/simdjson.h
-	LIBFILES=singleheader/simdjson.cpp
-	CXXFLAGS += -Isingleheader
-else
-	HEADERS=$(INCLUDEHEADERS) $(SRCHEADERS)
-	LIBFILES=src/simdjson.cpp
-	CXXFLAGS += -Isrc -Iinclude
-endif
-
-# We put EXTRAFLAGS after all other CXXFLAGS so they can override if necessary
-CXXFLAGS += $(EXTRAFLAGS)
-
-FEATURE_JSON_FILES=jsonexamples/generated/0-structurals-full.json jsonexamples/generated/0-structurals-miss.json jsonexamples/generated/0-structurals.json jsonexamples/generated/15-structurals-full.json jsonexamples/generated/15-structurals-miss.json jsonexamples/generated/15-structurals.json jsonexamples/generated/23-structurals-full.json jsonexamples/generated/23-structurals-miss.json jsonexamples/generated/23-structurals.json jsonexamples/generated/7-structurals-full.json jsonexamples/generated/7-structurals-miss.json jsonexamples/generated/7-structurals.json jsonexamples/generated/escape-full.json jsonexamples/generated/escape-miss.json jsonexamples/generated/escape.json jsonexamples/generated/utf-8-full.json jsonexamples/generated/utf-8-miss.json jsonexamples/generated/utf-8.json
-
-RAPIDJSON_INCLUDE:=dependencies/rapidjson/include
-SAJSON_INCLUDE:=dependencies/sajson/include
-JSON11_INCLUDE:=dependencies/json11/json11.hpp
-FASTJSON_INCLUDE:=dependencies/include/fastjson/fastjson.h
-GASON_INCLUDE:=dependencies/gason/src/gason.h
-UJSON4C_INCLUDE:=dependencies/ujson4c/src/ujdecode.c
-CJSON_INCLUDE:=dependencies/cJSON/cJSON.h
-JSMN_INCLUDE:=dependencies/jsmn/jsmn.h
-JSON_INCLUDE:=dependencies/json/single_include/nlohmann/json.hpp
-
-EXTRAOBJECTS=ujdecode.o
-
-MAINEXECUTABLES=parse minify json2json jsonstats statisticalmodel jsonpointer get_corpus_benchmark
-TESTEXECUTABLES=jsoncheck jsoncheck_westmere jsoncheck_fallback integer_tests numberparsingcheck stringparsingcheck pointercheck parse_many_test basictests errortests readme_examples readme_examples_noexceptions
-COMPARISONEXECUTABLES=minifiercompetition parsingcompetition parseandstatcompetition distinctuseridcompetition allparserscheckfile allparsingcompetition
-SUPPLEMENTARYEXECUTABLES=parse_noutf8validation parse_nonumberparsing parse_nostringparsing
-
-all:  $(MAINEXECUTABLES)
-
-competition:  $(COMPARISONEXECUTABLES)
-
-.PHONY: benchmark test
-
-benchmark:
-	bash ./scripts/parser.sh
-	bash ./scripts/parseandstat.sh
-
-run_basictests: basictests
-	./basictests
-
-run_errortests: errortests
-	./errortests
-
-run_numberparsingcheck: numberparsingcheck
-	./numberparsingcheck
-
-run_integer_tests: integer_tests
-	./integer_tests
-
-run_stringparsingcheck: stringparsingcheck
-	./stringparsingcheck
-
-run_jsoncheck: jsoncheck
-	./jsoncheck
-
-run_parse_many_test: parse_many_test
-	./parse_many_test
-
-run_jsoncheck_westmere: jsoncheck_westmere
-	./jsoncheck_westmere
-
-run_jsoncheck_fallback: jsoncheck_fallback
-	./jsoncheck_fallback
-
-run_pointercheck: pointercheck
-	./pointercheck
-
-run_issue150_sh: allparserscheckfile
-	./scripts/issue150.sh
-
-quickstart:
-	cd examples/quickstart && make quickstart
-
-run_quickstart:
-	cd examples/quickstart && make test
-
-run_testjson2json_sh: minify json2json
-	./scripts/testjson2json.sh
-
-$(FEATURE_JSON_FILES): benchmark/genfeaturejson.rb
-	ruby ./benchmark/genfeaturejson.rb
-
-run_benchfeatures: benchfeatures $(FEATURE_JSON_FILES)
-	./benchfeatures -n 1000
-
-test: quicktests slowtests
-	@echo "It looks like the code is good!"
-
-quiettest: quicktests slowtests
-
-quicktests: run_basictests run_quickstart readme_examples readme_examples_noexceptions run_jsoncheck run_numberparsingcheck run_integer_tests run_stringparsingcheck run_jsoncheck run_parse_many_test run_pointercheck run_jsoncheck_westmere run_jsoncheck_fallback
-
-slowtests: run_testjson2json_sh run_issue150_sh
-
-amalgamate:
-	./amalgamation.sh
-
-singleheader/simdjson.h singleheader/simdjson.cpp singleheader/amalgamation_demo.cpp: amalgamation.sh src/simdjson.cpp $(SRCHEADERS) $(INCLUDEHEADERS)
-	./amalgamation.sh
-
-singleheader/demo: singleheader/simdjson.h singleheader/simdjson.cpp singleheader/amalgamation_demo.cpp
-	$(CXX) $(CXXFLAGS) -o singleheader/demo singleheader/amalgamation_demo.cpp -Isingleheader
-
-submodules:
-	-git submodule update --init --recursive
-	-touch submodules
-
-$(JSON_INCLUDE) $(SAJSON_INCLUDE) $(RAPIDJSON_INCLUDE) $(JSON11_INCLUDE) $(FASTJSON_INCLUDE) $(GASON_INCLUDE) $(UJSON4C_INCLUDE) $(CJSON_INCLUDE) $(JSMN_INCLUDE) : submodules
-
-parse: benchmark/parse.cpp benchmark/event_counter.h benchmark/benchmarker.h $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o parse benchmark/parse.cpp $(LIBFILES) $(LIBFLAGS)
-
-get_corpus_benchmark: benchmark/get_corpus_benchmark.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o get_corpus_benchmark benchmark/get_corpus_benchmark.cpp $(LIBFILES) $(LIBFLAGS)
-
-parse_stream: benchmark/parse_stream.cpp benchmark/event_counter.h benchmark/benchmarker.h $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o parse_stream benchmark/parse_stream.cpp $(LIBFILES) $(LIBFLAGS)
-
-benchfeatures: benchmark/benchfeatures.cpp benchmark/event_counter.h benchmark/benchmarker.h $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o benchfeatures benchmark/benchfeatures.cpp $(LIBFILES) $(LIBFLAGS)
-
-perfdiff: benchmark/perfdiff.cpp
-	$(CXX) $(CXXFLAGS) -o perfdiff benchmark/perfdiff.cpp $(LIBFILES) $(LIBFLAGS)
-
-checkperf:
-	bash ./scripts/checkperf.sh $(REFERENCE_VERSION)
-
-statisticalmodel: benchmark/statisticalmodel.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o statisticalmodel benchmark/statisticalmodel.cpp $(LIBFILES) $(LIBFLAGS)
-
-
-parse_noutf8validation: benchmark/parse.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o parse_noutf8validation -DSIMDJSON_SKIPUTF8VALIDATION benchmark/parse.cpp $(LIBFILES) $(LIBFLAGS)
-
-parse_nonumberparsing: benchmark/parse.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o parse_nonumberparsing  -DSIMDJSON_SKIPNUMBERPARSING benchmark/parse.cpp $(LIBFILES) $(LIBFLAGS)
-
-parse_nostringparsing: benchmark/parse.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o parse_nostringparsing  -DSIMDJSON_SKIPSTRINGPARSING benchmark/parse.cpp $(LIBFILES) $(LIBFLAGS)
-
-
-jsoncheck:tests/jsoncheck.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o jsoncheck tests/jsoncheck.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-parse_many_test:tests/parse_many_test.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o parse_many_test tests/parse_many_test.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-
-jsoncheck_westmere:tests/jsoncheck.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o jsoncheck_westmere tests/jsoncheck.cpp -I. $(LIBFILES) $(LIBFLAGS) -DSIMDJSON_IMPLEMENTATION_HASWELL=0
-
-jsoncheck_fallback:tests/jsoncheck.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o jsoncheck_fallback tests/jsoncheck.cpp -I. $(LIBFILES) $(LIBFLAGS) -DSIMDJSON_IMPLEMENTATION_HASWELL=0 -DSIMDJSON_IMPLEMENTATION_WESTMERE=0 -DSIMDJSON_IMPLEMENTATION_ARM64=0
-
-basictests:tests/basictests.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o basictests tests/basictests.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-errortests:tests/errortests.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o errortests tests/errortests.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-readme_examples: tests/readme_examples.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o readme_examples tests/readme_examples.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-readme_examples_noexceptions: tests/readme_examples_noexceptions.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o readme_examples_noexceptions tests/readme_examples_noexceptions.cpp -I. $(LIBFILES) $(LIBFLAGS) -fno-exceptions
-
-numberparsingcheck: tests/numberparsingcheck.cpp $(HEADERS) src/simdjson.cpp
-	$(CXX) $(CXXFLAGS) -o numberparsingcheck tests/numberparsingcheck.cpp -I. $(LIBFLAGS) -DJSON_TEST_NUMBERS
-
-integer_tests:tests/integer_tests.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o integer_tests tests/integer_tests.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-
-
-stringparsingcheck: tests/stringparsingcheck.cpp $(HEADERS) src/simdjson.cpp
-	$(CXX) $(CXXFLAGS) -o stringparsingcheck tests/stringparsingcheck.cpp -I. $(LIBFLAGS) -DJSON_TEST_STRINGS
-
-pointercheck:tests/pointercheck.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o pointercheck tests/pointercheck.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-minifiercompetition: benchmark/minifiercompetition.cpp submodules $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o minifiercompetition benchmark/minifiercompetition.cpp -I. $(LIBFILES) $(LIBFLAGS) $(COREDEPSINCLUDE)
-
-minify: tools/minify.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o minify tools/minify.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-json2json: tools/json2json.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o json2json $ tools/json2json.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-jsonpointer: tools/jsonpointer.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o jsonpointer $ tools/jsonpointer.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-jsonstats: tools/jsonstats.cpp $(HEADERS) $(LIBFILES)
-	$(CXX) $(CXXFLAGS) -o jsonstats $ tools/jsonstats.cpp -I. $(LIBFILES) $(LIBFLAGS)
-
-ujdecode.o: $(UJSON4C_INCLUDE)
-	$(CC) $(CFLAGS) -c dependencies/ujson4c/src/ujdecode.c
-
-parseandstatcompetition: benchmark/parseandstatcompetition.cpp $(HEADERS) $(LIBFILES) submodules
-	$(CXX) $(CXXFLAGS) -o parseandstatcompetition benchmark/parseandstatcompetition.cpp -I. $(LIBFILES) $(LIBFLAGS) $(COREDEPSINCLUDE)
-
-distinctuseridcompetition: benchmark/distinctuseridcompetition.cpp $(HEADERS) $(LIBFILES) submodules
-	$(CXX) $(CXXFLAGS) -o distinctuseridcompetition benchmark/distinctuseridcompetition.cpp  -I. $(LIBFILES) $(LIBFLAGS) $(COREDEPSINCLUDE)
-
-parsingcompetition: benchmark/parsingcompetition.cpp $(HEADERS) $(LIBFILES) submodules
-	@echo "In case of build error due to missing files, try 'make clean'"
-	$(CXX) $(CXXFLAGS) -o parsingcompetition benchmark/parsingcompetition.cpp -I. $(LIBFILES) $(LIBFLAGS) $(COREDEPSINCLUDE)
-
-allparsingcompetition: benchmark/parsingcompetition.cpp $(HEADERS) $(LIBFILES) $(EXTRAOBJECTS) submodules
-	$(CXX) $(CXXFLAGS) -o allparsingcompetition benchmark/parsingcompetition.cpp  $(EXTRAOBJECTS) -I. $(LIBFILES) $(LIBFLAGS) $(COREDEPSINCLUDE) $(EXTRADEPSINCLUDE)  -DALLPARSER
-
-
-allparserscheckfile: tests/allparserscheckfile.cpp $(HEADERS) $(LIBFILES) $(EXTRAOBJECTS) submodules
-	$(CXX) $(CXXFLAGS) -o allparserscheckfile tests/allparserscheckfile.cpp $(EXTRAOBJECTS) -I. $(LIBFILES) $(LIBFLAGS) $(COREDEPSINCLUDE) $(EXTRADEPSINCLUDE)
-
-.PHONY:  clean cppcheck cleandist
-
-cppcheck:
-	cppcheck --enable=all src/*.cpp  benchmarks/*.cpp tests/*.cpp -Iinclude -I. -Ibenchmark/linux
-
-everything: $(MAINEXECUTABLES) $(EXTRA_EXECUTABLES) $(TESTEXECUTABLES) $(COMPARISONEXECUTABLES) $(SUPPLEMENTARYEXECUTABLES) quickstart
-
-clean:
-	rm -f submodules $(EXTRAOBJECTS) $(MAINEXECUTABLES) $(EXTRA_EXECUTABLES) $(TESTEXECUTABLES) $(COMPARISONEXECUTABLES) $(SUPPLEMENTARYEXECUTABLES)
-	cd examples/quickstart && make clean
-
-cleandist:
-	rm -f submodules $(EXTRAOBJECTS) $(MAINEXECUTABLES) $(EXTRA_EXECUTABLES) $(TESTEXECUTABLES) $(COMPARISONEXECUTABLES) $(SUPPLEMENTARYEXECUTABLES)
-
-doc/api: Doxyfile $(HEADERS)
-	doxygen

README.md

@@ -1,64 +1,112 @@
-[![Build Status](https://cloud.drone.io/api/badges/simdjson/simdjson/status.svg)](https://cloud.drone.io/simdjson/simdjson)
+[![][license img]][license] [![][licensemit img]][licensemit]
-[![CircleCI](https://circleci.com/gh/simdjson/simdjson.svg?style=svg)](https://circleci.com/gh/simdjson/simdjson)
+
-[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/simdjson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&q=proj%3Asimdjson&can=2)
+
-[![Build status](https://ci.appveyor.com/api/projects/status/ae77wp5v3lebmu6n/branch/master?svg=true)](https://ci.appveyor.com/project/lemire/simdjson-jmmti/branch/master)
+[![Doxygen Documentation](https://img.shields.io/badge/docs-doxygen-green.svg)](https://simdjson.github.io/simdjson/)
-[![][license img]][license]
 
 simdjson : Parsing gigabytes of JSON per second
 ===============================================
 
-<img src="images/logo.png" width="10%" style="float: right">
+<img src="images/official_logo/logo_noir/SVG/logo_simdjson_noir.svg" width="40%" style="float: right">
+
 JSON is everywhere on the Internet. Servers spend a *lot* of time parsing it. We need a fresh
 approach. The simdjson library uses commonly available SIMD instructions and microparallel algorithms
-to parse JSON 2.5x faster than anything else out there.
+to parse JSON 4x  faster than RapidJSON and 25x faster than JSON for Modern C++.
 
-* **Fast:** Over 2.5x faster than other production-grade JSON parsers.
+* **Fast:** Over 4x faster than commonly used production-grade JSON parsers.
-* **Easy:** First-class, easy to use API.
+* **Record Breaking Features:** Minify JSON  at 6 GB/s, validate UTF-8  at 13 GB/s,  NDJSON at 3.5 GB/s.
+* **Easy:** First-class, easy to use and carefully documented APIs.
 * **Strict:** Full JSON and UTF-8 validation, lossless parsing. Performance with no compromises.
 * **Automatic:** Selects a CPU-tailored parser at runtime. No configuration needed.
 * **Reliable:** From memory allocation to error handling, simdjson's design avoids surprises.
+* **Peer Reviewed:** Our research appears in venues like VLDB Journal, Software: Practice and Experience.
 
 This library is part of the [Awesome Modern C++](https://awesomecpp.com) list.
 
 Table of Contents
 -----------------
 
+* [Real-world usage](#real-world-usage)
 * [Quick Start](#quick-start)
 * [Documentation](#documentation)
+* [Godbolt](#godbolt)
 * [Performance results](#performance-results)
-* [Real-world usage](#real-world-usage)
+* [Packages](#packages)
 * [Bindings and Ports of simdjson](#bindings-and-ports-of-simdjson)
 * [About simdjson](#about-simdjson)
 * [Funding](#funding)
 * [Contributing to simdjson](#contributing-to-simdjson)
 * [License](#license)
 
+
+Real-world usage
+----------------
+
+- [Node.js](https://nodejs.org/)
+- [ClickHouse](https://github.com/ClickHouse/ClickHouse)
+- [Meta Velox](https://velox-lib.io)
+- [Google Pax](https://github.com/google/paxml)
+- [milvus](https://github.com/milvus-io/milvus)
+- [QuestDB](https://questdb.io/blog/questdb-release-8-0-3/)
+- [Clang Build Analyzer](https://github.com/aras-p/ClangBuildAnalyzer)
+- [Shopify HeapProfiler](https://github.com/Shopify/heap-profiler)
+- [StarRocks](https://github.com/StarRocks/starrocks)
+- [Microsoft FishStore](https://github.com/microsoft/FishStore)
+- [Intel PCM](https://github.com/intel/pcm)
+- [WatermelonDB](https://github.com/Nozbe/WatermelonDB)
+- [Apache Doris](https://github.com/apache/doris)
+- [Dgraph](https://github.com/dgraph-io/dgraph)
+- [UJRPC](https://github.com/unum-cloud/ujrpc)
+- [fastgltf](https://github.com/spnda/fastgltf)
+- [vast](https://github.com/tenzir/vast)
+- [ada-url](https://github.com/ada-url/ada)
+- [fastgron](https://github.com/adamritter/fastgron)
+- [WasmEdge](https://wasmedge.org)
+- [RonDB](https://github.com/logicalclocks/rondb)
+- [GreptimeDB](https://github.com/GreptimeTeam/greptimedb)
+- [mamba](https://github.com/mamba-org/mamba)
+- [Ladybird Browser](https://ladybird.org)
+- [SereneDB](https://github.com/serenedb/serenedb)
+
+
+If you are planning to use simdjson in a product, please work from one of our releases.
+
+
+
+
 Quick Start
 -----------
 
-          
 The simdjson library is easily consumable with a single .h and .cpp file.
 
-0. Prerequisites: `g++` (version 7 or better) or `clang++` (version 6 or better), and a 64-bit system.
+0. Prerequisites: `g++` (version 7 or better) or `clang++` (version 6 or better), and a 64-bit
-1. Pull [simdjson.h](singleheader/simdjson.h) and [simdjson.cpp](singleheader/simdjson.cpp) into a directory, along with the sample file [twitter.json](jsonexamples/twitter.json).
+   system with a command-line shell (e.g., Linux, macOS, freeBSD). We also support programming
+   environments like Visual Studio and Xcode, but different steps are needed. Users of clang++ may need to specify the C++ version (e.g., `c++ -std=c++17`) since clang++ tends to default on C++98.
+1. Pull [simdjson.h](singleheader/simdjson.h) and [simdjson.cpp](singleheader/simdjson.cpp) into a
+   directory, along with the sample file [twitter.json](jsonexamples/twitter.json). You can download them with the `wget` utility:
+
    ```
    wget https://raw.githubusercontent.com/simdjson/simdjson/master/singleheader/simdjson.h https://raw.githubusercontent.com/simdjson/simdjson/master/singleheader/simdjson.cpp https://raw.githubusercontent.com/simdjson/simdjson/master/jsonexamples/twitter.json
    ```
 2. Create `quickstart.cpp`:
 
-   ```c++
+```cpp
-   #include "simdjson.h"
+#include <iostream>
-   int main(void) {
+#include "simdjson.h"
-     simdjson::dom::parser parser;
+using namespace simdjson;
-     simdjson::dom::element tweets = parser.load("twitter.json");
+int main(void) {
-     std::cout << tweets["search_metadata"]["count"] << " results." << std::endl;
+    ondemand::parser parser;
-   }
+    padded_string json = padded_string::load("twitter.json");
-   ```
+    ondemand::document tweets = parser.iterate(json);
-3. `c++ -o quickstart quickstart.cpp simdjson.cpp -std=c++17`
+    std::cout << uint64_t(tweets["search_metadata"]["count"]) << " results." << std::endl;
+}
+```
+3. `c++ -o quickstart quickstart.cpp simdjson.cpp`
 4. `./quickstart`
-   ```
+
+  ```
    100 results.
-   ```
+  ```
+
 
 Documentation
 -------------
@@ -66,70 +114,52 @@ Documentation
 Usage documentation is available:
 
 * [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.org/api/0.3.0/annotated.html) contains the automatically generated API documentation.
+* [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)
 
 Performance results
 -------------------
 
-The simdjson library uses three-quarters less instructions than state-of-the-art parser RapidJSON and
+The simdjson library uses three-quarters less instructions than state-of-the-art parser [RapidJSON](https://rapidjson.org). To our knowledge, simdjson is the first fully-validating JSON parser
-fifty percent less than sajson. To our knowledge, simdjson is the first fully-validating JSON parser
+to run at [gigabytes per second](https://en.wikipedia.org/wiki/Gigabyte) (GB/s) on commodity processors. It can parse millions of JSON documents per second on a single core.
-to run at gigabytes per second on commodity processors. It can parse millions of JSON documents
-per second on a single core.
 
 The following figure represents parsing speed in GB/s for parsing various files
-on an Intel Skylake processor (3.4 GHz) using the GNU GCC 9 compiler (with the -O3 flag).
+on an Intel Skylake processor (3.4 GHz) using the GNU GCC 10 compiler (with the -O3 flag).
-We compare against the best and fastest C++ libraries.
+We compare against the best and fastest C++ libraries on benchmarks that load and process the data.
-The simdjson library offers full unicode (UTF-8) validation and exact
+The simdjson library offers full unicode ([UTF-8](https://en.wikipedia.org/wiki/UTF-8)) validation and exact
-number parsing. The RapidJSON library is tested in two modes: fast and
+number parsing.
-exact number parsing. The sajson library offers fast (but not exact)
-number parsing and partial unicode validation. In this data set, the file
-sizes range from 65KB (github_events) all the way to 3.3GB (gsoc-2018).
-Many files are mostly made of numbers: canada, mesh.pretty, mesh, random
-and numbers: in such instances, we see lower JSON parsing speeds due to the
-high cost of number parsing. The simdjson library uses exact number parsing which
-is particular taxing.
-
-<img src="doc/gbps.png" width="90%">
-
-On a Skylake processor, the parsing speeds (in GB/s) of various processors on the twitter.json file are as follows, using again GNU GCC 9.1 (with the -O3 flag). The popular JSON for Modern C++ library is particularly slow: it obviously trades parsing speed for other desirable features.
-
-| parser                                | GB/s |
-| ------------------------------------- | ---- |
-| simdjson                              | 2.5  |
-| RapidJSON UTF8-validation             | 0.29 |
-| RapidJSON UTF8-valid., exact numbers  | 0.28 |
-| RapidJSON insitu, UTF8-validation     | 0.41 |
-| RapidJSON insitu, UTF8-valid., exact  | 0.39 |
-| sajson (insitu, dynamic)              | 0.62 |
-| sajson (insitu, static)               | 0.88 |
-| dropbox                               | 0.13 |
-| fastjson                              | 0.27 |
-| gason                                 | 0.59 |
-| ultrajson                             | 0.34 |
-| jsmn                                  | 0.25 |
-| cJSON                                 | 0.31 |
-| JSON for Modern C++ (nlohmann/json)   | 0.11 |
 
+<img src="doc/rome.png" width="60%">
 
 The simdjson library offers high speed whether it processes tiny files (e.g., 300 bytes)
 or larger files (e.g., 3MB). The following plot presents parsing
 speed for [synthetic files over various sizes generated with a script](https://github.com/simdjson/simdjson_experiments_vldb2019/blob/master/experiments/growing/gen.py) on a 3.4 GHz Skylake processor (GNU GCC 9, -O3).
-<img src="doc/growing.png" width="90%">
 
+<img src="doc/growing.png" width="60%">
 
 [All our experiments are reproducible](https://github.com/simdjson/simdjson_experiments_vldb2019).
 
-Real-world usage
-----------------
 
-- [Microsoft FishStore](https://github.com/microsoft/FishStore)
+For NDJSON files, we can exceed 3 GB/s with [our  multithreaded parsing functions](https://github.com/simdjson/simdjson/blob/master/doc/parse_many.md).
-- [Yandex ClickHouse](https://github.com/yandex/ClickHouse)
+
-- [Clang Build Analyzer](https://github.com/aras-p/ClangBuildAnalyzer)
+
+Packages
+------------------------------
+[![Packaging status](https://repology.org/badge/vertical-allrepos/simdjson.svg)](https://repology.org/project/simdjson/versions)
 
-If you are planning to use simdjson in a product, please work from one of our releases.
 
 Bindings and Ports of simdjson
 ------------------------------
@@ -137,15 +167,29 @@ Bindings and Ports of simdjson
 We distinguish between "bindings" (which just wrap the C++ code) and a port to another programming language (which reimplements everything).
 
 - [ZippyJSON](https://github.com/michaeleisel/zippyjson): Swift bindings for the simdjson project.
+- [libpy_simdjson](https://github.com/gerrymanoim/libpy_simdjson/): high-speed Python bindings for simdjson using [libpy](https://github.com/quantopian/libpy).
 - [pysimdjson](https://github.com/TkTech/pysimdjson): Python bindings for the simdjson project.
+- [cysimdjson](https://github.com/TeskaLabs/cysimdjson): high-speed Python bindings for the simdjson project.
 - [simdjson-rs](https://github.com/simd-lite): Rust port.
 - [simdjson-rust](https://github.com/SunDoge/simdjson-rust): Rust wrapper (bindings).
 - [SimdJsonSharp](https://github.com/EgorBo/SimdJsonSharp): C# version for .NET Core (bindings and full port).
 - [simdjson_nodejs](https://github.com/luizperes/simdjson_nodejs): Node.js bindings for the simdjson project.
 - [simdjson_php](https://github.com/crazyxman/simdjson_php): PHP bindings for the simdjson project.
 - [simdjson_ruby](https://github.com/saka1/simdjson_ruby): Ruby bindings for the simdjson project.
+- [fast_jsonparser](https://github.com/anilmaurya/fast_jsonparser): Ruby bindings for the simdjson project.
 - [simdjson-go](https://github.com/minio/simdjson-go): Go port using Golang assembly.
 - [rcppsimdjson](https://github.com/eddelbuettel/rcppsimdjson): R bindings.
+- [simdjson_erlang](https://github.com/ChomperT/simdjson_erlang): erlang bindings.
+- [simdjsone](https://github.com/saleyn/simdjsone): erlang bindings.
+- [lua-simdjson](https://github.com/FourierTransformer/lua-simdjson): lua bindings.
+- [hermes-json](https://hackage.haskell.org/package/hermes-json): haskell bindings.
+- [zimdjson](https://github.com/EzequielRamis/zimdjson): Zig port.
+- [simdjzon](https://github.com/travisstaloch/simdjzon): Zig port.
+- [JSON-Simd](https://github.com/rawleyfowler/JSON-simd): Raku bindings.
+- [JSON::SIMD](https://metacpan.org/pod/JSON::SIMD): Perl bindings; fully-featured JSON module that uses simdjson for decoding.
+- [gemmaJSON](https://github.com/sainttttt/gemmaJSON): Nim JSON parser based on simdjson bindings.
+- [simdjson-java](https://github.com/simdjson/simdjson-java): Java port.
+- [mruby-fast-json](https://github.com/Asmod4n/mruby-fast-json): mruby binding with high API coverage.
 
 About simdjson
 --------------
@@ -154,33 +198,81 @@ The simdjson library takes advantage of modern microarchitectures, parallelizing
 instructions, reducing branch misprediction, and reducing data dependency to take advantage of each
 CPU's multiple execution cores.
 
-Some people [enjoy reading our paper](https://arxiv.org/abs/1902.08318): A description of the design
+Our default front-end is called On-Demand, and we wrote a paper about it:
-and implementation of simdjson is in our research article: Geoff Langdale, Daniel
+
-Lemire, [Parsing Gigabytes of JSON per Second](https://arxiv.org/abs/1902.08318), VLDB Journal 28 (6), 2019.
+- John Keiser, Daniel Lemire, [On-Demand JSON: A Better Way to Parse Documents?](http://arxiv.org/abs/2312.17149), Software: Practice and Experience 54 (6), 2024.
+
+Some people [enjoy reading the first (2019) simdjson paper](https://arxiv.org/abs/1902.08318): A description of the design
+and implementation of simdjson is in our research article:
+- Geoff Langdale, Daniel Lemire, [Parsing Gigabytes of JSON per Second](https://arxiv.org/abs/1902.08318), VLDB Journal 28 (6), 2019.
+
+We have an in-depth paper focused on the UTF-8 validation:
+
+- John Keiser, Daniel Lemire, [Validating UTF-8 In Less Than One Instruction Per Byte](https://arxiv.org/abs/2010.03090), Software: Practice & Experience 51 (5), 2021.
 
 We also have an informal [blog post providing some background and context](https://branchfree.org/2019/02/25/paper-parsing-gigabytes-of-json-per-second/).
 
-For the video inclined, <br />
+For the video inclined, we had a talk at QCon San Francisco 2019<br />
 [![simdjson at QCon San Francisco 2019](http://img.youtube.com/vi/wlvKAT7SZIQ/0.jpg)](http://www.youtube.com/watch?v=wlvKAT7SZIQ)<br />
-(it was the best voted talk, we're kinda proud of it).
+(It was the best voted talk, we're kinda proud of it.)
+
+We also had a CppCon 2025 talk. We show how C++26 reflection allows for one-line serialization (to_json(player)) or deserialization—without invasive macros or manual mapping—using nothing but the C++ standard library. Whether you’re a performance junkie or simply interested in the roadmap for the next decade of C++ development, watch our full talk!
+
+[![simdjson at CppCon 2025](http://img.youtube.com/vi/Mcgk3CxHYMs/0.jpg)](http://www.youtube.com/watch?v=Mcgk3CxHYMs)<br />
+
+
+
+Citing this work
+-----------------
+
+If you use simdjson in published research, please cite the software library. A suitable BibTeX entry is:
+
+```bibtex
+@misc{simdjson,
+  title={{The simdjson library: Parsing Gigabytes of JSON per Second}},
+  author={Daniel Lemire and Geoff Langdale and John Keiser and Paul Dreik and Francisco Thiesen and others},
+  year={2019},
+  howpublished={Software library},
+  note={https://github.com/simdjson/simdjson}
+}
+```
 
 Funding
 -------
 
-The work is supported by the Natural Sciences and Engineering Research Council of Canada under grant number RGPIN-2017-03910.
+The work is supported by the Natural Sciences and Engineering Research Council of Canada under grants
+RGPIN-2017-03910 and RGPIN-2024-03787.
 
 [license]: LICENSE
 [license img]: https://img.shields.io/badge/License-Apache%202-blue.svg
 
+
+[licensemit]: LICENSE-MIT
+[licensemit img]: https://img.shields.io/badge/License-MIT-blue.svg
+
+
 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
 -------
 
-This code is made available under the Apache License 2.0.
+This code is made available under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html) as well as under the MIT License. As a user, you can pick the license you prefer.
 
-Under Windows, we build some tools using the windows/dirent_portable.h file (which is outside our library code): it under the liberal (business-friendly) MIT license.
+Under Windows, we build some tools using the windows/dirent_portable.h file (which is outside our library code): it is under the liberal (business-friendly) MIT license.
+
+For compilers that do not support [C++17](https://en.wikipedia.org/wiki/C%2B%2B17), we bundle the string-view library which is published under the [Boost license](http://www.boost.org/LICENSE_1_0.txt). Like the Apache license, the Boost license is a permissive license allowing commercial redistribution.
+
+For efficient number serialization, we bundle Florian Loitsch's implementation of the Grisu2 algorithm for binary to decimal floating-point numbers. The implementation was slightly modified by JSON for Modern C++ library. Both Florian Loitsch's implementation and JSON for Modern C++ are provided under the MIT license.
+
+For runtime dispatching, we use some code from the PyTorch project licensed under 3-clause BSD.

RELEASES.md

@@ -1,33 +0,0 @@
-# 0.3
-
-## Highlights
-
-- **Multi-Document Parsing:** Read a bundle of JSON documents (ndjson) 2-4x faster than doing it
-  individually. [API docs](https://github.com/simdjson/simdjson/blob/master/doc/basics.md#newline-delimited-json-ndjson-and-json-lines) / [Design Details](https://github.com/simdjson/simdjson/blob/master/doc/parse_many.md)
-- **Simplified API:** The API has been completely revamped for ease of use, including a new JSON
-  navigation API and fluent support for error code *and* exception styles of error handling with a
-  single API. [Docs](https://github.com/simdjson/simdjson/blob/master/doc/basics.md#the-basics-loading-and-parsing-json-documents)
-- **Exact Float Parsing:** Now simdjson parses floats flawlessly *without* any performance loss,
-  thanks to [great work by @michaeleisel and @lemire](https://github.com/simdjson/simdjson/pull/558).
-  [Blog Post](https://lemire.me/blog/2020/03/10/fast-float-parsing-in-practice/)
-- **Even Faster:** The fastest parser got faster! With a [shiny new UTF-8 validator](https://github.com/simdjson/simdjson/pull/387)
-  and meticulously refactored SIMD core, simdjson 0.3 is 15% faster than before, running at 2.5 GB/s
-  (where 0.2 ran at 2.2 GB/s).
-
-## Minor Highlights
-
-- Fallback implementation: simdjson now has a non-SIMD fallback implementation, and can run even on
-  very old 64-bit machines.
-- Automatic allocation: as part of API simplification, the parser no longer has to be preallocated--
-  it will adjust automatically when it encounters larger files.
-- Runtime selection API: We've exposed simdjson's runtime CPU detection and implementation selection
-  as an API, so you can tell what implementation we detected and test with other implementations.
-- Error handling your way: Whether you use exceptions or check error codes, simdjson lets you handle
-  errors in your style. APIs that can fail return simdjson_result<T>, letting you check the error
-  code before using the result. But if you are more comfortable with exceptions, skip the error code
-  and cast straight to T, and exceptions will be thrown automatically if an error happens. Use the
-  same API either way!
-- Error chaining: We also worked to keep non-exception error-handling short and sweet. Instead of
-  having to check the error code after every single operation, now you can *chain* JSON navigation
-  calls like looking up an object field or array element, or casting to a string, so that you only
-  have to check the error code once at the very end.

SECURITY.md

@@ -0,0 +1,7 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please use the following contact information for reporting a vulnerability:
+
+- [Daniel Lemire](https://github.com/lemire) - daniel@lemire.me

amalgamation.sh

@@ -1,185 +0,0 @@
-#!/bin/bash
-########################################################################
-# Generates an "amalgamation build" for roaring. Inspired by similar
-# script used by whefs.
-########################################################################
-SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
-
-echo "We are about to amalgamate all simdjson files into one source file. "
-echo "See https://www.sqlite.org/amalgamation.html and https://en.wikipedia.org/wiki/Single_Compilation_Unit for rationale. "
-
-AMAL_H="simdjson.h"
-AMAL_C="simdjson.cpp"
-
-SRCPATH="$SCRIPTPATH/src"
-INCLUDEPATH="$SCRIPTPATH/include"
-
-# this list excludes the "src/generic headers"
-ALLCFILES="
-simdjson.cpp
-"
-
-# order matters
-ALLCHEADERS="
-simdjson.h
-"
-
-found_includes=()
-
-for file in ${ALLCFILES}; do
-    test -e "$SRCPATH/$file" && continue
-    echo "FATAL: source file [$SRCPATH/$file] not found."
-    exit 127
-done
-
-for file in ${ALLCHEADERS}; do
-    test -e "$INCLUDEPATH/$file" && continue
-    echo "FATAL: source file [$INCLUDEPATH/$file] not found."
-    exit 127
-done
-
-function doinclude()
-{
-    file=$1
-    line="${@:2}"
-    if [ -f $INCLUDEPATH/$file ]; then
-        if [[ ! " ${found_includes[@]} " =~ " ${file} " ]]; then
-            found_includes+=("$file")
-            dofile $INCLUDEPATH/$file
-        fi;
-    elif [ -f $SRCPATH/$file ]; then
-        # generic includes are included multiple times
-        if [[ "${file}" == *'generic/'*'.h' ]]; then
-            dofile $SRCPATH/$file
-        elif [[ ! " ${found_includes[@]} " =~ " ${file} " ]]; then
-            found_includes+=("$file")
-            dofile $SRCPATH/$file
-        else
-            echo "/* $file already included: $line */"
-        fi
-    else
-      # If we don't recognize it, just emit the #include
-      echo "$line"
-    fi
-}
-
-function dofile()
-{
-    # Last lines are always ignored. Files should end by an empty lines.
-    RELFILE=${1#"$SCRIPTPATH/"}
-    echo "/* begin file $RELFILE */"
-    # echo "#line 8 \"$1\"" ## redefining the line/file is not nearly as useful as it sounds for debugging. It breaks IDEs.
-    while IFS= read -r line || [ -n "$line" ];
-    do
-        if [[ "${line}" == '#include "'*'"'* ]]; then
-            file=$(echo $line| cut -d'"' -f 2)
-
-            if [[ "${file}" == '../'* ]]; then
-                file=$(echo $file| cut -d'/' -f 2-)
-            fi;
-
-            # we explicitly include simdjson headers, one time each (unless they are generic, in which case multiple times is fine)
-            doinclude $file $line
-        else
-            # Otherwise we simply copy the line
-            echo "$line"
-        fi
-    done < "$1"
-    echo "/* end file $RELFILE */"
-}
-timestamp=$(date)
-echo "Creating ${AMAL_H}..."
-echo "/* auto-generated on ${timestamp}. Do not edit! */" > "${AMAL_H}"
-{
-    for h in ${ALLCHEADERS}; do
-        doinclude $h "ERROR $h not found"
-    done
-} >> "${AMAL_H}"
-
-
-echo "Creating ${AMAL_C}..."
-echo "/* auto-generated on ${timestamp}. Do not edit! */" > "${AMAL_C}"
-{
-    echo "#include \"${AMAL_H}\""
-
-    echo ""
-    echo "/* used for http://dmalloc.com/ Dmalloc - Debug Malloc Library */"
-    echo "#ifdef DMALLOC"
-    echo "#include \"dmalloc.h\""
-    echo "#endif"
-    echo ""
-
-    for file in ${ALLCFILES}; do
-        dofile "$SRCPATH/$file"
-    done
-} >> "${AMAL_C}"
-
-
-DEMOCPP="amalgamation_demo.cpp"
-echo "Creating ${DEMOCPP}..."
-echo "/* auto-generated on ${timestamp}. Do not edit! */" > "${DEMOCPP}"
-cat <<< '
-#include <iostream>
-#include "simdjson.h"
-#include "simdjson.cpp"
-int main(int argc, char *argv[]) {
-  if(argc < 2) {
-    std::cerr << "Please specify at least one file name. " << std::endl;
-  }
-  const char * filename = argv[1];
-  simdjson::dom::parser parser;
-  auto [doc, error] = parser.load(filename); // do the parsing
-  if (error) {
-    std::cout << "parse failed" << std::endl;
-    std::cout << "error code: " << error << std::endl;
-    std::cout << error << std::endl;
-  } else {
-    std::cout << "parse valid" << std::endl;
-  }
-  if(argc == 2) {
-    return EXIT_SUCCESS;
-  }
-
-  // parse_many
-  const char * filename2 = argv[2];
-  for (auto result : parser.load_many(filename2)) {
-    error = result.error();
-  }
-  if (error) {
-    std::cout << "parse_many failed" << std::endl;
-    std::cout << "error code: " << error << std::endl;
-    std::cout << error << std::endl;
-  } else {
-    std::cout << "parse_many valid" << std::endl;
-  }
-  return EXIT_SUCCESS;
-}
-' >>  "${DEMOCPP}"
-
-echo "Done with all files generation. "
-
-echo "Files have been written to  directory: $PWD "
-ls -la ${AMAL_C} ${AMAL_H}  ${DEMOCPP}
-
-echo "Giving final instructions:"
-
-
-CPPBIN=${DEMOCPP%%.*}
-
-echo "Try :"
-echo "c++ -O3 -std=c++17 -pthread -o ${CPPBIN} ${DEMOCPP}  && ./${CPPBIN} ../jsonexamples/twitter.json ../jsonexamples/amazon_cellphones.ndjson"
-
-SINGLEHDR=$SCRIPTPATH/singleheader
-echo "Copying files to $SCRIPTPATH/singleheader "
-mkdir -p $SINGLEHDR
-echo "c++ -O3 -std=c++17 -pthread -o ${CPPBIN} ${DEMOCPP}  && ./${CPPBIN} ../jsonexamples/twitter.json ../jsonexamples/amazon_cellphones.ndjson" > $SINGLEHDR/README.md
-cp ${AMAL_C} ${AMAL_H}  ${DEMOCPP} $SINGLEHDR
-ls $SINGLEHDR
-
-cd $SINGLEHDR && c++ -O3 -std=c++17 -pthread -o ${CPPBIN} ${DEMOCPP}  && ./${CPPBIN} ../jsonexamples/twitter.json ../jsonexamples/amazon_cellphones.ndjson
-
-lowercase(){
-    echo "$1" | tr 'A-Z' 'a-z'
-}
-
-OS=`lowercase \`uname\``

benchmark/CMakeLists.txt

@@ -1,21 +1,51 @@
-target_include_directories(${SIMDJSON_LIB_NAME}
+add_subdirectory(dom)
-  INTERFACE
-  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/benchmark>
-  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/benchmark/linux>
-)
 
-add_cpp_benchmark(parse)
-add_cpp_benchmark(statisticalmodel)
-add_cpp_benchmark(parse_stream)
-add_cpp_benchmark(get_corpus_benchmark)
-add_executable(perfdiff perfdiff.cpp)
 
-# Google Benchmarks
+include_directories( . linux )
-if (SIMDJSON_GOOGLE_BENCHMARKS)
+link_libraries(simdjson-windows-headers test-data)
-  add_cpp_benchmark(bench_parse_call)
+link_libraries(simdjson)
-  target_link_libraries(bench_parse_call benchmark::benchmark)
+if(SIMDJSON_STATIC_REFLECTION)
+  add_compile_definitions(SIMDJSON_STATIC_REFLECTION=1)
+endif(SIMDJSON_STATIC_REFLECTION)
 
-  add_cpp_benchmark(bench_dom_api)
+add_executable(benchfeatures benchfeatures.cpp)
-  target_link_libraries(bench_dom_api benchmark::benchmark)
+add_executable(get_corpus_benchmark get_corpus_benchmark.cpp)
-  target_compile_definitions(bench_dom_api PRIVATE JSON_TEST_PATH="${PROJECT_SOURCE_DIR}/jsonexamples/twitter.json")
+
+if (TARGET benchmark::benchmark)
+  link_libraries(benchmark::benchmark)
+  add_executable(bench_parse_call bench_parse_call.cpp)
+  add_executable(bench_dom_api bench_dom_api.cpp)
+  add_executable(bench_stream_formats bench_stream_formats.cpp)
+  if(SIMDJSON_EXCEPTIONS)
+    add_executable(bench_ondemand bench_ondemand.cpp)
+    if(TARGET yyjson)
+      target_link_libraries(bench_ondemand PRIVATE yyjson)
+    endif()
+    if(TARGET rapidjson)
+      target_link_libraries(bench_ondemand PRIVATE rapidjson)
+    endif()
+    if(TARGET sajson)
+      target_link_libraries(bench_ondemand PRIVATE sajson)
+    endif()
+    if(TARGET nlohmann_json)
+      target_link_libraries(bench_ondemand PRIVATE nlohmann_json)
+    endif()
+    if(TARGET boostjson)
+      target_link_libraries(bench_ondemand PRIVATE boostjson)
+    endif()
+  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)
+
+

benchmark/Dockerfile

@@ -1,19 +0,0 @@
-# From the ROOT, run:
-# docker build -t simdjsonbench -f benchmark/Dockerfile . && docker run --privileged -t simdjsonbench
-FROM gcc:8.3
-
-# # Build latest
-# ENV latest_release=v0.2.1
-# WORKDIR /usr/src/$latest_release/
-# RUN git clone --depth 1 https://github.com/lemire/simdjson/ -b $latest_release .
-# RUN make parse
-
-# # Build master
-# WORKDIR /usr/src/master/
-# RUN git clone --depth 1 https://github.com/lemire/simdjson/ .
-# RUN make parse
-
-# Build the current source
-COPY . /usr/src/current/
-WORKDIR /usr/src/current/
-RUN make checkperf

benchmark/accessor_performance/README.md

@@ -0,0 +1,46 @@
+# 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

@@ -0,0 +1,132 @@
+#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

@@ -0,0 +1,56 @@
+#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

@@ -0,0 +1,53 @@
+#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/amazon_cellphones/amazon_cellphones.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include "json_benchmark/file_runner.h"
+#include <map>
+#include <string>
+
+
+namespace amazon_cellphones {
+
+const bool UNTHREADED = false;
+const bool THREADED = true;
+
+using namespace json_benchmark;
+
+struct brand {
+    double cumulative_rating;
+    uint64_t reviews_count;
+    simdjson_inline bool operator==(const brand &other) const {
+        return cumulative_rating == other.cumulative_rating &&
+            reviews_count == other.reviews_count;
+    }
+    simdjson_inline bool operator!=(const brand &other) const { return !(*this == other); }
+};
+
+simdjson_unused static std::ostream &operator<<(std::ostream &o, const brand &b) {
+  o << "cumulative_rating: " << b.cumulative_rating << std::endl;
+  o << "reviews_count: " << b.reviews_count << std::endl;
+  return o;
+}
+
+template<typename StringType>
+simdjson_unused static std::ostream &operator<<(std::ostream &o, const std::pair<const StringType, brand> &p) {
+  o << "brand: " << p.first << std::endl;
+	o << p.second;
+  return o;
+}
+
+template<typename I>
+struct runner : public file_runner<I> {
+    std::map<typename I::StringType, brand> result{};
+
+    bool setup(benchmark::State &state) {
+        return this->load_json(state, AMAZON_CELLPHONES_NDJSON);
+    }
+
+    bool before_run(benchmark::State &state) {
+        if (!file_runner<I>::before_run(state)) { return false; }
+        result.clear();
+        return true;
+    }
+
+    bool run(benchmark::State &) {
+        return this->implementation.run(this->json, result);
+    }
+
+    template<typename R>
+    bool diff(benchmark::State &state, runner<R> &reference) {
+        return diff_results(state, result, reference.result, diff_flags::NONE);
+    }
+
+    size_t items_per_iteration() {
+        return result.size();
+    }
+};
+
+template<bool threaded>
+struct simdjson_dom;
+
+template<typename I> simdjson_inline static void amazon_cellphones(benchmark::State &state) {
+  run_json_benchmark<runner<I>, runner<simdjson_dom<UNTHREADED>>>(state);
+}
+
+}   // namespace amazon_cellphones

benchmark/amazon_cellphones/simdjson_dom.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "amazon_cellphones.h"
+
+namespace amazon_cellphones {
+
+using namespace simdjson;
+
+template<bool threaded>
+struct simdjson_dom {
+  using StringType = std::string;
+
+  dom::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::map<StringType, brand> &result) {
+#ifdef SIMDJSON_THREADS_ENABLED
+    parser.threaded = threaded;
+#endif
+    auto stream = parser.parse_many(json);
+    auto i = stream.begin();
+    ++i;  // Skip first line
+    for (;i != stream.end(); ++i) {
+      auto doc = *i;
+      StringType copy(std::string_view(doc.at(1)));
+      auto x = result.find(copy);
+      if (x == result.end()) {  // If key not found, add new key
+        result.emplace(copy, amazon_cellphones::brand{
+          double(doc.at(5)) * uint64_t(doc.at(7)),
+          uint64_t(doc.at(7))
+        });
+      } else {  // Otherwise, update key data
+        x->second.cumulative_rating += double(doc.at(5)) * uint64_t(doc.at(7));
+        x->second.reviews_count += uint64_t(doc.at(7));
+      }
+    }
+
+    return true;
+  }
+
+};
+
+BENCHMARK_TEMPLATE(amazon_cellphones, simdjson_dom<UNTHREADED>)->UseManualTime();
+#ifdef SIMDJSON_THREADS_ENABLED
+BENCHMARK_TEMPLATE(amazon_cellphones, simdjson_dom<THREADED>)->UseManualTime();
+#endif
+
+} // namespace amazon_cellphones
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/amazon_cellphones/simdjson_ondemand.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "amazon_cellphones.h"
+
+namespace amazon_cellphones {
+
+using namespace simdjson;
+
+template<bool threaded>
+struct simdjson_ondemand {
+  using StringType = std::string;
+
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::map<StringType, brand> &result) {
+#ifdef SIMDJSON_THREADS_ENABLED
+    parser.threaded = threaded;
+#endif
+    ondemand::document_stream stream = parser.iterate_many(json);
+    ondemand::document_stream::iterator i = stream.begin();
+    ++i;  // Skip first line
+    for (;i != stream.end(); ++i) {
+      auto doc = *i;
+      size_t index{0};
+      StringType copy;
+      double rating;
+      uint64_t reviews;
+      for ( auto value : doc ) {
+        switch (index)
+        {
+        case 1:
+          copy = StringType(std::string_view(value));
+          break;
+        case 5:
+          rating = double(value);
+          break;
+        case 7:
+          reviews = uint64_t(value);
+          break;
+        default:
+          break;
+        }
+        index++;
+      }
+
+      auto x = result.find(copy);
+      if (x == result.end()) {  // If key not found, add new key
+        result.emplace(copy, amazon_cellphones::brand{
+          rating * reviews,
+          reviews
+        });
+      } else {  // Otherwise, update key data
+        x->second.cumulative_rating += rating * reviews;
+        x->second.reviews_count += reviews;
+      }
+    }
+
+    return true;
+  }
+
+};
+
+BENCHMARK_TEMPLATE(amazon_cellphones, simdjson_ondemand<UNTHREADED>)->UseManualTime();
+#ifdef SIMDJSON_THREADS_ENABLED
+BENCHMARK_TEMPLATE(amazon_cellphones, simdjson_ondemand<THREADED>)->UseManualTime();
+#endif
+
+} // namespace amazon_cellphones
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/bench_dom_api.cpp

@@ -1,4 +1,5 @@
 #include <benchmark/benchmark.h>
+#include <iostream>
 #include "simdjson.h"
 #include <sstream>
 
@@ -6,55 +7,482 @@ using namespace simdjson;
 using namespace benchmark;
 using namespace std;
 
-#ifndef JSON_TEST_PATH
-#define JSON_TEST_PATH "jsonexamples/twitter.json"
-#endif
-
 const padded_string EMPTY_ARRAY("[]", 2);
 
+static const char *TWITTER_JSON = SIMDJSON_BENCHMARK_DATA_DIR "twitter.json";
+static const char *NUMBERS_JSON = SIMDJSON_BENCHMARK_DATA_DIR "numbers.json";
+
+static void recover_one_string(State& state) {
+  dom::parser parser;
+  const std::string_view data = "\"one string\"";
+  padded_string docdata{data};
+  // we do not want mem. alloc. in the loop.
+  auto error = parser.allocate(docdata.size());
+  if(error) {
+      cout << error << endl;
+      return;
+  }
+  dom::element doc;
+  if ((error = parser.parse(docdata).get(doc))) {
+    cerr << "could not parse string" << error << endl;
+    return;
+  }
+  for (simdjson_unused auto _ : state) {
+      std::string_view v;
+      error = doc.get(v);
+      if (error) {
+        cerr << "could not get string" << error << endl;
+        return;
+      }
+      benchmark::DoNotOptimize(v);
+  }
+}
+BENCHMARK(recover_one_string);
+
+
+static void serialize_twitter(State& state) {
+  dom::parser parser;
+  padded_string docdata;
+  auto error = padded_string::load(TWITTER_JSON).get(docdata);
+  if(error) {
+      cerr << "could not parse twitter.json" << error << endl;
+      return;
+  }
+  // we do not want mem. alloc. in the loop.
+  if((error = parser.allocate(docdata.size()))) {
+      cout << error << endl;
+      return;
+  }
+  dom::element doc;
+  if ((error = parser.parse(docdata).get(doc))) {
+    cerr << "could not parse twitter.json" << error << endl;
+    return;
+  }
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    std::string serial = simdjson::minify(doc);
+    bytes += serial.size();
+    benchmark::DoNotOptimize(serial);
+  }
+  // we validate the result
+  {
+    auto serial = simdjson::minify(doc);
+    dom::element doc2; // we parse the minified output
+    if ((error = parser.parse(serial).get(doc2))) { throw std::runtime_error("serialization error"); }
+    auto serial2 = simdjson::minify(doc2); // we minify a second time
+    if(serial != serial2) { throw std::runtime_error("serialization mismatch"); }
+  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+  state.counters["Gigabytes"] = benchmark::Counter(
+	        double(bytes), benchmark::Counter::kIsRate,
+	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
+  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
+}
+BENCHMARK(serialize_twitter)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+
+static void serialize_big_string_to_string(State& state) {
+  dom::parser parser;
+  std::vector<char> content;
+  content.push_back('\"');
+  for(size_t i = 0 ; i < 100000; i ++) {
+    content.push_back('0' + char(i%10)); // we add what looks like a long list of digits
+  }
+  content.push_back('\"');
+  dom::element doc;
+  simdjson::error_code error;
+  if ((error = parser.parse(content.data(), content.size()).get(doc))) {
+    cerr << "could not parse big string" << error << endl;
+    return;
+  }
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    auto serial = simdjson::to_string(doc);
+    bytes += serial.size();
+    benchmark::DoNotOptimize(serial);
+  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+  state.counters["Gigabytes"] = benchmark::Counter(
+	        double(bytes), benchmark::Counter::kIsRate,
+	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
+  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
+}
+BENCHMARK(serialize_big_string_to_string)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+
+static void serialize_twitter_to_string(State& state) {
+  dom::parser parser;
+  padded_string docdata;
+  auto error = padded_string::load(TWITTER_JSON).get(docdata);
+  if(error) {
+      cerr << "could not parse twitter.json" << error << endl;
+      return;
+  }
+  // we do not want mem. alloc. in the loop.
+  if((error = parser.allocate(docdata.size()))) {
+      cout << error << endl;
+      return;
+  }
+  dom::element doc;
+  if ((error = parser.parse(docdata).get(doc))) {
+    cerr << "could not parse twitter.json" << error << endl;
+    return;
+  }
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    auto serial = simdjson::to_string(doc);
+    bytes += serial.size();
+    benchmark::DoNotOptimize(serial);
+  }
+  // we validate the result
+  {
+    auto serial = simdjson::to_string(doc);
+    dom::element doc2; // we parse the stringify output
+    if ((error = parser.parse(serial).get(doc2))) { throw std::runtime_error("serialization error"); }
+    auto serial2 = simdjson::to_string(doc2); // we stringify again
+    if(serial != serial2) { throw std::runtime_error("serialization mismatch"); }
+  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+  state.counters["Gigabytes"] = benchmark::Counter(
+	        double(bytes), benchmark::Counter::kIsRate,
+	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
+  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
+}
+BENCHMARK(serialize_twitter_to_string)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+static void serialize_twitter_string_builder(State& state) {
+  dom::parser parser;
+  padded_string docdata;
+  auto error = padded_string::load(TWITTER_JSON).get(docdata);
+  if(error) {
+      cerr << "could not parse twitter.json" << error << endl;
+      return;
+  }
+  // we do not want mem. alloc. in the loop.
+  if((error = parser.allocate(docdata.size()))) {
+      cout << error << endl;
+      return;
+  }
+  dom::element doc;
+  if ((error = parser.parse(docdata).get(doc))) {
+    cerr << "could not parse twitter.json" << error << endl;
+    return;
+  }
+  size_t bytes = 0;
+  simdjson::internal::string_builder<> sb;// not part of our public API, for internal use
+  for (simdjson_unused auto _ : state) {
+    sb.clear();
+    sb.append(doc);
+    std::string_view serial = sb.str();
+    bytes += serial.size();
+    benchmark::DoNotOptimize(serial);
+  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+  state.counters["Gigabytes"] = benchmark::Counter(
+	        double(bytes), benchmark::Counter::kIsRate,
+	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
+  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
+}
+BENCHMARK(serialize_twitter_string_builder)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+
+static void numbers_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr;
+  simdjson::error_code error;
+  if ((error = parser.load(NUMBERS_JSON).get(arr))) {
+    cerr << "could not read " << NUMBERS_JSON << " as an array: " << error << endl;
+    return;
+  }
+  for (simdjson_unused auto _ : state) {
+    std::vector<double> container;
+    for (auto e : arr) {
+      double x;
+      if ((error = e.get(x))) { cerr << "found a node that is not an number: " << error << endl; break;}
+      container.push_back(x);
+    }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_scan);
+
+static void numbers_size_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr;
+  simdjson::error_code error;
+  if ((error = parser.load(NUMBERS_JSON).get(arr))) {
+    cerr << "could not read " << NUMBERS_JSON << " as an array: " << error << endl;
+    return;
+  }
+  for (simdjson_unused auto _ : state) {
+    std::vector<double> container;
+    container.resize(arr.size());
+    size_t pos = 0;
+    for (auto e : arr) {
+      double x;
+      if ((error = e.get(x))) { cerr << "found a node that is not an number: " << error << endl; break;}
+      container[pos++] = x;
+    }
+    if(pos != container.size()) { cerr << "bad count" << endl; }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_size_scan);
+
+
+static void numbers_type_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr;
+  simdjson::error_code error;
+  if ((error = parser.load(NUMBERS_JSON).get(arr))) {
+    cerr << "could not read " << NUMBERS_JSON << " as an array" << endl;
+    return;
+  }
+  for (simdjson_unused auto _ : state) {
+    std::vector<double> container;
+    for (auto e : arr) {
+      dom::element_type actual_type = e.type();
+      if(actual_type != dom::element_type::DOUBLE) {
+        cerr << "found a node that is not an number?" << endl; break;
+      }
+      double x;
+      error = e.get(x);
+      container.push_back(x);
+    }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_type_scan);
+
+static void numbers_type_size_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr;
+  simdjson::error_code error;
+  if ((error = parser.load(NUMBERS_JSON).get(arr))) {
+    cerr << "could not read " << NUMBERS_JSON << " as an array: " << error << endl;
+    return;
+  }
+  for (simdjson_unused auto _ : state) {
+    std::vector<double> container;
+    container.resize(arr.size());
+    size_t pos = 0;
+    for (auto e : arr) {
+      dom::element_type actual_type = e.type();
+      if(actual_type != dom::element_type::DOUBLE) {
+        cerr << "found a node that is not an number?" << endl; break;
+      }
+      double x;
+      error = e.get(x);
+      container[pos++] = x;
+    }
+    if(pos != container.size()) { cerr << "bad count" << endl; }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_type_size_scan);
+
+static void numbers_load_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr;
+  simdjson::error_code error;
+  for (simdjson_unused auto _ : state) {
+    // this may hit the disk, but probably just once
+    if ((error = parser.load(NUMBERS_JSON).get(arr))) {
+      cerr << "could not read " << NUMBERS_JSON << " as an array: " << error << endl;
+      break;
+    }
+    std::vector<double> container;
+    for (auto e : arr) {
+      double x;
+      if ((error = e.get(x))) { cerr << "found a node that is not an number: " << error << endl; break;}
+      container.push_back(x);
+    }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_load_scan);
+
+static void numbers_load_size_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr;
+  simdjson::error_code error;
+  for (simdjson_unused auto _ : state) {
+    // this may hit the disk, but probably just once
+    if ((error = parser.load(NUMBERS_JSON).get(arr))) {
+      cerr << "could not read " << NUMBERS_JSON << " as an array" << endl;
+      break;
+    }
+    std::vector<double> container;
+    container.resize(arr.size());
+    size_t pos = 0;
+    for (auto e : arr) {
+      double x;
+      if ((error = e.get(x))) { cerr << "found a node that is not an number?" << endl; break;}
+      container[pos++] = x;
+    }
+    if(pos != container.size()) { cerr << "bad count" << endl; }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_load_size_scan);
+
+
 #if SIMDJSON_EXCEPTIONS
 
+
+static void numbers_exceptions_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr = parser.load(NUMBERS_JSON);
+  for (simdjson_unused auto _ : state) {
+    std::vector<double> container;
+    for (double x : arr) {
+      container.push_back(x);
+    }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_exceptions_scan);
+
+static void numbers_exceptions_size_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr = parser.load(NUMBERS_JSON);
+  for (simdjson_unused auto _ : state) {
+    std::vector<double> container;
+    container.resize(arr.size());
+    size_t pos = 0;
+    for (auto e : arr) {
+      container[pos++] = double(e);
+    }
+    if(pos != container.size()) { cerr << "bad count" << endl; }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_exceptions_size_scan);
+
+
+
+static void numbers_type_exceptions_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr = parser.load(NUMBERS_JSON);
+  for (simdjson_unused auto _ : state) {
+    std::vector<double> container;
+    for (auto e : arr) {
+      dom::element_type actual_type = e.type();
+      if(actual_type != dom::element_type::DOUBLE) {
+        cerr << "found a node that is not an number?" << endl; break;
+      }
+      container.push_back(double(e));
+    }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_type_exceptions_scan);
+
+static void numbers_type_exceptions_size_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  dom::array arr = parser.load(NUMBERS_JSON);
+  for (simdjson_unused auto _ : state) {
+    std::vector<double> container;
+    container.resize(arr.size());
+    size_t pos = 0;
+    for (auto e : arr) {
+      dom::element_type actual_type = e.type();
+      if(actual_type != dom::element_type::DOUBLE) {
+        cerr << "found a node that is not an number?" << endl; break;
+      }
+      container[pos++] = double(e);
+    }
+    if(pos != container.size()) { cerr << "bad count" << endl; }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_type_exceptions_size_scan);
+
+static void numbers_exceptions_load_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  for (simdjson_unused auto _ : state) {
+    // this may hit the disk, but probably just once
+    dom::array arr = parser.load(NUMBERS_JSON);
+    std::vector<double> container;
+    for (double x : arr) {
+      container.push_back(x);
+    }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_exceptions_load_scan);
+
+static void numbers_exceptions_load_size_scan(State& state) {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+  for (simdjson_unused auto _ : state) {
+    // this may hit the disk, but probably just once
+    dom::array arr = parser.load(NUMBERS_JSON);
+    std::vector<double> container;
+    container.resize(arr.size());
+    size_t pos = 0;
+    for (double x : arr) {
+      container[pos++] = x;
+    }
+    if(pos != container.size()) { cerr << "bad count" << endl; }
+    benchmark::DoNotOptimize(container.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(numbers_exceptions_load_size_scan);
+
+
 static void twitter_count(State& state) {
   // Prints the number of results in twitter.json
   dom::parser parser;
-  dom::element doc = parser.load(JSON_TEST_PATH);
+  dom::element doc = parser.load(TWITTER_JSON);
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
     uint64_t result_count = doc["search_metadata"]["count"];
     if (result_count != 100) { return; }
   }
 }
 BENCHMARK(twitter_count);
 
-SIMDJSON_PUSH_DISABLE_WARNINGS
-SIMDJSON_DISABLE_DEPRECATED_WARNING
-static void iterator_twitter_count(State& state) {
-  // Prints the number of results in twitter.json
-  padded_string json = padded_string::load(JSON_TEST_PATH);
-  ParsedJson pj = build_parsed_json(json);
-  for (auto _ : state) {
-    ParsedJson::Iterator iter(pj);
-    // uint64_t result_count = doc["search_metadata"]["count"];
-    if (!iter.move_to_key("search_metadata")) { return; }
-    if (!iter.move_to_key("count")) { return; }
-    if (!iter.is_integer()) { return; }
-    int64_t result_count = iter.get_integer();
-
-    if (result_count != 100) { return; }
-  }
-}
-BENCHMARK(iterator_twitter_count);
-SIMDJSON_POP_DISABLE_WARNINGS
-
 static void twitter_default_profile(State& state) {
   // Count unique users with a default profile.
   dom::parser parser;
-  dom::element doc = parser.load(JSON_TEST_PATH);
+  dom::element doc = parser.load(TWITTER_JSON);
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
     set<string_view> default_users;
-    for (dom::object tweet : doc["statuses"].get<dom::array>()) {
+    for (dom::object tweet : doc["statuses"]) {
       dom::object user = tweet["user"];
       if (user["default_profile"]) {
-        default_users.insert(user["screen_name"]);
+        default_users.emplace(user["screen_name"]);
       }
     }
     if (default_users.size() != 86) { return; }
@@ -65,15 +493,16 @@ BENCHMARK(twitter_default_profile);
 static void twitter_image_sizes(State& state) {
   // Count unique image sizes
   dom::parser parser;
-  dom::element doc = parser.load(JSON_TEST_PATH);
+  dom::element doc = parser.load(TWITTER_JSON);
-  for (auto _ : state) {
+  simdjson::error_code error;
+  for (simdjson_unused auto _ : state) {
     set<tuple<uint64_t, uint64_t>> image_sizes;
-    for (dom::object tweet : doc["statuses"].get<dom::array>()) {
+    for (dom::object tweet : doc["statuses"]) {
-      auto [media, not_found] = tweet["entities"]["media"];
+      dom::array media;
-      if (!not_found) {
+      if (! (error = tweet["entities"]["media"].get(media))) {
-        for (dom::object image : media.get<dom::array>()) {
+        for (dom::object image : media) {
-          for (auto [key, size] : image["sizes"].get<dom::object>()) {
+          for (auto size : image["sizes"].get_object()) {
-            image_sizes.insert({ size["w"], size["h"] });
+             image_sizes.emplace(size.value["w"], size.value["h"]);
           }
         }
       }
@@ -88,10 +517,12 @@ BENCHMARK(twitter_image_sizes);
 static void error_code_twitter_count(State& state) noexcept {
   // Prints the number of results in twitter.json
   dom::parser parser;
-  dom::element doc = parser.load(JSON_TEST_PATH);
+  simdjson::error_code error;
-  for (auto _ : state) {
+  dom::element doc;
-    auto [value, error] = doc["search_metadata"]["count"].get<uint64_t>();
+  if ((error = parser.load(TWITTER_JSON).get(doc))) { return; }
-    if (error) { return; }
+  for (simdjson_unused auto _ : state) {
+    uint64_t value;
+    if ((error = doc["search_metadata"]["count"].get(value))) { return; }
     if (value != 100) { return; }
   }
 }
@@ -100,20 +531,22 @@ BENCHMARK(error_code_twitter_count);
 static void error_code_twitter_default_profile(State& state) noexcept {
   // Count unique users with a default profile.
   dom::parser parser;
-  dom::element doc = parser.load(JSON_TEST_PATH);
+  simdjson::error_code error;
-  for (auto _ : state) {
+  dom::element doc;
+  if ((error = parser.load(TWITTER_JSON).get(doc))) { std::cerr << error << std::endl; return; }
+  for (simdjson_unused auto _ : state) {
     set<string_view> default_users;
 
-    auto [tweets, error] = doc["statuses"].get<dom::array>();
+    dom::array tweets;
-    if (error) { return; }
+    if ((error = doc["statuses"].get(tweets))) { return; }
     for (dom::element tweet : tweets) {
-      auto [user, error2] = tweet["user"].get<dom::object>();
+      dom::object user;
-      if (error2) { return; }
+      if ((error = tweet["user"].get(user))) { return; }
-      auto [default_profile, error3] = user["default_profile"].get<bool>();
+      bool default_profile{};
-      if (error3) { return; }
+      if ((error = user["default_profile"].get(default_profile))) { return; }
       if (default_profile) {
-        auto [screen_name, error4] = user["screen_name"].get<std::string_view>();
+        std::string_view screen_name;
-        if (error4) { return; }
+        if ((error = user["screen_name"].get(screen_name))) { return; }
         default_users.insert(screen_name);
       }
     }
@@ -123,66 +556,27 @@ static void error_code_twitter_default_profile(State& state) noexcept {
 }
 BENCHMARK(error_code_twitter_default_profile);
 
-SIMDJSON_PUSH_DISABLE_WARNINGS
-SIMDJSON_DISABLE_DEPRECATED_WARNING
-static void iterator_twitter_default_profile(State& state) {
-  // Count unique users with a default profile.
-  padded_string json = padded_string::load(JSON_TEST_PATH);
-  ParsedJson pj = build_parsed_json(json);
-  for (auto _ : state) {
-    set<string_view> default_users;
-    ParsedJson::Iterator iter(pj);
-
-    // for (dom::object tweet : doc["statuses"].get<dom::array>()) {
-    if (!(iter.move_to_key("statuses") && iter.is_array())) { return; }
-    if (iter.down()) { // first status
-      do {
-
-        // dom::object user = tweet["user"];
-        if (!(iter.move_to_key("user") && iter.is_object())) { return; }
-
-        // if (user["default_profile"]) {
-        if (iter.move_to_key("default_profile")) {
-          if (iter.is_true()) {
-            if (!iter.up()) { return; } // back to user
-
-            // default_users.insert(user["screen_name"]);
-            if (!(iter.move_to_key("screen_name") && iter.is_string())) { return; }
-            default_users.insert(string_view(iter.get_string(), iter.get_string_length()));
-          }
-          if (!iter.up()) { return; } // back to user
-        }
-
-        if (!iter.up()) { return; } // back to status
-
-      } while (iter.next()); // next status
-    }
-
-    if (default_users.size() != 86) { return; }
-  }
-}
-SIMDJSON_POP_DISABLE_WARNINGS
-BENCHMARK(iterator_twitter_default_profile);
-
 static void error_code_twitter_image_sizes(State& state) noexcept {
   // Count unique image sizes
   dom::parser parser;
-  dom::element doc = parser.load(JSON_TEST_PATH);
+  simdjson::error_code error;
-  for (auto _ : state) {
+  dom::element doc;
+  if ((error = parser.load(TWITTER_JSON).get(doc))) { std::cerr << error << std::endl; return; }
+  for (simdjson_unused auto _ : state) {
     set<tuple<uint64_t, uint64_t>> image_sizes;
-    auto [statuses, error] = doc["statuses"].get<dom::array>();
+    dom::array statuses;
-    if (error) { return; }
+    if ((error = doc["statuses"].get(statuses))) { return; }
     for (dom::element tweet : statuses) {
-      auto [images, not_found] = tweet["entities"]["media"].get<dom::array>();
+      dom::array images;
-      if (!not_found) {
+      if (! (error = tweet["entities"]["media"].get(images))) {
         for (dom::element image : images) {
-          auto [sizes, error2] = image["sizes"].get<dom::object>();
+          dom::object sizes;
-          if (error2) { return; }
+          if ((error = image["sizes"].get(sizes))) { return; }
-          for (auto [key, size] : sizes) {
+          for (auto size : sizes) {
-            auto [width, error3] = size["w"].get<uint64_t>();
+            uint64_t width, height;
-            auto [height, error4] = size["h"].get<uint64_t>();
+            if ((error = size.value["w"].get(width))) { return; }
-            if (error3 || error4) { return; }
+            if ((error = size.value["h"].get(height))) { return; }
-            image_sizes.insert({ width, height });
+            image_sizes.emplace(width, height);
           }
         }
       }
@@ -192,77 +586,28 @@ static void error_code_twitter_image_sizes(State& state) noexcept {
 }
 BENCHMARK(error_code_twitter_image_sizes);
 
-SIMDJSON_PUSH_DISABLE_WARNINGS
+static void parse_surrogate_pairs(State& state) {
-SIMDJSON_DISABLE_DEPRECATED_WARNING
+  // NOTE: This mostly exists to show there's a tiny benefit to
-static void iterator_twitter_image_sizes(State& state) {
+  // loading and comparing both bytes of "\\u" simultaneously.
-  // Count unique image sizes
+  // (which should also reduce the compiled code size).
-  padded_string json = padded_string::load(JSON_TEST_PATH);
+  // The repeated surrogate pairs make this easier to measure.
-  ParsedJson pj = build_parsed_json(json);
-  for (auto _ : state) {
-    set<tuple<uint64_t, uint64_t>> image_sizes;
-    ParsedJson::Iterator iter(pj);
-
-    // for (dom::object tweet : doc["statuses"].get<dom::array>()) {
-    if (!(iter.move_to_key("statuses") && iter.is_array())) { return; }
-    if (iter.down()) { // first status
-      do {
-
-        // auto [media, not_found] = tweet["entities"]["media"];
-        // if (!not_found) {
-        if (iter.move_to_key("entities")) {
-          if (!iter.is_object()) { return; }
-          if (iter.move_to_key("media")) {
-            if (!iter.is_array()) { return; }
-
-            //   for (dom::object image : media.get<dom::array>()) {
-            if (iter.down()) { // first media
-              do {
-
-                // for (auto [key, size] : image["sizes"].get<dom::object>()) {
-                if (!(iter.move_to_key("sizes") && iter.is_object())) { return; }
-                if (iter.down()) { // first size
-                  do {
-                    iter.move_to_value();
-
-                    // image_sizes.insert({ size["w"], size["h"] });
-                    if (!(iter.move_to_key("w")) && !iter.is_integer()) { return; }
-                    uint64_t width = iter.get_integer();
-                    if (!iter.up()) { return; } // back to size
-                    if (!(iter.move_to_key("h")) && !iter.is_integer()) { return; }
-                    uint64_t height = iter.get_integer();
-                    if (!iter.up()) { return; } // back to size
-                    image_sizes.insert({ width, height });
-
-                  } while (iter.next()); // next size
-                  if (!iter.up()) { return; } // back to sizes
-                }
-                if (!iter.up()) { return; } // back to image
-              } while (iter.next()); // next image
-              if (!iter.up()) { return; } // back to media
-            }
-            if (!iter.up()) { return; } // back to entities
-          }
-          if (!iter.up()) { return; } // back to status
-        } 
-      } while (iter.next()); // next status
-    }
-
-    if (image_sizes.size() != 15) { return; };
-  }
-}
-BENCHMARK(iterator_twitter_image_sizes);
-
-static void print_json(State& state) noexcept {
-  // Prints the number of results in twitter.json
-  padded_string json = get_corpus(JSON_TEST_PATH);
   dom::parser parser;
-  if (int error = json_parse(json, parser); error != SUCCESS) { cerr << error_message(error) << endl; return; }
+  const std::string_view data = "\"\\uD834\\uDD1E\\uD834\\uDD1E\\uD834\\uDD1E\\uD834\\uDD1E\\uD834\\uDD1E\\uD834\\uDD1E\\uD834\\uDD1E\\uD834\\uDD1E\\uD834\\uDD1E\\uD834\\uDD1E\"";
-  for (auto _ : state) {
+  padded_string docdata{data};
-    std::stringstream s;
+  // we do not want mem. alloc. in the loop.
-    if (!parser.print_json(s)) { cerr << "print_json failed" << endl; return; }
+  auto error = parser.allocate(docdata.size());
+  if (error) {
+    cout << error << endl;
+    return;
+  }
+  for (simdjson_unused auto _ : state) {
+    dom::element doc;
+    if ((error = parser.parse(docdata).get(doc))) {
+      cerr << "could not parse string" << error << endl;
+      return;
+    }
   }
 }
-BENCHMARK(print_json);
+BENCHMARK(parse_surrogate_pairs);
-SIMDJSON_POP_DISABLE_WARNINGS
 
 BENCHMARK_MAIN();

benchmark/bench_ondemand.cpp

@@ -0,0 +1,156 @@
+#include "simdjson.h"
+
+SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
+
+#ifdef SIMDJSON_COMPETITION_YYJSON
+#include "yyjson.h"
+#endif
+
+#ifdef SIMDJSON_COMPETITION_RAPIDJSON
+#include "rapidjson/document.h"
+#include "rapidjson/reader.h"
+#include "rapidjson/stringbuffer.h"
+#include "rapidjson/writer.h"
+#endif
+
+#ifdef SIMDJSON_COMPETITION_SAJSON
+#include "sajson.h"
+#endif
+
+#ifdef SIMDJSON_COMPETITION_NLOHMANN_JSON
+#include <nlohmann/json.hpp>
+#endif
+
+#ifdef SIMDJSON_COMPETITION_BOOSTJSON
+#include <boost/json.hpp>
+#endif
+
+// This has to be last, for reasons I don't yet understand
+#include <benchmark/benchmark.h>
+
+SIMDJSON_POP_DISABLE_WARNINGS
+#include "json2msgpack/simdjson_ondemand.h"
+#include "json2msgpack/simdjson_dom.h"
+#include "json2msgpack/yyjson.h"
+#include "json2msgpack/rapidjson.h"
+#if SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "json2msgpack/sajson.h"
+#endif // SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "json2msgpack/nlohmann_json.h"
+#include "json2msgpack/boostjson.h"
+
+#include "partial_tweets/simdjson_ondemand.h"
+#include "partial_tweets/simdjson_dom.h"
+#include "partial_tweets/yyjson.h"
+#if SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "partial_tweets/sajson.h"
+#endif // SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "partial_tweets/rapidjson.h"
+#if SIMDJSON_COMPETITION_SAX
+#include "partial_tweets/rapidjson_sax.h"
+#endif // SIMDJSON_COMPETITION_SAX
+#include "partial_tweets/nlohmann_json.h"
+#if SIMDJSON_COMPETITION_SAX
+#include "partial_tweets/nlohmann_json_sax.h"
+#endif // SIMDJSON_COMPETITION_SAX
+#include "partial_tweets/boostjson.h"
+
+
+#include "distinct_user_id/simdjson_ondemand.h"
+#include "distinct_user_id/simdjson_ondemand_json_pointer.h"
+#include "distinct_user_id/simdjson_dom.h"
+#include "distinct_user_id/simdjson_dom_json_pointer.h"
+#include "distinct_user_id/yyjson.h"
+#if SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "distinct_user_id/sajson.h"
+#endif // SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "distinct_user_id/rapidjson.h"
+#if SIMDJSON_COMPETITION_SAX
+#include "distinct_user_id/rapidjson_sax.h"
+#endif // SIMDJSON_COMPETITION_SAX
+#include "distinct_user_id/nlohmann_json.h"
+#if SIMDJSON_COMPETITION_SAX
+#include "distinct_user_id/nlohmann_json_sax.h"
+#endif // SIMDJSON_COMPETITION_SAX
+#include "distinct_user_id/boostjson.h"
+
+#include "find_tweet/simdjson_ondemand.h"
+#include "find_tweet/simdjson_dom.h"
+#include "find_tweet/yyjson.h"
+#if SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "find_tweet/sajson.h"
+#endif // SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "find_tweet/rapidjson.h"
+#if SIMDJSON_COMPETITION_SAX
+#include "find_tweet/rapidjson_sax.h"
+#endif // SIMDJSON_COMPETITION_SAX
+#include "find_tweet/nlohmann_json.h"
+#if SIMDJSON_COMPETITION_SAX
+#include "find_tweet/nlohmann_json_sax.h"
+#endif // SIMDJSON_COMPETITION_SAX
+#include "find_tweet/boostjson.h"
+
+#include "top_tweet/simdjson_ondemand.h"
+#include "top_tweet/simdjson_dom.h"
+#include "top_tweet/yyjson.h"
+#if SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "top_tweet/sajson.h"
+#endif // SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "top_tweet/rapidjson.h"
+#if SIMDJSON_COMPETITION_SAX
+#include "top_tweet/rapidjson_sax.h"
+#endif // SIMDJSON_COMPETITION_SAX
+#include "top_tweet/nlohmann_json.h"
+#if SIMDJSON_COMPETITION_SAX
+#include "top_tweet/nlohmann_json_sax.h"
+#endif // SIMDJSON_COMPETITION_SAX
+#include "top_tweet/boostjson.h"
+
+
+#include "kostya/simdjson_ondemand.h"
+#include "kostya/simdjson_dom.h"
+#include "kostya/yyjson.h"
+#if SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "kostya/sajson.h"
+#endif // SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "kostya/rapidjson.h"
+#if SIMDJSON_COMPETITION_SAX
+#include "kostya/rapidjson_sax.h"
+#endif // SIMDJSON_COMPETITION_SAX
+#include "kostya/nlohmann_json.h"
+#if SIMDJSON_COMPETITION_SAX
+#include "kostya/nlohmann_json_sax.h"
+#endif // SIMDJSON_COMPETITION_SAX
+#include "kostya/boostjson.h"
+
+#include "large_random/simdjson_ondemand.h"
+#if SIMDJSON_COMPETITION_ONDEMAND_UNORDERED
+#include "large_random/simdjson_ondemand_unordered.h"
+#endif // SIMDJSON_COMPETITION_ONDEMAND_UNORDERED
+#include "large_random/simdjson_dom.h"
+#include "large_random/yyjson.h"
+#if SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "large_random/sajson.h"
+#endif // SIMDJSON_COMPETITION_ONDEMAND_SAJSON
+#include "large_random/rapidjson.h"
+#if SIMDJSON_COMPETITION_SAX
+#include "large_random/rapidjson_sax.h"
+#endif // SIMDJSON_COMPETITION_SAX
+#include "large_random/nlohmann_json.h"
+#if SIMDJSON_COMPETITION_SAX
+#include "large_random/nlohmann_json_sax.h"
+#endif // SIMDJSON_COMPETITION_SAX
+#include "large_random/boostjson.h"
+
+#include "amazon_cellphones/simdjson_dom.h"
+#include "amazon_cellphones/simdjson_ondemand.h"
+
+#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/bench_parse_call.cpp

@@ -1,73 +1,226 @@
 #include <benchmark/benchmark.h>
+#include <iostream>
 #include "simdjson.h"
 using namespace simdjson;
 using namespace benchmark;
 using namespace std;
 
 const padded_string EMPTY_ARRAY("[]", 2);
+const char *TWITTER_JSON = SIMDJSON_BENCHMARK_DATA_DIR "twitter.json";
+const char *GSOC_JSON = SIMDJSON_BENCHMARK_DATA_DIR "gsoc-2018.json";
 
-SIMDJSON_PUSH_DISABLE_WARNINGS
+
-SIMDJSON_DISABLE_DEPRECATED_WARNING
+
-static void json_parse(State& state) {
+
-  ParsedJson pj;
+static void fast_minify_twitter(State& state) {
-  if (!pj.allocate_capacity(EMPTY_ARRAY.length())) { return; }
+  dom::parser parser;
-  for (auto _ : state) {
+  padded_string docdata;
-    auto error = json_parse(EMPTY_ARRAY, pj);
+  auto error = padded_string::load(TWITTER_JSON).get(docdata);
-    if (error) { return; }
+  if(error) {
+      cerr << "could not parse twitter.json" << error << endl;
+      return;
   }
+  std::unique_ptr<char[]> buffer{new char[docdata.size()]};
+
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    size_t new_length{}; // It will receive the minified length.
+    auto error = simdjson::minify(docdata.data(), docdata.size(), buffer.get(), new_length);
+    bytes += docdata.size();
+    benchmark::DoNotOptimize(error);
+  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+  state.counters["Gigabytes"] = benchmark::Counter(
+	        double(bytes), benchmark::Counter::kIsRate,
+	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
+  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
 }
-SIMDJSON_POP_DISABLE_WARNINGS
+BENCHMARK(fast_minify_twitter)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
-BENCHMARK(json_parse);
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+
+
+
+static void fast_minify_gsoc(State& state) {
+  dom::parser parser;
+  padded_string docdata;
+  auto error = padded_string::load(GSOC_JSON).get(docdata);
+  if(error) {
+      cerr << "could not parse gsoc-2018.json" << error << endl;
+      return;
+  }
+  std::unique_ptr<char[]> buffer{new char[docdata.size()]};
+
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    size_t new_length{}; // It will receive the minified length.
+    auto error = simdjson::minify(docdata.data(), docdata.size(), buffer.get(), new_length);
+    bytes += docdata.size();
+    benchmark::DoNotOptimize(error);
+  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+  state.counters["Gigabytes"] = benchmark::Counter(
+	        double(bytes), benchmark::Counter::kIsRate,
+	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
+  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
+}
+BENCHMARK(fast_minify_gsoc)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+static void unicode_validate_twitter(State& state) {
+  dom::parser parser;
+  padded_string docdata;
+  auto error = padded_string::load(TWITTER_JSON).get(docdata);
+  if(error) {
+      cerr << "could not parse twitter.json" << error << endl;
+      return;
+  }
+  // we do not want mem. alloc. in the loop.
+  error = parser.allocate(docdata.size());
+  if(error) {
+      cout << error << endl;
+      return;
+  }
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    bool is_ok = simdjson::validate_utf8(docdata.data(), docdata.size());
+    bytes += docdata.size();
+    benchmark::DoNotOptimize(is_ok);
+  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+  state.counters["Gigabytes"] = benchmark::Counter(
+	        double(bytes), benchmark::Counter::kIsRate,
+	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
+  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
+}
+BENCHMARK(unicode_validate_twitter)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+static void parse_twitter(State& state) {
+  dom::parser parser;
+  padded_string docdata;
+  auto error = padded_string::load(TWITTER_JSON).get(docdata);
+  if(error) {
+      cerr << "could not parse twitter.json" << error << endl;
+      return;
+  }
+  // we do not want mem. alloc. in the loop.
+  error = parser.allocate(docdata.size());
+  if(error) {
+      cout << error << endl;
+      return;
+  }
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    dom::element doc;
+    bytes += docdata.size();
+    if ((error = parser.parse(docdata).get(doc))) {
+      cerr << "could not parse twitter.json" << error << endl;
+      return;
+    }
+    benchmark::DoNotOptimize(doc);
+  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+  state.counters["Gigabytes"] = benchmark::Counter(
+	        double(bytes), benchmark::Counter::kIsRate,
+	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
+  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
+}
+BENCHMARK(parse_twitter)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+
+static void parse_gsoc(State& state) {
+  dom::parser parser;
+  padded_string docdata;
+  auto error = padded_string::load(GSOC_JSON).get(docdata);
+  if(error) {
+      cerr << "could not parse gsoc-2018.json" << error << endl;
+      return;
+  }
+  // we do not want mem. alloc. in the loop.
+  error = parser.allocate(docdata.size());
+  if(error) {
+      cout << error << endl;
+      return;
+  }
+  size_t bytes = 0;
+  for (simdjson_unused auto _ : state) {
+    bytes += docdata.size();
+    dom::element doc;
+    if ((error = parser.parse(docdata).get(doc))) {
+      cerr << "could not parse gsoc-2018.json" << error << endl;
+      return;
+    }
+    benchmark::DoNotOptimize(doc);
+  }
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+  state.counters["Gigabytes"] = benchmark::Counter(
+	        double(bytes), benchmark::Counter::kIsRate,
+	        benchmark::Counter::OneK::kIs1000); // For GiB : kIs1024
+  state.counters["docs"] = Counter(double(state.iterations()), benchmark::Counter::kIsRate);
+}
+BENCHMARK(parse_gsoc)->Repetitions(10)->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
+    return *(std::max_element(std::begin(v), std::end(v)));
+  })->DisplayAggregatesOnly(true);
+
+
 static void parser_parse_error_code(State& state) {
   dom::parser parser;
   if (parser.allocate(EMPTY_ARRAY.length())) { return; }
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
-    auto [doc, error] = parser.parse(EMPTY_ARRAY);
+    auto error = parser.parse(EMPTY_ARRAY).error();
     if (error) { return; }
   }
 }
 BENCHMARK(parser_parse_error_code);
+
+#if SIMDJSON_EXCEPTIONS
+
 static void parser_parse_exception(State& state) {
   dom::parser parser;
   if (parser.allocate(EMPTY_ARRAY.length())) { return; }
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
     try {
-      UNUSED dom::element doc = parser.parse(EMPTY_ARRAY);
+      simdjson_unused dom::element doc = parser.parse(EMPTY_ARRAY);
     } catch(simdjson_error &j) {
+      cout << j.what() << endl;
       return;
     }
   }
 }
 BENCHMARK(parser_parse_exception);
 
-SIMDJSON_PUSH_DISABLE_WARNINGS
+#endif // SIMDJSON_EXCEPTIONS
-SIMDJSON_DISABLE_DEPRECATED_WARNING
+
-static void build_parsed_json(State& state) {
-  for (auto _ : state) {
-    dom::parser parser = simdjson::build_parsed_json(EMPTY_ARRAY);
-    if (!parser.valid) { return; }
-  }
-}
-SIMDJSON_POP_DISABLE_WARNINGS
-BENCHMARK(build_parsed_json);
 static void document_parse_error_code(State& state) {
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
     dom::parser parser;
-    auto [doc, error] = parser.parse(EMPTY_ARRAY);
+    auto error = parser.parse(EMPTY_ARRAY).error();
     if (error) { return; }
   }
 }
 BENCHMARK(document_parse_error_code);
+
+#if SIMDJSON_EXCEPTIONS
+
 static void document_parse_exception(State& state) {
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
     try {
       dom::parser parser;
-      UNUSED dom::element doc = parser.parse(EMPTY_ARRAY);
+      simdjson_unused dom::element doc = parser.parse(EMPTY_ARRAY);
     } catch(simdjson_error &j) {
+      cout << j.what() << endl;
       return;
     }
   }
 }
 BENCHMARK(document_parse_exception);
 
+#endif // SIMDJSON_EXCEPTIONS
+
 BENCHMARK_MAIN();

benchmark/bench_stream_formats.cpp

@@ -0,0 +1,216 @@
+#include <benchmark/benchmark.h>
+#include <string>
+#include "simdjson.h"
+
+using namespace simdjson;
+
+namespace {
+
+enum class stream_case {
+  ndjson_small,
+  ndjson_large,
+  rfc7464_small,
+  rfc7464_large,
+  comma_delimited_small,
+  comma_delimited_large
+};
+
+constexpr size_t TARGET_BYTES = 128 * 1000 * 1000;
+constexpr size_t SMALL_PAYLOAD = 16;
+constexpr size_t LARGE_PAYLOAD = 4096;
+constexpr size_t BATCH_SIZE = 1 << 20;
+
+struct stream_dataset {
+  padded_string json;
+  size_t count{};
+};
+
+std::string make_document(size_t id, size_t payload_size) {
+  return std::string{"{\"id\":"} + std::to_string(id) +
+    ",\"name\":\"aaaaaaaa\",\"payload\":\"" +
+    std::string(payload_size, 'x') + "\",\"flag\":true}";
+}
+
+stream_dataset build_dataset(stream_case which) {
+  const bool small = which == stream_case::ndjson_small ||
+                     which == stream_case::rfc7464_small ||
+                     which == stream_case::comma_delimited_small;
+  const bool rfc = which == stream_case::rfc7464_small ||
+                   which == stream_case::rfc7464_large;
+  const bool comma = which == stream_case::comma_delimited_small ||
+                     which == stream_case::comma_delimited_large;
+  const size_t payload_size = small ? SMALL_PAYLOAD : LARGE_PAYLOAD;
+  const size_t count = TARGET_BYTES / (payload_size + 48);
+  std::string out;
+  out.reserve(count * (payload_size + 64));
+  for (size_t i = 0; i < count; i++) {
+    if (rfc) {
+      out += char(0x1E);
+    }
+    if (comma && i > 0) {
+      out += ',';
+    }
+    out += make_document(i, payload_size);
+    if (!comma) {
+      out += '\n';
+    }
+  }
+  return {padded_string(out), count};
+}
+
+const stream_dataset &get_dataset(stream_case which) {
+  static const stream_dataset ndjson_small =
+    build_dataset(stream_case::ndjson_small);
+  static const stream_dataset ndjson_large =
+    build_dataset(stream_case::ndjson_large);
+  static const stream_dataset rfc_small =
+    build_dataset(stream_case::rfc7464_small);
+  static const stream_dataset rfc_large =
+    build_dataset(stream_case::rfc7464_large);
+  static const stream_dataset comma_small =
+    build_dataset(stream_case::comma_delimited_small);
+  static const stream_dataset comma_large =
+    build_dataset(stream_case::comma_delimited_large);
+  switch (which) {
+    case stream_case::ndjson_small:
+      return ndjson_small;
+    case stream_case::ndjson_large:
+      return ndjson_large;
+    case stream_case::rfc7464_small:
+      return rfc_small;
+    case stream_case::rfc7464_large:
+      return rfc_large;
+    case stream_case::comma_delimited_small:
+      return comma_small;
+    case stream_case::comma_delimited_large:
+      return comma_large;
+  }
+  return ndjson_small;
+}
+
+void set_counters(benchmark::State &state, const stream_dataset &dataset) {
+  state.SetBytesProcessed(int64_t(state.iterations()) * int64_t(dataset.json.size()));
+  state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(dataset.count));
+}
+
+template <stream_case which, bool threaded = true>
+static void bench_ondemand(benchmark::State &state) {
+  const auto &dataset = get_dataset(which);
+  ondemand::parser parser;
+  parser.threaded = threaded;
+  stream_format format = stream_format::whitespace_delimited;
+  if constexpr (which == stream_case::rfc7464_small ||
+                which == stream_case::rfc7464_large) {
+    format = stream_format::json_sequence;
+  } else if constexpr (which == stream_case::comma_delimited_small ||
+                       which == stream_case::comma_delimited_large) {
+    format = stream_format::comma_delimited;
+  }
+  for (const auto _ : state) {
+    ondemand::document_stream docs;
+    auto error = parser.iterate_many(dataset.json, BATCH_SIZE, format).get(docs);
+    if (error) {
+      state.SkipWithError(error_message(error));
+      return;
+    }
+    uint64_t sum = 0;
+    for (auto doc : docs) {
+      ondemand::object obj;
+      if ((error = doc.get_object().get(obj))) {
+        state.SkipWithError(error_message(error));
+        return;
+      }
+      uint64_t id;
+      if ((error = obj["id"].get_uint64().get(id))) {
+        state.SkipWithError(error_message(error));
+        return;
+      }
+      sum += id;
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+  set_counters(state, dataset);
+}
+
+template <stream_case which>
+static void bench_dom(benchmark::State &state) {
+  const auto &dataset = get_dataset(which);
+  dom::parser parser;
+  parser.threaded = true;
+  stream_format format = stream_format::whitespace_delimited;
+  if constexpr (which == stream_case::rfc7464_small ||
+                which == stream_case::rfc7464_large) {
+    format = stream_format::json_sequence;
+  } else if constexpr (which == stream_case::comma_delimited_small ||
+                       which == stream_case::comma_delimited_large) {
+    format = stream_format::comma_delimited;
+  }
+  for (const auto _ : state) {
+    dom::document_stream docs;
+    auto error = parser.parse_many(dataset.json, BATCH_SIZE, format).get(docs);
+    if (error) {
+      state.SkipWithError(error_message(error));
+      return;
+    }
+    uint64_t sum = 0;
+    for (auto doc : docs) {
+      uint64_t id;
+      if ((error = doc["id"].get(id))) {
+        state.SkipWithError(error_message(error));
+        return;
+      }
+      sum += id;
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+  set_counters(state, dataset);
+}
+
+} // namespace
+
+BENCHMARK(bench_ondemand<stream_case::ndjson_small>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+BENCHMARK(bench_ondemand<stream_case::ndjson_large>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+BENCHMARK(bench_ondemand<stream_case::rfc7464_small>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+BENCHMARK(bench_ondemand<stream_case::rfc7464_large>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+BENCHMARK(bench_ondemand<stream_case::comma_delimited_small>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+BENCHMARK(bench_ondemand<stream_case::comma_delimited_large>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+// Non-threaded comma_delimited for comparison
+BENCHMARK(bench_ondemand<stream_case::comma_delimited_small, false>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+BENCHMARK(bench_ondemand<stream_case::comma_delimited_large, false>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+
+BENCHMARK(bench_dom<stream_case::ndjson_small>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+BENCHMARK(bench_dom<stream_case::ndjson_large>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+BENCHMARK(bench_dom<stream_case::rfc7464_small>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+BENCHMARK(bench_dom<stream_case::rfc7464_large>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+BENCHMARK(bench_dom<stream_case::comma_delimited_small>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+BENCHMARK(bench_dom<stream_case::comma_delimited_large>)
+    ->UseRealTime()
+    ->DisplayAggregatesOnly(true);
+
+BENCHMARK_MAIN();

benchmark/benchfeatures.cpp

@@ -4,8 +4,8 @@
 #include <cctype>
 #ifndef _MSC_VER
 #include <dirent.h>
-#include <unistd.h>
 #endif
+#include <unistd.h>
 #include <cinttypes>
 #include <initializer_list>
 
@@ -63,8 +63,8 @@ void print_usage(ostream& out) {
   out << "-s STAGE   - Stop after the given stage." << endl;
   out << "             -s stage1 - Stop after find_structural_bits." << endl;
   out << "             -s all    - Run all stages." << endl;
-  out << "-a ARCH    - Use the parser with the designated architecture (HASWELL, WESTMERE" << endl;
+  out << "-a ARCH    - Use the parser with the designated architecture (HASWELL, WESTMERE," << endl;
-  out << "             or ARM64). By default, detects best supported architecture." << endl;
+  out << "             PPC64 or ARM64). By default, detects best supported architecture." << endl;
 }
 
 void exit_usage(string message) {
@@ -75,7 +75,6 @@ void exit_usage(string message) {
 }
 
 struct option_struct {
-  architecture arch = architecture::UNSUPPORTED;
   bool stage1_only = false;
 
   int32_t iterations = 400;
@@ -84,48 +83,41 @@ struct option_struct {
   bool verbose = false;
 
   option_struct(int argc, char **argv) {
-    #ifndef _MSC_VER
+    int c;
-      int c;
 
-      while ((c = getopt(argc, argv, "vtn:i:a:s:")) != -1) {
+    while ((c = getopt(argc, argv, "vtn:i:a:s:")) != -1) {
-        switch (c) {
+      switch (c) {
-        case 'n':
+      case 'n':
-          iterations = atoi(optarg);
+        iterations = atoi(optarg);
-          break;
+        break;
-        case 'i':
+      case 'i':
-          iteration_step = atoi(optarg);
+        iteration_step = atoi(optarg);
-          break;
+        break;
-        case 'v':
+      case 'v':
-          verbose = true;
+        verbose = true;
-          break;
+        break;
-        case 'a':
+      case 'a': {
-          arch = parse_architecture(optarg);
+          auto impl = simdjson::get_available_implementations()[optarg];
-          if (arch == architecture::UNSUPPORTED) {
+          if(impl && impl->supported_by_runtime_system()) {
-            exit_usage(string("Unsupported option value -a ") + optarg + ": expected -a HASWELL, WESTMERE or ARM64");
+            simdjson::get_active_implementation() = impl;
-          }
-          break;
-        case 's':
-          if (!strcmp(optarg, "stage1")) {
-            stage1_only = true;
-          } else if (!strcmp(optarg, "all")) {
-            stage1_only = false;
           } else {
-            exit_usage(string("Unsupported option value -s ") + optarg + ": expected -s stage1 or all");
+            std::cerr << "implementation " << optarg << " not found or not supported " << std::endl;
           }
-          break;
-        default:
-          exit_error("Unexpected argument " + c);
         }
+        break;
+      case 's':
+        if (!strcmp(optarg, "stage1")) {
+          stage1_only = true;
+        } else if (!strcmp(optarg, "all")) {
+          stage1_only = false;
+        } else {
+          exit_usage(string("Unsupported option value -s ") + optarg + ": expected -s stage1 or all");
+        }
+        break;
+      default:
+        exit_error(string("Unexpected argument ") + std::string(1,static_cast<char>(c)));
       }
-    #else
-      int optind = 1;
-    #endif
-
-    // If architecture is not specified, pick the best supported architecture by default
-    if (arch == architecture::UNSUPPORTED) {
-      arch = find_best_supported_architecture();
     }
-    dom::parser::use_implementation(arch);
   }
 
   template<typename F>
@@ -154,25 +146,25 @@ struct feature_benchmarker {
   benchmarker struct23;
   benchmarker struct23_miss;
 
-  feature_benchmarker(const simdjson::implementation &parser, event_collector& collector) :
+  feature_benchmarker(event_collector& collector) :
-    utf8               ("jsonexamples/generated/utf-8.json", parser, collector),
+    utf8               (SIMDJSON_BENCHMARK_DATA_DIR "generated/utf-8.json", collector),
-    utf8_miss          ("jsonexamples/generated/utf-8-miss.json", parser, collector),
+    utf8_miss          (SIMDJSON_BENCHMARK_DATA_DIR "generated/utf-8-miss.json", collector),
-    escape               ("jsonexamples/generated/escape.json", parser, collector),
+    escape               (SIMDJSON_BENCHMARK_DATA_DIR "generated/escape.json", collector),
-    escape_miss          ("jsonexamples/generated/escape-miss.json", parser, collector),
+    escape_miss          (SIMDJSON_BENCHMARK_DATA_DIR "generated/escape-miss.json", collector),
-    empty              ("jsonexamples/generated/0-structurals.json", parser, collector),
+    empty              (SIMDJSON_BENCHMARK_DATA_DIR "generated/0-structurals.json", collector),
-    empty_miss         ("jsonexamples/generated/0-structurals-miss.json", parser, collector),
+    empty_miss         (SIMDJSON_BENCHMARK_DATA_DIR "generated/0-structurals-miss.json", collector),
-    struct7           ("jsonexamples/generated/7-structurals.json", parser, collector),
+    struct7           (SIMDJSON_BENCHMARK_DATA_DIR "generated/7-structurals.json", collector),
-    struct7_miss      ("jsonexamples/generated/7-structurals-miss.json", parser, collector),
+    struct7_miss      (SIMDJSON_BENCHMARK_DATA_DIR "generated/7-structurals-miss.json", collector),
-    struct7_full       ("jsonexamples/generated/7-structurals-full.json", parser, collector),
+    struct7_full       (SIMDJSON_BENCHMARK_DATA_DIR "generated/7-structurals-full.json", collector),
-    struct15     ("jsonexamples/generated/15-structurals.json", parser, collector),
+    struct15     (SIMDJSON_BENCHMARK_DATA_DIR "generated/15-structurals.json", collector),
-    struct15_miss("jsonexamples/generated/15-structurals-miss.json", parser, collector),
+    struct15_miss(SIMDJSON_BENCHMARK_DATA_DIR "generated/15-structurals-miss.json", collector),
-    struct23     ("jsonexamples/generated/23-structurals.json", parser, collector),
+    struct23     (SIMDJSON_BENCHMARK_DATA_DIR "generated/23-structurals.json", collector),
-    struct23_miss("jsonexamples/generated/23-structurals-miss.json", parser, collector)
+    struct23_miss(SIMDJSON_BENCHMARK_DATA_DIR "generated/23-structurals-miss.json", collector)
   {
 
   }
 
-  really_inline void run_iterations(size_t iterations, bool stage1_only=false) {
+  simdjson_inline void run_iterations(size_t iterations, bool stage1_only=false) {
     struct7.run_iterations(iterations, stage1_only);
     struct7_miss.run_iterations(iterations, stage1_only);
     struct7_full.run_iterations(iterations, stage1_only);
@@ -189,7 +181,7 @@ struct feature_benchmarker {
   }
 
   double cost_per_block(BenchmarkStage stage, const benchmarker& feature, size_t feature_blocks, const benchmarker& base) const {
-    return (feature[stage].best.elapsed_ns() - base[stage].best.elapsed_ns()) / feature_blocks;
+    return (feature[stage].best.elapsed_ns() - base[stage].best.elapsed_ns()) / double(feature_blocks);
   }
 
   // Whether we're recording cache miss and branch miss events
@@ -199,7 +191,7 @@ struct feature_benchmarker {
 
   // Base cost of any block (including empty ones)
   double base_cost(BenchmarkStage stage) const {
-    return (empty[stage].best.elapsed_ns() / empty.stats->blocks);
+    return (empty[stage].best.elapsed_ns() / double(empty.stats->blocks));
   }
 
   // Extra cost of a 1-7 structural block over an empty block
@@ -212,10 +204,13 @@ struct feature_benchmarker {
   }
   // Rate of 1-7-structural misses per 8-structural flip
   double struct1_7_miss_rate(BenchmarkStage stage) const {
+#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+    return 1;
+#else
     if (!has_events()) { return 1; }
-    return double(struct7_miss[stage].best.branch_misses() - struct7[stage].best.branch_misses()) / struct7_miss.stats->blocks_with_1_structural_flipped;
+    return struct7_miss[stage].best.branch_misses() - struct7[stage].best.branch_misses() / double(struct7_miss.stats->blocks_with_1_structural_flipped);
+#endif
   }
-
   // Extra cost of an 8-15 structural block over a 1-7 structural block
   double struct8_15_cost(BenchmarkStage stage) const {
     return cost_per_block(stage, struct15, struct15.stats->blocks_with_8_structurals, struct7);
@@ -226,8 +221,12 @@ struct feature_benchmarker {
   }
   // Rate of 8-15-structural misses per 8-structural flip
   double struct8_15_miss_rate(BenchmarkStage stage) const {
+#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+    return 1;
+#else
     if (!has_events()) { return 1; }
-    return double(struct15_miss[stage].best.branch_misses() - struct15[stage].best.branch_misses()) / struct15_miss.stats->blocks_with_8_structurals_flipped;
+    return double(struct15_miss[stage].best.branch_misses() - struct15[stage].best.branch_misses()) / double(struct15_miss.stats->blocks_with_8_structurals_flipped);
+#endif
   }
 
   // Extra cost of a 16+-structural block over an 8-15 structural block (actual varies based on # of structurals!)
@@ -240,10 +239,15 @@ struct feature_benchmarker {
   }
   // Rate of 16-structural misses per 16-structural flip
   double struct16_miss_rate(BenchmarkStage stage) const {
+#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+    return 1;
+#else
     if (!has_events()) { return 1; }
-    return double(struct23_miss[stage].best.branch_misses() - struct23[stage].best.branch_misses()) / struct23_miss.stats->blocks_with_16_structurals_flipped;
+    return double(struct23_miss[stage].best.branch_misses() - struct23[stage].best.branch_misses()) / double(struct23_miss.stats->blocks_with_16_structurals_flipped);
+#endif
   }
 
+
   // Extra cost of having UTF-8 in a block
   double utf8_cost(BenchmarkStage stage) const {
     return cost_per_block(stage, utf8, utf8.stats->blocks_with_utf8, struct7_full);
@@ -254,10 +258,13 @@ struct feature_benchmarker {
   }
   // Rate of UTF-8 misses per UTF-8 flip
   double utf8_miss_rate(BenchmarkStage stage) const {
+#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+    return 1;
+#else
     if (!has_events()) { return 1; }
-    return double(utf8_miss[stage].best.branch_misses() - utf8[stage].best.branch_misses()) / utf8_miss.stats->blocks_with_utf8_flipped;
+    return double(utf8_miss[stage].best.branch_misses() - utf8[stage].best.branch_misses()) / double(utf8_miss.stats->blocks_with_utf8_flipped);
+#endif
   }
-
   // Extra cost of having escapes in a block
   double escape_cost(BenchmarkStage stage) const {
     return cost_per_block(stage, escape, escape.stats->blocks_with_escapes, struct7_full);
@@ -268,47 +275,51 @@ struct feature_benchmarker {
   }
   // Rate of escape misses per escape flip
   double escape_miss_rate(BenchmarkStage stage) const {
+#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+    return 1;
+#else
     if (!has_events()) { return 1; }
-    return double(escape_miss[stage].best.branch_misses() - escape[stage].best.branch_misses()) / escape_miss.stats->blocks_with_escapes_flipped;
+    return double(escape_miss[stage].best.branch_misses() - escape[stage].best.branch_misses()) / double(escape_miss.stats->blocks_with_escapes_flipped);
+#endif
   }
 
+
   double calc_expected_feature_cost(BenchmarkStage stage, const benchmarker& file) const {
     // Expected base ns/block (empty)
     json_stats& stats = *file.stats;
-    double expected = base_cost(stage)       * stats.blocks;
+    double expected = base_cost(stage)       * double(stats.blocks);
-    expected +=       struct1_7_cost(stage)  * stats.blocks_with_1_structural;
+    expected +=       struct1_7_cost(stage)  * double(stats.blocks_with_1_structural);
-    expected +=       utf8_cost(stage)       * stats.blocks_with_utf8;
+    expected +=       utf8_cost(stage)       * double(stats.blocks_with_utf8);
-    expected +=       escape_cost(stage)     * stats.blocks_with_escapes;
+    expected +=       escape_cost(stage)     * double(stats.blocks_with_escapes);
-    expected +=       struct8_15_cost(stage) * stats.blocks_with_8_structurals;
+    expected +=       struct8_15_cost(stage) * double(stats.blocks_with_8_structurals);
-    expected +=       struct16_cost(stage)   * stats.blocks_with_16_structurals;
+    expected +=       struct16_cost(stage)   * double(stats.blocks_with_16_structurals);
-    return expected / stats.blocks;
+    return expected / double(stats.blocks);
   }
 
   double calc_expected_miss_cost(BenchmarkStage stage, const benchmarker& file) const {
     // Expected base ns/block (empty)
     json_stats& stats = *file.stats;
-    double expected = struct1_7_miss_cost(stage)  * stats.blocks_with_1_structural_flipped * struct1_7_miss_rate(stage);
+    double expected = struct1_7_miss_cost(stage)  * double(stats.blocks_with_1_structural_flipped) * struct1_7_miss_rate(stage);
-    expected +=       utf8_miss_cost(stage)       * stats.blocks_with_utf8_flipped * utf8_miss_rate(stage);
+    expected +=       utf8_miss_cost(stage)       * double(stats.blocks_with_utf8_flipped) * utf8_miss_rate(stage);
-    expected +=       escape_miss_cost(stage)     * stats.blocks_with_escapes_flipped * escape_miss_rate(stage);
+    expected +=       escape_miss_cost(stage)     * double(stats.blocks_with_escapes_flipped) * escape_miss_rate(stage);
-    expected +=       struct8_15_miss_cost(stage) * stats.blocks_with_8_structurals_flipped * struct8_15_miss_rate(stage);
+    expected +=       struct8_15_miss_cost(stage) * double(stats.blocks_with_8_structurals_flipped) * struct8_15_miss_rate(stage);
-    expected +=       struct16_miss_cost(stage)   * stats.blocks_with_16_structurals_flipped * struct16_miss_rate(stage);
+    expected +=       struct16_miss_cost(stage)   * double(stats.blocks_with_16_structurals_flipped) * struct16_miss_rate(stage);
-    return expected / stats.blocks;
+    return expected / double(stats.blocks);
   }
 
   double calc_expected_misses(BenchmarkStage stage, const benchmarker& file) const {
     json_stats& stats = *file.stats;
-    double expected = stats.blocks_with_1_structural_flipped   * struct1_7_miss_rate(stage);
+    double expected = double(stats.blocks_with_1_structural_flipped)   * struct1_7_miss_rate(stage);
-    expected +=       stats.blocks_with_utf8_flipped           * utf8_miss_rate(stage);
+    expected +=       double(stats.blocks_with_utf8_flipped)           * utf8_miss_rate(stage);
-    expected +=       stats.blocks_with_escapes_flipped        * escape_miss_rate(stage);
+    expected +=       double(stats.blocks_with_escapes_flipped)        * escape_miss_rate(stage);
-    expected +=       stats.blocks_with_8_structurals_flipped  * struct8_15_miss_rate(stage);
+    expected +=       double(stats.blocks_with_8_structurals_flipped)  * struct8_15_miss_rate(stage);
-    expected +=       stats.blocks_with_16_structurals_flipped * struct16_miss_rate(stage);
+    expected +=       double(stats.blocks_with_16_structurals_flipped) * struct16_miss_rate(stage);
     return expected;
   }
 
   double calc_expected(BenchmarkStage stage, const benchmarker& file) const {
     return calc_expected_feature_cost(stage, file) + calc_expected_miss_cost(stage, file);
   }
-
   void print(const option_struct& options) const {
     printf("\n");
     printf("Features in ns/block (64 bytes):\n");
@@ -367,11 +378,11 @@ struct feature_benchmarker {
   }
 };
 
+#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
 void print_file_effectiveness(BenchmarkStage stage, const char* filename, const benchmarker& results, const feature_benchmarker& features) {
-  double actual = results[stage].best.elapsed_ns() / results.stats->blocks;
+  double actual = results[stage].best.elapsed_ns() / double(results.stats->blocks);
   double calc = features.calc_expected(stage, results);
-  uint64_t actual_misses = results[stage].best.branch_misses();
+  double calc_misses = features.calc_expected_misses(stage, results);
-  uint64_t calc_misses = uint64_t(features.calc_expected_misses(stage, results));
   double calc_miss_cost = features.calc_expected_miss_cost(stage, results);
   printf("        | %-8s ", benchmark_stage_name(stage));
   printf("| %-15s ",   filename);
@@ -380,16 +391,33 @@ void print_file_effectiveness(BenchmarkStage stage, const char* filename, const
   printf("| %8.3g ",  calc);
   printf("| %8.3g ",  actual);
   printf("| %+8.3g ", actual - calc);
-  printf("| %13lu ",  calc_misses);
+  printf("| %13llu ", (long long unsigned)(calc_misses));
+}
+#else
+void print_file_effectiveness(BenchmarkStage stage, const char* filename, const benchmarker& results, const feature_benchmarker& features) {
+  double actual = results[stage].best.elapsed_ns() / double(results.stats->blocks);
+  double calc = features.calc_expected(stage, results);
+  double actual_misses = results[stage].best.branch_misses();
+  double calc_misses = features.calc_expected_misses(stage, results);
+  double calc_miss_cost = features.calc_expected_miss_cost(stage, results);
+  printf("        | %-8s ", benchmark_stage_name(stage));
+  printf("| %-15s ",   filename);
+  printf("|    %8.3g ", features.calc_expected_feature_cost(stage, results));
+  printf("|    %8.3g ", calc_miss_cost);
+  printf("| %8.3g ",  calc);
+  printf("| %8.3g ",  actual);
+  printf("| %+8.3g ", actual - calc);
+  printf("| %13llu ", (long long unsigned)(calc_misses));
   if (features.has_events()) {
-    printf("| %13lu ",  actual_misses);
+    printf("| %13llu ", (long long unsigned)(actual_misses));
-    printf("| %+13ld ", int64_t(actual_misses - calc_misses));
+    printf("| %+13lld ", (long long int)(actual_misses - calc_misses));
     double miss_adjustment = calc_miss_cost * (double(int64_t(actual_misses - calc_misses)) / calc_misses);
     printf("|      %8.3g ", calc_miss_cost + miss_adjustment);
     printf("|      %+8.3g ", actual - (calc + miss_adjustment));
   }
   printf("|\n");
 }
+#endif
 
 int main(int argc, char *argv[]) {
   // Read options
@@ -405,9 +433,9 @@ int main(int argc, char *argv[]) {
 
   // Set up benchmarkers by reading all files
   feature_benchmarker features(collector);
-  benchmarker gsoc_2018("jsonexamples/gsoc-2018.json", collector);
+  benchmarker gsoc_2018(SIMDJSON_BENCHMARK_DATA_DIR "gsoc-2018.json", collector);
-  benchmarker twitter("jsonexamples/twitter.json", collector);
+  benchmarker twitter(SIMDJSON_BENCHMARK_DATA_DIR "twitter.json", collector);
-  benchmarker random("jsonexamples/random.json", collector);
+  benchmarker random(SIMDJSON_BENCHMARK_DATA_DIR "random.json", collector);
 
   // Run the benchmarks
   progress_bar progress(options.iterations, 100);

benchmark/benchmark.h

@@ -1,82 +1,7 @@
 #ifndef _BENCHMARK_H_
 #define _BENCHMARK_H_
-#include <float.h>
-#include <stdint.h>
-#include <time.h>
-#ifdef __x86_64__
 
-const char *unitname = "cycles";
+#include "event_counter.h"
-
-#define RDTSC_START(cycles)                                                    \
-  do {                                                                         \
-    uint32_t cyc_high, cyc_low;                                                \
-    __asm volatile("cpuid\n"                                                   \
-                   "rdtsc\n"                                                   \
-                   "mov %%edx, %0\n"                                           \
-                   "mov %%eax, %1"                                             \
-                   : "=r"(cyc_high), "=r"(cyc_low)                             \
-                   :                                                           \
-                   :                              /* no read only */           \
-                   "%rax", "%rbx", "%rcx", "%rdx" /* clobbers */               \
-    );                                                                         \
-    (cycles) = ((uint64_t)cyc_high << 32) | cyc_low;                           \
-  } while (0)
-
-#define RDTSC_STOP(cycles)                                                     \
-  do {                                                                         \
-    uint32_t cyc_high, cyc_low;                                                \
-    __asm volatile("rdtscp\n"                                                  \
-                   "mov %%edx, %0\n"                                           \
-                   "mov %%eax, %1\n"                                           \
-                   "cpuid"                                                     \
-                   : "=r"(cyc_high), "=r"(cyc_low)                             \
-                   : /* no read only registers */                              \
-                   : "%rax", "%rbx", "%rcx", "%rdx" /* clobbers */             \
-    );                                                                         \
-    (cycles) = ((uint64_t)cyc_high << 32) | cyc_low;                           \
-  } while (0)
-
-#else
-const char *unitname = " (clock units) ";
-
-#define RDTSC_START(cycles)                                                    \
-  do {                                                                         \
-    cycles = clock();                                                          \
-  } while (0)
-
-#define RDTSC_STOP(cycles)                                                     \
-  do {                                                                         \
-    cycles = clock();                                                          \
-  } while (0)
-#endif
-
-static __attribute__((noinline)) uint64_t rdtsc_overhead_func(uint64_t dummy) {
-  return dummy;
-}
-
-uint64_t global_rdtsc_overhead = (uint64_t)UINT64_MAX;
-
-#define RDTSC_SET_OVERHEAD(test, repeat)                                       \
-  do {                                                                         \
-    uint64_t cycles_start, cycles_final, cycles_diff;                          \
-    uint64_t min_diff = UINT64_MAX;                                            \
-    for (int i = 0; i < repeat; i++) {                                         \
-      __asm volatile("" ::: /* pretend to clobber */ "memory");                \
-      RDTSC_START(cycles_start);                                               \
-      test;                                                                    \
-      RDTSC_STOP(cycles_final);                                                \
-      cycles_diff = (cycles_final - cycles_start);                             \
-      if (cycles_diff < min_diff)                                              \
-        min_diff = cycles_diff;                                                \
-    }                                                                          \
-    global_rdtsc_overhead = min_diff;                                          \
-  } while (0)
-
-double diff(timespec start, timespec end) {
-  return ((end.tv_nsec + 1000000000 * end.tv_sec) -
-          (start.tv_nsec + 1000000000 * start.tv_sec)) /
-         1000000000.0;
-}
 
 /*
  * Prints the best number of operations per cycle where
@@ -86,142 +11,99 @@ double diff(timespec start, timespec end) {
  */
 #define BEST_TIME(name, test, expected, pre, repeat, size, verbose)            \
   do {                                                                         \
-    if (global_rdtsc_overhead == UINT64_MAX) {                                 \
-      RDTSC_SET_OVERHEAD(rdtsc_overhead_func(1), repeat);                      \
-    }                                                                          \
     if (verbose)                                                               \
-      printf("%-40s\t: ", name);                                               \
+      std::printf("%-40s\t: ", name);                                          \
     else                                                                       \
-      printf("\"%-40s\"", name);                                               \
+      std::printf("\"%-40s\"", name);                                          \
     fflush(NULL);                                                              \
-    uint64_t cycles_start, cycles_final, cycles_diff;                          \
+    event_collector collector;                                                 \
-    uint64_t min_diff = (uint64_t)-1;                                          \
+    event_aggregate aggregate{};                                               \
-    double min_sumclockdiff = DBL_MAX;                                         \
+    for (decltype(repeat) i = 0; i < repeat; i++) {                            \
-    uint64_t sum_diff = 0;                                                     \
-    double sumclockdiff = 0;                                                   \
-    struct timespec time1, time2;                                              \
-    for (int i = 0; i < repeat; i++) {                                         \
       pre;                                                                     \
-      __asm volatile("" ::: /* pretend to clobber */ "memory");                \
+      std::atomic_thread_fence(std::memory_order_acquire);                     \
-      clock_gettime(CLOCK_REALTIME, &time1);                                   \
+      collector.start();                                                       \
-      RDTSC_START(cycles_start);                                               \
       if (test != expected) {                                                  \
-        fprintf(stderr, "not expected (%d , %d )", (int)test, (int)expected);  \
+        std::fprintf(stderr, "not expected (%d , %d )", (int)test,             \
+                     (int)expected);                                           \
         break;                                                                 \
       }                                                                        \
-      RDTSC_STOP(cycles_final);                                                \
+      std::atomic_thread_fence(std::memory_order_release);                     \
-      clock_gettime(CLOCK_REALTIME, &time2);                                   \
+      event_count allocate_count = collector.end();                            \
-      double thistiming = diff(time1, time2);                                  \
+      aggregate << allocate_count;                                             \
-      sumclockdiff += thistiming;                                              \
-      if (thistiming < min_sumclockdiff)                                       \
-        min_sumclockdiff = thistiming;                                         \
-      cycles_diff = (cycles_final - cycles_start - global_rdtsc_overhead);     \
-      if (cycles_diff < min_diff)                                              \
-        min_diff = cycles_diff;                                                \
-      sum_diff += cycles_diff;                                                 \
     }                                                                          \
-    uint64_t S = size;                                                         \
+    if (collector.has_events()) {                                              \
-    float cycle_per_op = (min_diff) / (double)S;                               \
+      std::printf("%7.3f",                                                     \
-    float avg_cycle_per_op = (sum_diff) / ((double)S * repeat);                \
+                  aggregate.best.cycles() / static_cast<double>(size));        \
-    double avg_gb_per_s =                                                      \
+      if (verbose) {                                                           \
-        ((double)S * repeat) / ((sumclockdiff)*1000.0 * 1000.0 * 1000.0);      \
+        std::printf(" cycles/byte ");                                          \
-    double max_gb_per_s =                                                      \
+      }                                                                        \
-        ((double)S) / ((min_sumclockdiff)*1000.0 * 1000.0 * 1000.0);           \
+      std::printf("\t");                                                       \
-    if (verbose)                                                               \
+      std::printf("%7.3f",                                                     \
-      printf(" %7.3f %s per input byte (best) ", cycle_per_op, unitname);      \
+                  aggregate.best.instructions() / static_cast<double>(size));  \
-    if (verbose)                                                               \
+      if (verbose) {                                                           \
-      printf(" %7.3f %s (avg) ", avg_cycle_per_op, unitname);                  \
+        std::printf(" instructions/byte ");                                    \
-    if (verbose)                                                               \
+      }                                                                        \
-      printf(" %7.3f GB/s (error margin: %5.3f GB/s)", max_gb_per_s,            \
+      std::printf("\t");                                                       \
-             -avg_gb_per_s + max_gb_per_s);                                    \
+    }                                                                          \
-    if (verbose)                                                               \
+    double gb = static_cast<double>(size) / 1000000000.0;                      \
-      printf(" %13.0f documents/s (best)", 1.0/min_sumclockdiff);             \
+    std::printf("%7.3f", gb / aggregate.best.elapsed_sec());                   \
-    if (verbose)                                                               \
+    if (verbose) {                                                             \
-      printf(" %13.0f documents/s (avg)", 1.0/(sumclockdiff/repeat));         \
+      std::printf(" GB/s ");                                                   \
-    if (!verbose)                                                              \
+    }                                                                          \
-      printf(" %20.3f %20.3f %20.3f %20.3f", cycle_per_op,                     \
+    std::printf("\t"); \
-             avg_cycle_per_op - cycle_per_op, max_gb_per_s,                    \
+    std::printf("%7.3f", 1.0 / aggregate.best.elapsed_sec());                  \
-             -avg_gb_per_s + max_gb_per_s);                                    \
+    if (verbose) {                                                             \
-    printf("\n");                                                              \
+      std::printf(" documents/s ");                                            \
-    fflush(NULL);                                                              \
+    }                                                                          \
+    std::printf("\n");                                                         \
+    std::fflush(NULL);                                                         \
   } while (0)
 
 // like BEST_TIME, but no check
 #define BEST_TIME_NOCHECK(name, test, pre, repeat, size, verbose)              \
   do {                                                                         \
-    if (global_rdtsc_overhead == UINT64_MAX) {                                 \
-      RDTSC_SET_OVERHEAD(rdtsc_overhead_func(1), repeat);                      \
-    }                                                                          \
     if (verbose)                                                               \
-      printf("%-40s\t: ", name);                                               \
+      std::printf("%-40s\t: ", name);                                          \
-    fflush(NULL);                                                              \
+    else                                                                       \
-    uint64_t cycles_start, cycles_final, cycles_diff;                          \
+      std::printf("\"%-40s\"", name);                                          \
-    uint64_t min_diff = (uint64_t)-1;                                          \
+    std::fflush(NULL);                                                         \
-    uint64_t sum_diff = 0;                                                     \
+    event_collector collector;                                                 \
-    for (int i = 0; i < repeat; i++) {                                         \
+    event_aggregate aggregate{};                                               \
+    for (decltype(repeat) i = 0; i < repeat; i++) {                            \
       pre;                                                                     \
-      __asm volatile("" ::: /* pretend to clobber */ "memory");                \
+      std::atomic_thread_fence(std::memory_order_acquire);                     \
-      RDTSC_START(cycles_start);                                               \
+      collector.start();                                                       \
       test;                                                                    \
-      RDTSC_STOP(cycles_final);                                                \
+      std::atomic_thread_fence(std::memory_order_release);                     \
-      cycles_diff = (cycles_final - cycles_start - global_rdtsc_overhead);     \
+      event_count allocate_count = collector.end();                            \
-      if (cycles_diff < min_diff)                                              \
+      aggregate << allocate_count;                                             \
-        min_diff = cycles_diff;                                                \
-      sum_diff += cycles_diff;                                                 \
     }                                                                          \
-    uint64_t S = size;                                                         \
+    if (collector.has_events()) {                                              \
-    float cycle_per_op = (min_diff) / (double)S;                               \
+      std::printf("%7.3f",                                                     \
-    float avg_cycle_per_op = (sum_diff) / ((double)S * repeat);                \
+                  aggregate.best.cycles() / static_cast<double>(size));        \
-    if (verbose)                                                               \
+      if (verbose) {                                                           \
-      printf(" %.3f %s per input byte (best) ", cycle_per_op, unitname);       \
+        std::printf(" cycles/byte ");                                          \
-    if (verbose)                                                               \
-      printf(" %.3f %s per input byte (avg) ", avg_cycle_per_op, unitname);    \
-    if (verbose)                                                               \
-      printf("\n");                                                            \
-    if (!verbose)                                                              \
-      printf(" %.3f ", cycle_per_op);                                          \
-    fflush(NULL);                                                              \
-  } while (0)
-
-// like BEST_TIME except that we run a function to check the result
-#define BEST_TIME_CHECK(test, check, pre, repeat, size, verbose)               \
-  do {                                                                         \
-    if (global_rdtsc_overhead == UINT64_MAX) {                                 \
-      RDTSC_SET_OVERHEAD(rdtsc_overhead_func(1), repeat);                      \
-    }                                                                          \
-    if (verbose)                                                               \
-      printf("%-60s\t:\n", #test);                                             \
-    fflush(NULL);                                                              \
-    uint64_t cycles_start, cycles_final, cycles_diff;                          \
-    uint64_t min_diff = (uint64_t)-1;                                          \
-    uint64_t sum_diff = 0;                                                     \
-    for (int i = 0; i < repeat; i++) {                                         \
-      pre;                                                                     \
-      __asm volatile("" ::: /* pretend to clobber */ "memory");                \
-      RDTSC_START(cycles_start);                                               \
-      test;                                                                    \
-      RDTSC_STOP(cycles_final);                                                \
-      if (!check) {                                                            \
-        printf("error");                                                       \
-        break;                                                                 \
       }                                                                        \
-      cycles_diff = (cycles_final - cycles_start - global_rdtsc_overhead);     \
+      std::printf("\t");                                                       \
-      if (cycles_diff < min_diff)                                              \
+      std::printf("%7.3f",                                                     \
-        min_diff = cycles_diff;                                                \
+                  aggregate.best.instructions() / static_cast<double>(size));  \
-      sum_diff += cycles_diff;                                                 \
+      if (verbose) {                                                           \
+        std::printf(" instructions/byte ");                                    \
+      }                                                                        \
+      std::printf("\t");                                                       \
     }                                                                          \
-    uint64_t S = size;                                                         \
+    double gb = static_cast<double>(size) / 1000000000.0;                      \
-    float cycle_per_op = (min_diff) / (double)S;                               \
+    std::printf("%7.3f", gb / aggregate.best.elapsed_sec());                   \
-    float avg_cycle_per_op = (sum_diff) / ((double)S * repeat);                \
+    if (verbose) {                                                             \
-    if (verbose)                                                               \
+      std::printf(" GB/s ");                                                   \
-      printf(" %.3f cycles per operation (best) ", cycle_per_op);              \
+    }                                                                          \
-    if (verbose)                                                               \
+    std::printf("\t");                                                       \
-      printf("\t%.3f cycles per operation (avg) ", avg_cycle_per_op);          \
+    std::printf("%7.3f", 1.0 / aggregate.best.elapsed_sec());                  \
-    if (verbose)                                                               \
+    if (verbose) {                                                             \
-      printf("\n");                                                            \
+      std::printf(" documents/s ");                                            \
-    if (!verbose)                                                              \
+    }                                                                          \
-      printf(" %.3f ", cycle_per_op);                                          \
+    std::printf("\n");                                                         \
-    fflush(NULL);                                                              \
+    std::fflush(NULL);                                                         \
   } while (0)
 
 #endif

benchmark/benchmark_reflection_usage_compilation.sh

@@ -0,0 +1,618 @@
+#!/bin/bash
+
+# JSON Parsing Compilation Benchmark: Reflection Usage vs Manual Parsing
+# Compares compilation times when ACTUALLY USING reflection for parsing vs manual parsing
+# This measures the compile-time cost of reflection-based automatic deserialization
+
+set -e
+
+echo "=== simdjson Reflection Usage Compilation Benchmark ==="
+echo "Measuring compilation impact of ACTUALLY USING reflection for parsing"
+echo "Starting at: $(date)"
+echo
+echo "╔════════════════════════════════════════════════════════════════════════════╗"
+echo "║                              METHODOLOGY                                   ║"
+echo "╠════════════════════════════════════════════════════════════════════════════╣"
+echo "║                                                                            ║"
+echo "║ FAIR COMPARISON STRATEGY:                                                  ║"
+echo "║ This benchmark compares two DIFFERENT approaches to parsing the same JSON: ║"
+echo "║                                                                            ║"
+echo "║ • MANUAL PARSING: Traditional simdjson with explicit .get() calls          ║"
+echo "║   - Uses doc[\"field\"].get(variable) for each field                         ║"
+echo "║   - No reflection involved                                                 ║"
+echo "║                                                                            ║"
+echo "║ • REFLECTION PARSING: Automatic deserialization with reflection            ║"
+echo "║   - Uses doc.get<MyStruct>() for automatic field mapping                   ║"
+echo "║   - Relies on compile-time reflection to generate parsing code             ║"
+echo "║                                                                            ║"
+echo "║ WHAT WE'RE MEASURING:                                                      ║"
+echo "║ • Compile-time cost of reflection-based automatic deserialization          ║"
+echo "║ • Template instantiation overhead for reflection parsing                   ║"
+echo "║ • Code generation complexity from using reflection features                ║"
+echo "║                                                                            ║"
+echo "║ TEST SCENARIOS:                                                            ║"
+echo "║                                                                            ║"
+echo "║ 1. SIMPLE STRUCT: Basic fields (string, int, bool)                         ║"
+echo "║    - Measures baseline reflection overhead                                 ║"
+echo "║                                                                            ║"
+echo "║ 2. NESTED STRUCT: Multiple levels of nested objects                        ║"
+echo "║    - Measures reflection complexity scaling                                ║"
+echo "║                                                                            ║"
+echo "║ 3. COMPLEX STRUCT: Arrays, optional fields, mixed types                    ║"
+echo "║    - Measures real-world reflection usage impact                           ║"
+echo "║                                                                            ║"
+echo "║ WHY THIS IS MEANINGFUL:                                                    ║"
+echo "║ • Shows actual cost of using reflection features                           ║"
+echo "║ • Measures compile-time code generation overhead                           ║"
+echo "║ • Helps developers understand reflection's compilation impact              ║"
+echo "║ • Compares equivalent functionality implemented two different ways         ║"
+echo "║                                                                            ║"
+echo "╚════════════════════════════════════════════════════════════════════════════╝"
+echo
+
+# Configuration
+ITERATIONS=10
+JOBS=4
+
+# ───────────────────────────── BOX-PRINT HELPER ────────────────────────────
+BOX_WIDTH=74                               # characters between the pipes
+print_box_line() {                         # usage: print_box_line "text"
+  printf "║ %-*s ║\n" "${BOX_WIDTH}" "$1"
+}
+
+# Function to test if a compiler supports reflection with debug output
+test_reflection_support() {
+    local compiler="$1"
+    echo "  → Testing compiler: $compiler"
+
+    if [ ! -x "$compiler" ] && ! command -v "$compiler" >/dev/null 2>&1; then
+        echo "  → Compiler not found or not executable"
+        return 1
+    fi
+
+    # Check compiler version first
+    echo "  → Compiler version: $("$compiler" --version 2>/dev/null | head -n1 || echo "version check failed")"
+
+    # Simple test: check if compiler accepts reflection flags
+    local test_file=$(mktemp /tmp/reflection_test_XXXXXX.cpp)
+    cat > "$test_file" << 'EOF'
+int main() {
+    return 0;
+}
+EOF
+
+    echo "  → Testing basic reflection flags..."
+    local test_exe=$(mktemp /tmp/reflection_test_XXXXXX)
+    local basic_result=$("$compiler" -freflection -fexpansion-statements -std=c++26 "$test_file" -o "$test_exe" 2>&1)
+    local basic_exit_code=$?
+
+    if [ $basic_exit_code -ne 0 ]; then
+        echo "  → Basic flags FAILED with exit code $basic_exit_code"
+        echo "  → Error output: $basic_result"
+        rm -f "$test_file" "$test_exe"
+        return 1
+    fi
+    echo "  → Basic flags: OK"
+    rm -f "$test_exe"
+
+    # Test reflection syntax
+    echo "  → Testing reflection syntax..."
+    cat > "$test_file" << 'EOF'
+struct Test {
+    int x;
+};
+
+int main() {
+    auto refl = ^^Test;
+    return 0;
+}
+EOF
+
+    local syntax_result=$("$compiler" -freflection -fexpansion-statements -std=c++26 "$test_file" -o "$test_exe" 2>&1)
+    local syntax_exit_code=$?
+
+    if [ $syntax_exit_code -eq 0 ]; then
+        echo "  → Reflection syntax: OK"
+        echo "  → ✓ REFLECTION SUPPORT CONFIRMED"
+        rm -f "$test_file" "$test_exe"
+        return 0
+    else
+        echo "  → Reflection syntax FAILED with exit code $syntax_exit_code"
+        echo "  → Error output: $syntax_result"
+        rm -f "$test_file" "$test_exe"
+        return 1
+    fi
+}
+
+# Find a compiler with reflection support
+echo "Searching for clang++ with reflection support..."
+
+REFLECTION_CXX=""
+REFLECTION_CC=""
+
+# List of potential clang++ locations to check
+POTENTIAL_COMPILERS=(
+    "/usr/local/bin/clang++"
+    "/opt/clang/bin/clang++"
+    "/usr/bin/clang++"
+    "clang++"
+)
+
+# If CXX is already set, test it first
+if [ -n "$CXX" ]; then
+    echo "Testing user-specified compiler: $CXX"
+    if test_reflection_support "$CXX"; then
+        REFLECTION_CXX="$CXX"
+        echo "✓ User-specified compiler supports reflection: $CXX"
+    else
+        echo "✗ User-specified compiler does not support reflection: $CXX"
+        echo "Will search for alternative..."
+    fi
+fi
+
+# If we don't have a working compiler yet, search for one
+if [ -z "$REFLECTION_CXX" ]; then
+    for compiler in "${POTENTIAL_COMPILERS[@]}"; do
+        echo "Testing: $compiler"
+        if test_reflection_support "$compiler"; then
+            REFLECTION_CXX="$compiler"
+            echo "✓ Found reflection-enabled compiler: $compiler"
+            break
+        else
+            echo "✗ No reflection support: $compiler"
+        fi
+    done
+fi
+
+# Check if we found a working compiler
+if [ -z "$REFLECTION_CXX" ]; then
+    echo
+    echo "╔════════════════════════════════════════════════════════════════════════════╗"
+    echo "║                                 ERROR                                      ║"
+    echo "╠════════════════════════════════════════════════════════════════════════════╣"
+    echo "║                                                                            ║"
+    echo "║ No clang++ compiler with reflection support found!                        ║"
+    echo "║                                                                            ║"
+    echo "║ This benchmark requires a compiler that supports C++26 reflection.        ║"
+    echo "║                                                                            ║"
+    echo "║ Options:                                                                   ║"
+    echo "║ 1. Use the Docker container: ./p2996/run_docker.sh                        ║"
+    echo "║ 2. Build clang with reflection from: https://github.com/bloomberg/clang-p2996 ║"
+    echo "║ 3. Set CXX environment variable to point to reflection-enabled clang++    ║"
+    echo "║                                                                            ║"
+    echo "║ Example: CXX=/path/to/reflection-clang++ ./benchmark_script.sh            ║"
+    echo "║                                                                            ║"
+    echo "╚════════════════════════════════════════════════════════════════════════════╝"
+    exit 1
+fi
+
+# Set the compilers
+export CXX="$REFLECTION_CXX"
+
+# Find corresponding C compiler
+if [ -n "$CC" ]; then
+    REFLECTION_CC="$CC"
+elif [ "$REFLECTION_CXX" = "/usr/local/bin/clang++" ]; then
+    REFLECTION_CC="/usr/local/bin/clang"
+elif [ "$REFLECTION_CXX" = "/opt/clang/bin/clang++" ]; then
+    REFLECTION_CC="/opt/clang/bin/clang"
+elif [ "$REFLECTION_CXX" = "/usr/bin/clang++" ]; then
+    REFLECTION_CC="/usr/bin/clang"
+else
+    REFLECTION_CC="clang"
+fi
+
+export CC="$REFLECTION_CC"
+
+echo
+echo "Using reflection-enabled compiler: $($CXX --version | head -n1)"
+echo "Using C compiler: $($CC --version | head -n1)"
+echo
+
+# Function to create manual parsing test
+create_manual_parsing_test() {
+    local test_name="$1"
+    local struct_complexity="$2"
+
+    cat > "${test_name}_manual.cpp" << 'EOF'
+#include <simdjson.h>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <optional>
+
+// Test structures
+struct Person {
+    std::string name;
+    int age;
+    bool active;
+};
+
+struct Address {
+    std::string street;
+    std::string city;
+    int zipcode;
+};
+
+struct Employee {
+    Person person;
+    Address address;
+    std::vector<std::string> skills;
+    std::optional<std::string> department;
+    double salary;
+};
+
+// Manual parsing functions
+bool parse_person_manual(simdjson::ondemand::value& val, Person& person) {
+    auto obj = val.get_object();
+    if (obj.error()) return false;
+
+    for (auto field : obj) {
+        std::string_view key = field.unescaped_key();
+        if (key == "name") {
+            std::string_view name_val;
+            if (field.value().get(name_val)) return false;
+            person.name = name_val;
+        } else if (key == "age") {
+            if (field.value().get(person.age)) return false;
+        } else if (key == "active") {
+            if (field.value().get(person.active)) return false;
+        }
+    }
+    return true;
+}
+
+bool parse_address_manual(simdjson::ondemand::value& val, Address& address) {
+    auto obj = val.get_object();
+    if (obj.error()) return false;
+
+    for (auto field : obj) {
+        std::string_view key = field.unescaped_key();
+        if (key == "street") {
+            std::string_view street_val;
+            if (field.value().get(street_val)) return false;
+            address.street = street_val;
+        } else if (key == "city") {
+            std::string_view city_val;
+            if (field.value().get(city_val)) return false;
+            address.city = city_val;
+        } else if (key == "zipcode") {
+            if (field.value().get(address.zipcode)) return false;
+        }
+    }
+    return true;
+}
+
+bool parse_employee_manual(simdjson::ondemand::document& doc, Employee& employee) {
+    auto obj = doc.get_object();
+    if (obj.error()) return false;
+
+    for (auto field : obj) {
+        std::string_view key = field.unescaped_key();
+        if (key == "person") {
+            auto person_val = field.value();
+            if (!parse_person_manual(person_val, employee.person)) return false;
+        } else if (key == "address") {
+            auto addr_val = field.value();
+            if (!parse_address_manual(addr_val, employee.address)) return false;
+        } else if (key == "skills") {
+            auto skills_array = field.value().get_array();
+            if (skills_array.error()) return false;
+            for (auto skill : skills_array) {
+                std::string_view skill_val;
+                if (skill.get(skill_val)) return false;
+                employee.skills.emplace_back(skill_val);
+            }
+        } else if (key == "department") {
+            std::string_view dept_val;
+            if (!field.value().get(dept_val)) {
+                employee.department = dept_val;
+            }
+        } else if (key == "salary") {
+            if (field.value().get(employee.salary)) return false;
+        }
+    }
+    return true;
+}
+
+int main() {
+    simdjson::ondemand::parser parser;
+    std::string json_str = R"({
+        "person": {
+            "name": "John Doe",
+            "age": 30,
+            "active": true
+        },
+        "address": {
+            "street": "123 Main St",
+            "city": "Anytown",
+            "zipcode": 12345
+        },
+        "skills": ["C++", "JSON", "Programming"],
+        "department": "Engineering",
+        "salary": 85000.50
+    })";
+
+    simdjson::ondemand::document doc;
+    auto error = parser.iterate(simdjson::pad(json_str)).get(doc);
+    if (error) {
+        std::cerr << "Parse error" << std::endl;
+        return 1;
+    }
+
+    Employee employee;
+    if (!parse_employee_manual(doc, employee)) {
+        std::cerr << "Manual parsing failed" << std::endl;
+        return 1;
+    }
+
+    std::cout << "Manual parsing successful: " << employee.person.name
+              << ", age " << employee.person.age << std::endl;
+    return 0;
+}
+EOF
+}
+
+# Function to create reflection parsing test
+create_reflection_parsing_test() {
+    local test_name="$1"
+    local struct_complexity="$2"
+
+    cat > "${test_name}_reflection.cpp" << 'EOF'
+#include <simdjson.h>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <optional>
+
+// Test structures (same as manual version)
+struct Person {
+    std::string name;
+    int age;
+    bool active;
+};
+
+struct Address {
+    std::string street;
+    std::string city;
+    int zipcode;
+};
+
+struct Employee {
+    Person person;
+    Address address;
+    std::vector<std::string> skills;
+    std::optional<std::string> department;
+    double salary;
+};
+
+int main() {
+    simdjson::ondemand::parser parser;
+    std::string json_str = R"({
+        "person": {
+            "name": "John Doe",
+            "age": 30,
+            "active": true
+        },
+        "address": {
+            "street": "123 Main St",
+            "city": "Anytown",
+            "zipcode": 12345
+        },
+        "skills": ["C++", "JSON", "Programming"],
+        "department": "Engineering",
+        "salary": 85000.50
+    })";
+
+    simdjson::ondemand::document doc;
+    auto error = parser.iterate(simdjson::pad(json_str)).get(doc);
+    if (error) {
+        std::cerr << "Parse error" << std::endl;
+        return 1;
+    }
+
+    // Use reflection-based automatic deserialization
+    Employee employee;
+    auto result = doc.get<Employee>();
+    if (result.error()) {
+        std::cerr << "Reflection parsing failed" << std::endl;
+        return 1;
+    }
+    employee = result.value();
+
+    std::cout << "Reflection parsing successful: " << employee.person.name
+              << ", age " << employee.person.age << std::endl;
+    return 0;
+}
+EOF
+}
+
+# Function to time compilation of parsing approach
+time_parsing_compilation() {
+    local description="$1"
+    local test_file="$2"
+    local use_reflection="$3"
+    local iteration="$4"
+
+    echo "[$iteration] $description"
+
+    # Clean build
+    rm -rf build_parsing_test
+    mkdir build_parsing_test
+    cd build_parsing_test
+
+    # Copy test file
+    cp "../$test_file" .
+
+    echo "  Configuring..."
+    if [ "$use_reflection" = "true" ]; then
+        cmake -DCMAKE_CXX_COMPILER="$CXX" \
+              -DSIMDJSON_DEVELOPER_MODE=ON \
+              -DSIMDJSON_STATIC_REFLECTION=ON \
+              -DBUILD_SHARED_LIBS=OFF \
+              ../.. >/dev/null 2>&1
+    else
+        cmake -DCMAKE_CXX_COMPILER="$CXX" \
+              -DSIMDJSON_DEVELOPER_MODE=ON \
+              -DSIMDJSON_STATIC_REFLECTION=OFF \
+              -DBUILD_SHARED_LIBS=OFF \
+              ../.. >/dev/null 2>&1
+    fi
+
+    echo "  Building simdjson..."
+    cmake --build . --target simdjson >/dev/null 2>&1
+
+    echo "  Compiling parsing test..."
+    # Time just the test compilation
+    start_time=$(date +%s.%N)
+
+    "$CXX" -std=c++17 -I../../include "$test_file" -L. -lsimdjson -o parsing_test >/dev/null 2>&1
+
+    end_time=$(date +%s.%N)
+
+    # Calculate time duration
+    time_taken=$(echo "$end_time $start_time" | awk '{printf "%.3f", $1 - $2}')
+    echo "  Completed in: ${time_taken}s"
+
+    cd ..
+    rm -rf build_parsing_test
+
+    echo "$time_taken"
+}
+
+# Create test files
+echo "Creating test files..."
+create_manual_parsing_test "complex" "complex"
+create_reflection_parsing_test "complex" "complex"
+
+# Arrays to store times
+times_manual=""
+times_reflection=""
+
+echo
+echo "=== MANUAL PARSING COMPILATION ==="
+echo "Testing traditional simdjson parsing with explicit .get() calls"
+echo
+
+for i in $(seq 1 $ITERATIONS); do
+    time_result=$(time_parsing_compilation "Compiling manual parsing test" "complex_manual.cpp" "false" "$i" | tail -n1)
+    times_manual="$times_manual $time_result"
+done
+
+echo
+echo "=== REFLECTION PARSING COMPILATION ==="
+echo "Testing automatic deserialization with doc.get<Struct>()"
+echo
+
+for i in $(seq 1 $ITERATIONS); do
+    time_result=$(time_parsing_compilation "Compiling reflection parsing test" "complex_reflection.cpp" "true" "$i" | tail -n1)
+    times_reflection="$times_reflection $time_result"
+done
+
+echo
+echo "╔════════════════════════════════════════════════════════════════════════════╗"
+echo "║           REFLECTION USAGE COMPILATION RESULTS                             ║"
+echo "╠════════════════════════════════════════════════════════════════════════════╣"
+echo "║                                                                            ║"
+echo "║ MANUAL PARSING (explicit .get() calls):                                    ║"
+count=1
+for t in $times_manual; do
+    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
+        line=$(printf "Run %2d: %7.3f seconds" "$count" "$t")
+        print_box_line "$line"
+        count=$((count + 1))
+    fi
+done
+echo "║                                                                            ║"
+echo "║ REFLECTION PARSING (automatic doc.get<Struct>()):                          ║"
+count=1
+for t in $times_reflection; do
+    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
+        line=$(printf "Run %2d: %7.3f seconds" "$count" "$t")
+        print_box_line "$line"
+        count=$((count + 1))
+    fi
+done
+echo "╚════════════════════════════════════════════════════════════════════════════╝"
+
+echo
+echo "╔════════════════════════════════════════════════════════════════════════════╗"
+echo "║                              ANALYSIS SUMMARY                              ║"
+echo "╠════════════════════════════════════════════════════════════════════════════╣"
+echo "║                                                                            ║"
+
+# Calculate averages and percentages - filter to only numeric values first
+manual_numbers=""
+reflection_numbers=""
+
+for t in $times_manual; do
+    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
+        manual_numbers="$manual_numbers $t"
+    fi
+done
+
+for t in $times_reflection; do
+    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
+        reflection_numbers="$reflection_numbers $t"
+    fi
+done
+
+if [ -n "$manual_numbers" ] && [ -n "$reflection_numbers" ]; then
+    manual_avg=$(echo "$manual_numbers" | awk '{sum=0; for(i=1;i<=NF;i++) sum+=$i; print sum/NF}')
+    reflection_avg=$(echo "$reflection_numbers" | awk '{sum=0; for(i=1;i<=NF;i++) sum+=$i; print sum/NF}')
+    overhead=$(echo "$reflection_avg $manual_avg" | awk '{printf "%.3f", $1 - $2}')
+
+    if [ $(echo "$manual_avg > 0" | awk '{print ($1 > 0)}') -eq 1 ]; then
+        percent=$(echo "$reflection_avg $manual_avg" | awk '{printf "%.1f", ($1 - $2) / $2 * 100}')
+    else
+        percent="0"
+    fi
+
+    print_box_line "MANUAL PARSING RESULTS:"
+    print_box_line "$(printf "Average compilation time: %.3fs" "$manual_avg")"
+    print_box_line ""
+    print_box_line "REFLECTION PARSING RESULTS:"
+    print_box_line "$(printf "Average compilation time: %.3fs" "$reflection_avg")"
+    print_box_line ""
+    print_box_line "REFLECTION OVERHEAD:"
+    print_box_line "$(printf "Additional time: %.3fs (%+.1f%%)" "$overhead" "$percent")"
+    print_box_line ""
+else
+    echo "║ ERROR: Could not extract valid timing data                                 ║"
+    echo "║ Manual times: $times_manual"
+    echo "║ Reflection times: $times_reflection"
+    echo "║                                                                            ║"
+fi
+
+echo "╠════════════════════════════════════════════════════════════════════════════╣"
+echo "║                              INTERPRETATION                                ║"
+echo "╠════════════════════════════════════════════════════════════════════════════╣"
+echo "║                                                                            ║"
+echo "║ WHAT THESE RESULTS SHOW:                                                   ║"
+echo "║                                                                            ║"
+echo "║ • COMPILE-TIME COST: How much longer reflection parsing takes to compile   ║"
+echo "║   - Higher % = more expensive template instantiation and codegen           ║"
+echo "║                                                                            ║"
+echo "║ • CODE GENERATION OVERHEAD: Reflection creates parsing code at compile     ║"
+echo "║   time, which requires more template processing than manual parsing        ║"
+echo "║                                                                            ║"
+echo "║ • DEVELOPER TRADE-OFF: Reflection provides automatic deserialization       ║"
+echo "║   but at the cost of increased compilation time                            ║"
+echo "║                                                                            ║"
+echo "║ EVALUATION:                                                                ║"
+echo "║ • Low overhead (0-20%): Reflection is compile-time efficient               ║"
+echo "║ • Medium overhead (20-50%): Noticeable but potentially acceptable          ║"
+echo "║ • High overhead (50%+): Significant compilation cost for reflection        ║"
+echo "║                                                                            ║"
+echo "║ REAL-WORLD IMPACT:                                                         ║"
+echo "║ • Small projects: Absolute time matters more than percentage               ║"
+echo "║ • Large projects: Percentage overhead compounds across many files          ║"
+echo "║ • CI/CD pipelines: Longer builds affect development velocity               ║"
+echo "║                                                                            ║"
+echo "╚════════════════════════════════════════════════════════════════════════════╝"
+
+# Clean up test files
+rm -f complex_manual.cpp complex_reflection.cpp
+
+echo
+echo "Completed at: $(date)"

benchmark/benchmarker.h

@@ -2,13 +2,14 @@
 #define __BENCHMARKER_H
 
 #include "event_counter.h"
+#include "simdjson.h"
 
 #include <cassert>
 #include <cctype>
 #ifndef _MSC_VER
 #include <dirent.h>
-#include <unistd.h>
 #endif
+#include <unistd.h>
 #include <cinttypes>
 
 #include <cstdio>
@@ -45,6 +46,8 @@ using std::vector;
 using std::ostream;
 using std::ofstream;
 using std::exception;
+using std::min;
+using std::max;
 
 // Initialize "verbose" to go nowhere. We'll read options in main() and set to cout if verbose is true.
 std::ofstream dev_null;
@@ -81,7 +84,7 @@ struct json_stats {
     bytes = json.size();
     blocks = bytes / BYTES_PER_BLOCK;
     if (bytes % BYTES_PER_BLOCK > 0) { blocks++; } // Account for remainder block
-    structurals = parser.n_structural_indexes-1;
+    structurals = parser.implementation->n_structural_indexes-1;
 
     // Calculate stats on blocks that will trigger utf-8 if statements / mispredictions
     bool last_block_has_utf8 = false;
@@ -138,7 +141,7 @@ struct json_stats {
     for (size_t block=0; block<blocks; block++) {
       // Count structurals in the block
       int block_structurals=0;
-      while (structural < parser.n_structural_indexes && parser.structural_indexes[structural] < (block+1)*BYTES_PER_BLOCK) {
+      while (structural < parser.implementation->n_structural_indexes && parser.implementation->structural_indexes[structural] < (block+1)*BYTES_PER_BLOCK) {
         block_structurals++;
         structural++;
       }
@@ -222,8 +225,19 @@ struct progress_bar {
   }
 };
 
+/**
+ * The speed at which we can allocate memory is strictly system specific.
+ * It depends on the OS and the runtime library. It is subject to various
+ * system-specific knobs. It is not something that we can reasonably
+ * benchmark with crude timings.
+ * If someone wants to optimize how simdjson allocate memory, then it will
+ * almost surely require a distinct benchmarking tool. What is meant by
+ * "memory allocation" also requires a definition. Doing "new char[size]" can
+ * do many different things depending on the system.
+ */
+
 enum class BenchmarkStage {
-  ALL,
+  ALL, // This excludes allocation
   ALLOCATE,
   STAGE1,
   STAGE2
@@ -231,7 +245,7 @@ enum class BenchmarkStage {
 
 const char* benchmark_stage_name(BenchmarkStage stage) {
   switch (stage) {
-    case BenchmarkStage::ALL: return "All";
+    case BenchmarkStage::ALL: return "All (Without Allocation)";
     case BenchmarkStage::ALLOCATE: return "Allocate";
     case BenchmarkStage::STAGE1: return "Stage 1";
     case BenchmarkStage::STAGE2: return "Stage 2";
@@ -241,7 +255,7 @@ const char* benchmark_stage_name(BenchmarkStage stage) {
 
 struct benchmarker {
   // JSON text from loading the file. Owns the memory.
-  padded_string json;
+  padded_string json{};
   // JSON filename
   const char *filename;
   // Event collector that can be turned on to measure cycles, missed branches, etc.
@@ -250,22 +264,21 @@ struct benchmarker {
   // Statistics about the JSON file independent of its speed (amount of utf-8, structurals, etc.).
   // Loaded on first parse.
   json_stats* stats;
-  // Speed and event summary for full parse (not including allocation)
+  // Speed and event summary for full parse (stage 1 and stage 2, but *excluding* allocation)
-  event_aggregate all_stages;
+  event_aggregate all_stages_without_allocation{};
   // Speed and event summary for stage 1
-  event_aggregate stage1;
+  event_aggregate stage1{};
   // Speed and event summary for stage 2
-  event_aggregate stage2;
+  event_aggregate stage2{};
   // Speed and event summary for allocation
-  event_aggregate allocate_stage;
+  event_aggregate allocate_stage{};
   // Speed and event summary for the repeatly-parsing mode
-  event_aggregate loop;
+  event_aggregate loop{};
 
   benchmarker(const char *_filename, event_collector& _collector)
     : filename(_filename), collector(_collector), stats(NULL) {
     verbose() << "[verbose] loading " << filename << endl;
-    simdjson::error_code error;
+    auto error = padded_string::load(filename).get(json);
-    padded_string::load(filename).tie(this->json, error);
     if (error) {
       exit_error(string("Could not load the file ") + filename);
     }
@@ -278,33 +291,37 @@ struct benchmarker {
     }
   }
 
+  benchmarker(const benchmarker&) = delete;
+  benchmarker& operator=(const benchmarker&) = delete;
+
   const event_aggregate& operator[](BenchmarkStage stage) const {
     switch (stage) {
-      case BenchmarkStage::ALL: return this->all_stages;
+      case BenchmarkStage::ALL: return this->all_stages_without_allocation;
       case BenchmarkStage::STAGE1: return this->stage1;
       case BenchmarkStage::STAGE2: return this->stage2;
       case BenchmarkStage::ALLOCATE: return this->allocate_stage;
-      default: exit_error("Unknown stage"); return this->all_stages;
+      default: exit_error("Unknown stage"); return this->all_stages_without_allocation;
     }
   }
 
   int iterations() const {
-    return all_stages.iterations;
+    return all_stages_without_allocation.iterations;
   }
 
-  really_inline void run_iteration(bool stage1_only, bool hotbuffers=false) {
+  simdjson_inline void run_iteration(bool stage1_only, bool hotbuffers=false) {
     // Allocate dom::parser
     collector.start();
     dom::parser parser;
-    error_code error = parser.allocate(json.size());
+    // We always allocate at least 64KB. Smaller allocations may actually be slower under some systems.
+    error_code error = parser.allocate(json.size() < 65536 ? 65536 : json.size());
     if (error) {
-      exit_error(string("Unable to allocate_stage ") + to_string(json.size()) + " bytes for the JSON result: " + error_message(error));
+      exit_error(string("Unable to allocate_stage ") + to_string(json.size()) + " bytes for the JSON text: " + error_message(error));
     }
     event_count allocate_count = collector.end();
     allocate_stage << allocate_count;
     // Run it once to get hot buffers
     if(hotbuffers) {
-      auto result = parser.parse((const uint8_t *)json.data(), json.size());
+      auto result = parser.parse(reinterpret_cast<const uint8_t *>(json.data()), json.size());
       if (result.error()) {
         exit_error(string("Failed to parse ") + filename + string(":") + error_message(result.error()));
       }
@@ -314,7 +331,7 @@ struct benchmarker {
 
     // Stage 1 (find structurals)
     collector.start();
-    error = active_implementation->stage1((const uint8_t *)json.data(), json.size(), parser, false);
+    error = parser.implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.size(), stage1_mode::regular);
     event_count stage1_count = collector.end();
     stage1 << stage1_count;
     if (error) {
@@ -324,22 +341,22 @@ struct benchmarker {
     // Stage 2 (unified machine) and the rest
 
     if (stage1_only) {
-      all_stages << stage1_count;
+      all_stages_without_allocation << stage1_count;
     } else {
       event_count stage2_count;
       collector.start();
-      error = active_implementation->stage2((const uint8_t *)json.data(), json.size(), parser);
+      error = parser.implementation->stage2(parser.doc);
       if (error) {
         exit_error(string("Failed to parse ") + filename + " during stage 2 parsing " + error_message(error));
       }
       stage2_count = collector.end();
       stage2 << stage2_count;
-      all_stages << allocate_count + stage1_count + stage2_count;
+      all_stages_without_allocation << stage1_count + stage2_count;
     }
     // Calculate stats the first time we parse
     if (stats == NULL) {
       if (stage1_only) { //  we need stage 2 once
-        error = active_implementation->stage2((const uint8_t *)json.data(), json.size(), parser);
+        error = parser.implementation->stage2(parser.doc);
         if (error) {
           printf("Warning: failed to parse during stage 2. Unable to acquire statistics.\n");
         }
@@ -350,7 +367,7 @@ struct benchmarker {
 
   void run_loop(size_t iterations) {
     dom::parser parser;
-    auto firstresult = parser.parse((const uint8_t *)json.data(), json.size());
+    auto firstresult = parser.parse(reinterpret_cast<const uint8_t *>(json.data()), json.size());
     if (firstresult.error()) {
       exit_error(string("Failed to parse ") + filename + string(":") + error_message(firstresult.error()));
     }
@@ -358,7 +375,7 @@ struct benchmarker {
     collector.start();
     // some users want something closer to "number of documents per second"
     for(size_t i = 0; i < iterations; i++) {
-      auto result = parser.parse((const uint8_t *)json.data(), json.size());
+      auto result = parser.parse(reinterpret_cast<const uint8_t *>(json.data()), json.size());
       if (result.error()) {
         exit_error(string("Failed to parse ") + filename + string(":") + error_message(result.error()));
       }
@@ -367,62 +384,75 @@ struct benchmarker {
     loop << all_loop_count;
   }
 
-  really_inline void run_iterations(size_t iterations, bool stage1_only, bool hotbuffers=false) {
+  simdjson_inline void run_iterations(size_t iterations, bool stage1_only, bool hotbuffers=false) {
     for (size_t i = 0; i<iterations; i++) {
       run_iteration(stage1_only, hotbuffers);
     }
     run_loop(iterations);
   }
 
+  // Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
   template<typename T>
   void print_aggregate(const char* prefix, const T& stage) const {
-    printf("%s%-13s: %8.4f ns per block (%6.2f%%) - %8.4f ns per byte - %8.4f ns per structural - %8.3f GB/s\n",
+    printf("%s%-13s: %8.4f ns per block (%6.2f%%) - %8.4f ns per byte - %8.4f ns per structural - %8.4f GB/s\n",
       prefix,
       "Speed",
-      stage.elapsed_ns() / stats->blocks, // per block
+      stage.elapsed_ns() / static_cast<double>(stats->blocks), // per block
-      100.0 * stage.elapsed_sec() / all_stages.elapsed_sec(), // %
+      percent(stage.elapsed_sec(), all_stages_without_allocation.elapsed_sec()), // %
-      stage.elapsed_ns() / stats->bytes, // per byte
+      stage.elapsed_ns() / static_cast<double>(stats->bytes), // per byte
-      stage.elapsed_ns() / stats->structurals, // per structural
+      stage.elapsed_ns() / static_cast<double>(stats->structurals), // per structural
-      (json.size() / 1000000000.0) / stage.elapsed_sec() // GB/s
+      (static_cast<double>(json.size()) / 1000000000.0) / stage.elapsed_sec() // GB/s
     );
 
     if (collector.has_events()) {
       printf("%s%-13s: %8.4f per block    (%6.2f%%) - %8.4f per byte    - %8.4f per structural    - %8.3f GHz est. frequency\n",
         prefix,
         "Cycles",
-        stage.cycles() / stats->blocks,
+        stage.cycles() / static_cast<double>(stats->blocks),
-        100.0 * stage.cycles() / all_stages.cycles(),
+        percent(stage.cycles(), all_stages_without_allocation.cycles()),
-        stage.cycles() / stats->bytes,
+        stage.cycles() / static_cast<double>(stats->bytes),
-        stage.cycles() / stats->structurals,
+        stage.cycles() / static_cast<double>(stats->structurals),
         (stage.cycles() / stage.elapsed_sec()) / 1000000000.0
       );
       printf("%s%-13s: %8.4f per block    (%6.2f%%) - %8.4f per byte    - %8.4f per structural    - %8.3f per cycle\n",
         prefix,
         "Instructions",
-        stage.instructions() / stats->blocks,
+        stage.instructions() / static_cast<double>(stats->blocks),
-        100.0 * stage.instructions() / all_stages.instructions(),
+        percent(stage.instructions(), all_stages_without_allocation.instructions()),
-        stage.instructions() / stats->bytes,
+        stage.instructions() / static_cast<double>(stats->bytes),
-        stage.instructions() / stats->structurals,
+        stage.instructions() / static_cast<double>(stats->structurals),
-        stage.instructions() / stage.cycles()
+        stage.instructions() / static_cast<double>(stage.cycles())
       );
-
+#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
       // NOTE: removed cycles/miss because it is a somewhat misleading stat
       printf("%s%-13s: %7.0f branch misses (%6.2f%%) - %.0f cache misses (%6.2f%%) - %.2f cache references\n",
         prefix,
         "Misses",
         stage.branch_misses(),
-        100.0 * stage.branch_misses() / all_stages.branch_misses(),
+        percent(stage.branch_misses(), all_stages_without_allocation.branch_misses()),
         stage.cache_misses(),
-        100.0 * stage.cache_misses() / all_stages.cache_misses(),
+        percent(stage.cache_misses(), all_stages_without_allocation.cache_misses()),
         stage.cache_references()
       );
+#endif
     }
   }
 
-  void print(bool tabbed_output, size_t iterations) const {
+  static double percent(size_t a, size_t b) {
+    return 100.0 * static_cast<double>(a) / static_cast<double>(b);
+  }
+  static double percent(double a, double b) {
+    return 100.0 * a / b;
+  }
+
+  void print(bool tabbed_output, bool stage1_only) const {
     if (tabbed_output) {
-      char* filename_copy = (char*)malloc(strlen(filename)+1);
+      char* filename_copy = reinterpret_cast<char*>(malloc(strlen(filename)+1));
+      SIMDJSON_PUSH_DISABLE_WARNINGS
+      SIMDJSON_DISABLE_DEPRECATED_WARNING // Validated CRT_SECURE safe here
       strcpy(filename_copy, filename);
+      SIMDJSON_POP_DISABLE_WARNINGS
+
       #if defined(__linux__)
       char* base = ::basename(filename_copy);
       #else
@@ -432,21 +462,21 @@ struct benchmarker {
         base[strlen(base)-5] = '\0';
       }
 
-      double gb = json.size() / 1000000000.0;
+      double gb = static_cast<double>(json.size()) / 1000000000.0;
       if (collector.has_events()) {
         printf("\"%s\"\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n",
                 base,
-                allocate_stage.best.cycles() / json.size(),
+                allocate_stage.best.cycles() / static_cast<double>(json.size()),
-                stage1.best.cycles() / json.size(),
+                stage1.best.cycles() / static_cast<double>(json.size()),
-                stage2.best.cycles() / json.size(),
+                stage2.best.cycles() / static_cast<double>(json.size()),
-                all_stages.best.cycles() / json.size(),
+                all_stages_without_allocation.best.cycles() / static_cast<double>(json.size()),
-                gb / all_stages.best.elapsed_sec(),
+                gb / all_stages_without_allocation.best.elapsed_sec(),
                 gb / stage1.best.elapsed_sec(),
                 gb / stage2.best.elapsed_sec());
       } else {
         printf("\"%s\"\t\t\t\t\t%f\t%f\t%f\n",
                 base,
-                gb / all_stages.best.elapsed_sec(),
+                gb / all_stages_without_allocation.best.elapsed_sec(),
                 gb / stage1.best.elapsed_sec(),
                 gb / stage2.best.elapsed_sec());
       }
@@ -455,49 +485,52 @@ struct benchmarker {
       printf("\n");
       printf("%s\n", filename);
       printf("%s\n", string(strlen(filename), '=').c_str());
-      printf("%9zu blocks - %10zu bytes - %5zu structurals (%5.1f %%)\n", stats->bytes / BYTES_PER_BLOCK, stats->bytes, stats->structurals, 100.0 * stats->structurals / stats->bytes);
+      printf("%9zu blocks - %10zu bytes - %5zu structurals (%5.1f %%)\n", stats->bytes / BYTES_PER_BLOCK, stats->bytes, stats->structurals, percent(stats->structurals, stats->bytes));
       if (stats) {
         printf("special blocks with: utf8 %9zu (%5.1f %%) - escape %9zu (%5.1f %%) - 0 structurals %9zu (%5.1f %%) - 1+ structurals %9zu (%5.1f %%) - 8+ structurals %9zu (%5.1f %%) - 16+ structurals %9zu (%5.1f %%)\n",
-          stats->blocks_with_utf8, 100.0 * stats->blocks_with_utf8 / stats->blocks,
+          stats->blocks_with_utf8, percent(stats->blocks_with_utf8, stats->blocks),
-          stats->blocks_with_escapes, 100.0 * stats->blocks_with_escapes / stats->blocks,
+          stats->blocks_with_escapes, percent(stats->blocks_with_escapes, stats->blocks),
-          stats->blocks_with_0_structurals, 100.0 * stats->blocks_with_0_structurals / stats->blocks,
+          stats->blocks_with_0_structurals, percent(stats->blocks_with_0_structurals, stats->blocks),
-          stats->blocks_with_1_structural, 100.0 * stats->blocks_with_1_structural / stats->blocks,
+          stats->blocks_with_1_structural, percent(stats->blocks_with_1_structural, stats->blocks),
-          stats->blocks_with_8_structurals, 100.0 * stats->blocks_with_8_structurals / stats->blocks,
+          stats->blocks_with_8_structurals, percent(stats->blocks_with_8_structurals, stats->blocks),
-          stats->blocks_with_16_structurals, 100.0 * stats->blocks_with_16_structurals / stats->blocks);
+          stats->blocks_with_16_structurals, percent(stats->blocks_with_16_structurals, stats->blocks));
         printf("special block flips: utf8 %9zu (%5.1f %%) - escape %9zu (%5.1f %%) - 0 structurals %9zu (%5.1f %%) - 1+ structurals %9zu (%5.1f %%) - 8+ structurals %9zu (%5.1f %%) - 16+ structurals %9zu (%5.1f %%)\n",
-          stats->blocks_with_utf8_flipped, 100.0 * stats->blocks_with_utf8_flipped / stats->blocks,
+          stats->blocks_with_utf8_flipped, percent(stats->blocks_with_utf8_flipped, stats->blocks),
-          stats->blocks_with_escapes_flipped, 100.0 * stats->blocks_with_escapes_flipped / stats->blocks,
+          stats->blocks_with_escapes_flipped, percent(stats->blocks_with_escapes_flipped, stats->blocks),
-          stats->blocks_with_0_structurals_flipped, 100.0 * stats->blocks_with_0_structurals_flipped / stats->blocks,
+          stats->blocks_with_0_structurals_flipped, percent(stats->blocks_with_0_structurals_flipped, stats->blocks),
-          stats->blocks_with_1_structural_flipped, 100.0 * stats->blocks_with_1_structural_flipped / stats->blocks,
+          stats->blocks_with_1_structural_flipped, percent(stats->blocks_with_1_structural_flipped, stats->blocks),
-          stats->blocks_with_8_structurals_flipped, 100.0 * stats->blocks_with_8_structurals_flipped / stats->blocks,
+          stats->blocks_with_8_structurals_flipped, percent(stats->blocks_with_8_structurals_flipped, stats->blocks),
-          stats->blocks_with_16_structurals_flipped, 100.0 * stats->blocks_with_16_structurals_flipped / stats->blocks);
+          stats->blocks_with_16_structurals_flipped, percent(stats->blocks_with_16_structurals_flipped, stats->blocks));
       }
       printf("\n");
-      printf("All Stages\n");
+      if(!stage1_only) {
-      print_aggregate("|    "   , all_stages.best);
+        printf("All Stages (excluding allocation)\n");
-      // frequently, allocation is a tiny fraction of the running time so we omit it
+        print_aggregate("|    "   , all_stages_without_allocation.best);
-      if(allocate_stage.best.elapsed_sec() > 0.01 * all_stages.best.elapsed_sec()) {
+        // frequently, allocation is a tiny fraction of the running time so we omit it
-        printf("|- Allocation\n");
+        if(allocate_stage.best.elapsed_sec() > 0.01 * all_stages_without_allocation.best.elapsed_sec()) {
-        print_aggregate("|    ", allocate_stage.best);
+          printf("|- Allocation\n");
+          print_aggregate("|    ", allocate_stage.best);
+        }
       }
       printf("|- Stage 1\n");
       print_aggregate("|    ", stage1.best);
-      printf("|- Stage 2\n");
+      if(!stage1_only) {
-      print_aggregate("|    ", stage2.best);
+        printf("|- Stage 2\n");
+        print_aggregate("|    ", stage2.best);
+      }
       if (collector.has_events()) {
         double freq1 = (stage1.best.cycles() / stage1.best.elapsed_sec()) / 1000000000.0;
         double freq2 = (stage2.best.cycles() / stage2.best.elapsed_sec()) / 1000000000.0;
-        double freqall = (all_stages.best.cycles() / all_stages.best.elapsed_sec()) / 1000000000.0;
+        double freqall = (all_stages_without_allocation.best.cycles() / all_stages_without_allocation.best.elapsed_sec()) / 1000000000.0;
-        double freqmin = std::min(freq1, freq2);
+        double freqmin = min(freq1, freq2);
-        double freqmax = std::max(freq1, freq2);
+        double freqmax = max(freq1, freq2);
-        if((freqall < 0.95 * freqmin) or (freqall > 1.05 * freqmax)) {
+        if((freqall < 0.95 * freqmin) || (freqall > 1.05 * freqmax)) {
           printf("\nWarning: The processor frequency fluctuates in an expected way!!!\n"
-          "Expect the overall speed not to match stage 1 and stage 2 speeds.\n"
           "Range for stage 1 and stage 2 : [%.3f GHz, %.3f GHz], overall: %.3f GHz.\n",
           freqmin, freqmax, freqall);
         }
       }
-      printf("\n%.1f documents parsed per second\n", iterations/loop.best.elapsed_sec());
+      printf("\n%.1f documents parsed per second (best)\n", 1.0/static_cast<double>(all_stages_without_allocation.best.elapsed_sec()));
     }
   }
 };

benchmark/car_builder/CMakeLists.txt

@@ -0,0 +1,14 @@
+# 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

@@ -0,0 +1,127 @@
+#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/boostjson.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_BOOSTJSON
+
+#include "distinct_user_id.h"
+
+namespace distinct_user_id {
+
+struct boostjson {
+  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+
+    auto root = boost::json::parse(json);
+    for (const auto &tweet : root.at("statuses").as_array()) {
+      result.push_back(tweet.at("user").at("id").to_number<uint64_t>());
+
+      if (tweet.as_object().if_contains("retweeted_status")) {
+        result.push_back(tweet.at("retweeted_status").at("user").at("id").to_number<uint64_t>());
+      }
+    }
+
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(distinct_user_id, boostjson)->UseManualTime();
+
+} // namespace distinct_user_id
+
+#endif // SIMDJSON_COMPETITION_BOOSTJSON

benchmark/distinct_user_id/distinct_user_id.h

@@ -0,0 +1,53 @@
+
+#pragma once
+
+#include "json_benchmark/file_runner.h"
+#include <vector>
+
+namespace distinct_user_id {
+
+using namespace json_benchmark;
+
+template<typename I>
+struct runner : public file_runner<I> {
+  std::vector<uint64_t> result{};
+
+  bool setup(benchmark::State &state) {
+    return this->load_json(state, TWITTER_JSON);
+  }
+
+  bool before_run(benchmark::State &state) {
+    if (!file_runner<I>::before_run(state)) { return false; }
+    result.clear();
+    return true;
+  }
+
+  bool run(benchmark::State &) {
+    return this->implementation.run(this->json, result);
+  }
+
+  bool after_run(benchmark::State &state) {
+    if (!file_runner<I>::after_run(state)) { return false; }
+    std::sort(result.begin(), result.end());
+    auto last = std::unique(result.begin(), result.end());
+    result.erase(last, result.end());
+    return true;
+  }
+
+  template<typename R>
+  bool diff(benchmark::State &state, runner<R> &reference) {
+    return diff_results(state, result, reference.result, diff_flags::NONE);
+  }
+
+  size_t items_per_iteration() {
+    return result.size();
+  }
+};
+
+struct simdjson_dom;
+
+template<typename I> simdjson_inline static void distinct_user_id(benchmark::State &state) {
+  run_json_benchmark<runner<I>, runner<simdjson_dom>>(state);
+}
+
+} // namespace distinct_user_id

benchmark/distinct_user_id/nlohmann_json.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_NLOHMANN_JSON
+
+#include "distinct_user_id.h"
+
+namespace distinct_user_id {
+
+struct nlohmann_json {
+  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+    auto root = nlohmann::json::parse(json.data(), json.data() + json.size());
+    for (auto tweet : root["statuses"]) {
+      result.push_back(tweet["user"]["id"]);
+      if (tweet.contains("retweeted_status")) {
+        result.push_back(tweet["retweeted_status"]["user"]["id"]);
+      }
+    }
+
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(distinct_user_id, nlohmann_json)->UseManualTime();
+
+} // namespace distinct_user_id
+
+#endif // SIMDJSON_COMPETITION_NLOHMANN_JSON

benchmark/distinct_user_id/nlohmann_json_sax.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_NLOHMANN_JSON
+
+#include "distinct_user_id.h"
+
+namespace distinct_user_id {
+
+using json = nlohmann::json;
+
+struct nlohmann_json_sax {
+    struct Handler : json::json_sax_t
+    {
+        std::vector<uint64_t>& result;
+        bool user = false;
+        bool user_id = false;
+        Handler(std::vector<uint64_t> &r) : result(r) { }
+
+        bool key(string_t& val) override {
+            // Assume that valid user/id pairs appear only once in main array of user objects
+            if (user) { // If already found user object, find id key
+                if (val.compare("id") == 0) { user_id = true; }
+            }
+            else if (val.compare("user") == 0) { user = true; } // Otherwise, find user object
+            return true;
+        }
+        bool number_unsigned(number_unsigned_t val) override {
+            if (user_id) {
+                result.emplace_back(val);
+                user = false;
+                user_id = false;
+            }
+            return true;
+        }
+        // Irrelevant events
+        bool null() override { return true; }
+        bool boolean(bool val) override { return true; }
+        bool number_float(number_float_t val, const string_t& s) override { return true; }
+        bool number_integer(number_integer_t val) override { return true; }
+        bool string(string_t& val) override { return true; }
+        bool start_object(std::size_t elements) override { return true; }
+        bool end_object() override { return true; }
+        bool start_array(std::size_t elements) override { return true; }
+        bool end_array() override { return true; }
+        bool binary(json::binary_t& val) override { return true; }
+        bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override { return false; }
+    }; // Handler
+
+    bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+        Handler handler(result);
+        json::sax_parse(json.data(), &handler);
+
+        return true;
+    }
+}; // nlohmann_json_sax
+BENCHMARK_TEMPLATE(distinct_user_id, nlohmann_json_sax)->UseManualTime();
+} // namespace distinct_user_id
+
+#endif // SIMDJSON_COMPETITION_NLOHMANN_JSON

benchmark/distinct_user_id/rapidjson.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_RAPIDJSON
+
+#include "distinct_user_id.h"
+
+namespace distinct_user_id {
+
+using namespace rapidjson;
+
+struct rapidjson_base {
+  Document doc{};
+
+  bool run(Document &root, std::vector<uint64_t> &result) {
+    if (root.HasParseError()) { printf("parse error\n"); return false; }
+    if (!root.IsObject()) { printf("root is not an object\n"); return false; }
+    auto statuses = root.FindMember("statuses");
+    if (statuses == root.MemberEnd() || !statuses->value.IsArray()) { printf("statuses is not an array\n"); return false; }
+    for (auto &tweet : statuses->value.GetArray()) {
+      if (!tweet.IsObject()) { return false; }
+      auto user = tweet.FindMember("user");
+      if (user == tweet.MemberEnd() || !user->value.IsObject()) { printf("user is not an object\n"); return false; }
+      auto id = user->value.FindMember("id");
+      if (id == user->value.MemberEnd() || !id->value.IsUint64()) { printf("id is not an int\n"); return false; }
+      result.push_back(id->value.GetUint64());
+
+      auto retweet = tweet.FindMember("retweeted_status");
+      if (retweet != tweet.MemberEnd()) {
+        if (!retweet->value.IsObject()) { printf("retweet is not an object\n"); return false; }
+        user = retweet->value.FindMember("user");
+        if (user == retweet->value.MemberEnd() || !user->value.IsObject()) { printf("rewtweet.user is not an object\n"); return false; }
+        id = user->value.FindMember("id");
+        if (id == user->value.MemberEnd() || !id->value.IsUint64()) { printf("retweet.id is not an int\n"); return false; }
+        result.push_back(id->value.GetUint64());
+      }
+    }
+
+    return true;
+  }
+};
+
+struct rapidjson : rapidjson_base {
+  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+    return rapidjson_base::run(doc.Parse<kParseValidateEncodingFlag>(json.data()), result);
+  }
+};
+BENCHMARK_TEMPLATE(distinct_user_id, rapidjson)->UseManualTime();
+
+#if SIMDJSON_COMPETITION_ONDEMAND_INSITU
+struct rapidjson_insitu : rapidjson_base {
+  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag|kParseInsituFlag>(json.data()), result);
+  }
+};
+BENCHMARK_TEMPLATE(distinct_user_id, rapidjson_insitu)->UseManualTime();
+#endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
+} // namespace partial_tweets
+
+#endif // SIMDJSON_COMPETITION_RAPIDJSON

benchmark/distinct_user_id/rapidjson_sax.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_RAPIDJSON
+
+#include "distinct_user_id.h"
+#include <string.h>
+namespace distinct_user_id {
+
+using namespace rapidjson;
+
+struct rapidjson_sax {
+    struct Handler {
+        std::vector<uint64_t>& result;
+        bool user = false;
+        bool user_id = false;
+        Handler(std::vector<uint64_t> &r) : result(r) { }
+
+        bool Key(const char* key, SizeType length, bool copy) {
+            // Assume that valid user/id pairs appear only once in main array of user objects
+            if (user) { // If already found user object, find id key
+                if ((length == 2) && memcmp(key,"id",2) == 0) { user_id = true; }
+            }
+            else if ((length == 4) && memcmp(key,"user",4) == 0) { user = true; } // Otherwise, find user object
+            return true;
+        }
+        bool Uint(unsigned i) {     // id values are treated as Uint (not Uint64) by the reader
+            if (user_id) {  // Getting id if previous key was "id" for a user
+                result.emplace_back(i);
+                user_id = false;
+                user = false;
+            }
+            return true;
+        }
+        // Irrelevant events
+        bool Null() { return true; }
+        bool Bool(bool b) { return true; }
+        bool Double(double d) { return true; }
+        bool Int(int i) { return true; }
+        bool Int64(int64_t i) { return true; }
+        bool Uint64(uint64_t i) { return true; }
+        bool RawNumber(const char* str, SizeType length, bool copy) { return true; }
+        bool String(const char* str, SizeType length, bool copy) { return true; }
+        bool StartObject() { return true; }
+        bool EndObject(SizeType memberCount) { return true; }
+        bool StartArray() { return true; }
+        bool EndArray(SizeType elementCount) { return true; }
+    }; // handler
+
+    bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+        Reader reader;
+        Handler handler(result);
+        InsituStringStream ss(json.data());
+        reader.Parse<kParseInsituFlag | kParseValidateEncodingFlag | kParseFullPrecisionFlag>(ss,handler);
+        return true;
+    }
+
+}; // rapid_jason_sax
+BENCHMARK_TEMPLATE(distinct_user_id, rapidjson_sax)->UseManualTime();
+} // namespace distinct_user_id
+
+#endif // SIMDJSON_COMPETITION_RAPIDJSON