Last commit for version 0.9.0. (#1503)

* Last commit for version 0.9.0.

* Removing space.

.appveyor.yml

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

.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

.dockerignore

@@ -1,7 +1,7 @@
 *
 !.git
 !Makefile
-!amalgamation.sh
+!amalgamate.py
 !benchmark
 !dependencies
 !include
@@ -12,4 +12,4 @@
 !src
 !style
 !tests
-!tools
+!tools

.drone.yml

@@ -1,207 +1,458 @@
 kind: pipeline
-name: x64-quicktests-libc
-
-platform:
-  os: linux
-  arch: amd64
-
+name: i386-gcc # we do not support 32-bit systems, but we run tests
+platform: { os: linux, arch: amd64 }
 steps:
-- name: quicktests
-  image: conanio/clang8
+- name: Build and Test
+  image: i386/ubuntu
+  environment:
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly 
+  commands:
+    - scripts/addcmakeppa.sh "$(env -i sh -c '. /etc/os-release; echo $VERSION_CODENAME')"
+    - apt-get install -y g++ cmake gcc git
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS 
+---
+kind: pipeline
+name: i386-clang # we do not support 32-bit systems, but we run tests
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: i386/ubuntu
+  environment:
+    CC: clang-6.0
+    CXX: clang++-6.0
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
+    CTEST_FLAGS: -j4 --output-on-failure -LE explicitonly 
+  commands:
+    - scripts/addcmakeppa.sh "$(env -i sh -c '. /etc/os-release; echo $VERSION_CODENAME')"
+    - apt-get install -y clang++-6.0 cmake git
+    - mkdir build
+    - cd build
+    - cmake $CMAKE_FLAGS ..
+    - cmake --build . $BUILD_FLAGS
+    - ctest $CTEST_FLAGS 
+---
+kind: pipeline
+name: gcc9
+platform: { os: linux, arch: amd64 }
+steps:
+- name: Build and Test
+  image: gcc:9
+  environment:
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=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=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: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=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=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
-
-platform:
-  os: linux
-  arch: amd64
-
+name: dynamic-gcc9
+platform: { os: linux, arch: amd64 }
 steps:
-- name: quicktests
-  image: gcc:8
-  commands: [ make quicktests ]
+- name: Build and Test
+  image: gcc:9
+  environment:
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=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: x64-checkperf
-
-platform:
-  os: linux
-  arch: amd64
-
+name: dynamic-clang9
+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: -DSIMDJSON_BUILD_STATIC=OFF
+    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: -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_IMPLEMENTATION=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=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=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=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
-  commands: [ sed '/^$/Q' /proc/cpuinfo, make checkperf ]
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -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
-
-platform:
-  os: linux
-  arch: amd64
-
+name: arm64-clang6
+platform: { os: linux, arch: arm64 }
 steps:
-- name: build
-  image: gcc:8
-  commands: [ make, make amalgamate ]
+- name: Build and Test
+  image: debian:buster-backports
+  environment:
+    CC: clang-6.0
+    CXX: clang++-6.0
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
+    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
-
-platform:
-  os: linux
-  arch: amd64
-
+name: arm64-dynamic-gcc8
+platform: { os: linux, arch: arm64 }
 steps:
-- name: slowtests
-  image: gcc:8
-  commands: [ make slowtests ]
----
-kind: pipeline
-name: x64-noexceptions-quicktests
-
-platform:
-  os: linux
-  arch: amd64
-
-steps:
-- name: quicktests
+- name: Build and Test
   image: gcc:8
   environment:
-    EXTRA_FLAGS: -fno-exceptions
-  commands: [ make quicktests ]
+    CC: gcc
+    CXX: g++
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=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: x64-noexceptions-build
-
-platform:
-  os: linux
-  arch: amd64
-
+name: arm64-dynamic-clang6
+platform: { os: linux, arch: arm64 }
 steps:
-- name: build
+- name: Build and Test
+  image: debian:buster-backports
+  environment:
+    CC: clang-6.0
+    CXX: clang++-6.0
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=OFF
+    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
-  commands: [ make, make amalgamate ]
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON -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
-
-platform:
-  os: linux
-  arch: amd64
-
+name: arm64-sanitize-clang6
+platform: { os: linux, arch: arm64 }
 steps:
-- name: slowtests
-  image: gcc:8
+- name: Build and Test
+  image: debian:buster-backports
   environment:
-    EXTRA_FLAGS: -fno-exceptions
-  commands: [ make slowtests ]
+    CC: clang-6.0
+    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
-
-platform:
-  os: linux
-  arch: arm64
-
+name: ninja-clang9
+platform: { os: linux, arch: amd64 }
 steps:
-- name: quicktests
-  image: gcc:8
-  commands: [ make quicktests ]
----
-kind: pipeline
-name: arm64-checkperf
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: checkperf
-  image: gcc:8
+- name: Build and Test
+  image: conanio/clang9
+  user: root
   environment:
-    CHECKPERF_REPOSITORY: https://github.com/lemire/simdjson
-  commands: [ cat /proc/cpuinfo, make checkperf ]
+    CC: clang-9
+    CXX: clang++-9
+    BUILD_FLAGS: -- -j 4
+    CMAKE_FLAGS: -GNinja -DSIMDJSON_BUILD_STATIC=ON
+    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
-
-platform:
-  os: linux
-  arch: arm64
-
+name: libcpp-clang9
+platform: { os: linux, arch: amd64 }
 steps:
-- name: build
-  image: gcc:8
-  commands: [ make, make amalgamate ]
----
-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
+- name: Build and Test
+  image: conanio/clang9
+  user: root
   environment:
-    SIMDJSON_TEST_AMALGAMATED_HEADERS: 1
-  commands: [ make amalgamate, make ]
+    CC: clang-9
+    CXX: clang++-9
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
+    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
-
-platform:
-  os: linux
-  arch: amd64
-
+name: libcpp-clang7
+platform: { os: linux, arch: amd64 }
 steps:
-- name: quicktests
-  image: gcc:8
+- name: Build and Test
+  image: conanio/clang7
+  user: root
   environment:
-    SIMDJSON_TEST_AMALGAMATED_HEADERS: 1
-  commands: [ make amalgamate, make quicktests ]
+    CC: clang-7
+    CXX: clang++-7
+    BUILD_FLAGS: -- -j
+    CMAKE_FLAGS: -DSIMDJSON_BUILD_STATIC=ON
+    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
-
-platform:
-  os: linux
-  arch: amd64
-
+name: noexceptions-gcc9
+platform: { os: linux, arch: amd64 }
 steps:
-- name: slowtests
-  image: gcc:8
+- name: Build and Test
+  image: gcc:9
   environment:
-    SIMDJSON_TEST_AMALGAMATED_HEADERS: 1
-  commands: [ make amalgamate, make slowtests ]
+    CC: gcc
+    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 --quiet https://dl.bintray.com/pauldreik/simdjson-fuzz-corpus/corpus/corpus.tar
+    - tar xf corpus.tar && rm corpus.tar
+    - 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 +460,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

.gitattributes

@@ -80,15 +80,15 @@
 .gitignore     export-ignore
 
 # Sources
-*.c     text diff=c
-*.cc    text diff=cpp
-*.cxx   text diff=cpp
-*.cpp   text diff=cpp
-*.c++   text diff=cpp
-*.hpp   text diff=cpp
-*.h     text diff=c
-*.h++   text diff=cpp
-*.hh    text diff=cpp
+*.c     text eol=lf diff=c
+*.cc    text eol=lf diff=cpp
+*.cxx   text eol=lf diff=cpp
+*.cpp   text eol=lf diff=cpp
+*.c++   text eol=lf diff=cpp
+*.hpp   text eol=lf diff=cpp
+*.h     text eol=lf diff=c
+*.h++   text eol=lf diff=cpp
+*.hh    text eol=lf diff=cpp
 
 # Compiled Object files
 *.slo   binary

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,41 @@
+---
+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: https://github.com/simdjson/simdjson/blob/master/doc/basics.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).
+
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+Note that a compiler warning is not a bug.
+
+**To Reproduce**
+Steps to reproduce the behaviour: provide a code sample if possible.
+
+If we cannot reproduce the issue, then we cannot address it.
+
+Note that a stack trace from your own program is not enough.
+
+**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]
+
+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. In particular, we do not support legacy 32-bit systems.
+
+**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
+* 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/feature_request.md

@@ -0,0 +1,37 @@
+---
+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: https://github.com/simdjson/simdjson/blob/master/doc/basics.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,32 @@
+---
+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: https://github.com/simdjson/simdjson/blob/master/doc/basics.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.
+
+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,8 @@
+
+
+Our tests check whether you have introduced trailing white space. If such a test fails, please check the "artifacts button" above, which if you click it gives a link to a downloadable file to help you identify the issue. You can also run scripts/remove_trailing_whitespace.sh locally if you have a bash shell and the sed command available on your system.
+
+If you plan to contribute to simdjson, please read our
+
+CONTRIBUTING guide: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md and our
+HACKING guide: https://github.com/simdjson/simdjson/blob/master/HACKING.md

.github/workflows/alpine.yml

@@ -0,0 +1,40 @@
+name: Alpine Linux
+
+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-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        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 -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"

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

@@ -0,0 +1,37 @@
+name: Detect trailing whitespace
+
+on:
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  whitespace:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - 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@v2
+        if: always()
+        with:
+          name: whitespace-patch
+          path: |
+            whitespace.patch
+          if-no-files-found: ignore
+

.github/workflows/fuzzers.yml

@@ -1,21 +1,33 @@
-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:    
+  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
-      artifactsprefix: -artifact_prefix=fuzzfailure/
+      # fuzzers that change behaviour with SIMDJSON_FORCE_IMPLEMENTATION
+      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: 11
+      # which optimization level to use for the sanitizer build (see build_fuzzer.variants.sh)
+      OPTLEVEL: -O3
+
     steps:
     - name: Install packages necessary for building
       run: |
@@ -23,105 +35,130 @@ jobs:
         sudo apt-get install --quiet ninja-build valgrind zip unzip
         wget https://apt.llvm.org/llvm.sh
         chmod +x llvm.sh
-        sudo ./llvm.sh 8
+        sudo ./llvm.sh $CLANGVERSION
 
     - uses: actions/checkout@v1
+
+    - uses: actions/cache@v2
+      with:
+        path: dependencies/.cache
+        key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+
     - name: Create and prepare the initial seed corpus
       run: |
         fuzz/build_corpus.sh
         mv corpus.zip seed_corpus.zip
+        mkdir seedcorpus
+        unzip -q -d seedcorpus seed_corpus.zip
+
     - name: Download the corpus from the last run
       run: |
         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
-    - name: Verify that the oss-fuzz seed corpus passes without problems
+      run: CLANGSUFFIX=-$CLANGVERSION fuzz/build_fuzzer_variants.sh
+
+    - name: Explore fast (release build, default implementation)
       run: |
-        mkdir seedcorpus
-        unzip -q -d seedcorpus seed_corpus.zip
-        for buildvariant in noavx withavx; do
-          for fuzzer in $allfuzzers; do
-            build-ossfuzz-$buildvariant/fuzz/fuzz_$fuzzer seedcorpus -max_total_time=1
-          done
-        done
-    - name: Run the fastest fuzzer to explore fast
-      run: |
-        for fuzzer in $allfuzzers; do
+        set -eux
+        for fuzzer in $defaultimplfuzzers $implfuzzers; 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
+          # 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 out/$fuzzer $others seedcorpus -max_total_time=30 $MAXLEN
         done
-    - name: Run the other fuzzer variants for $fuzzer, with sanitizers etc
+
+    - name: Fuzz default impl. fuzzers with sanitizer+asserts (good at detecting errors)
       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
+        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
           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@v2
       with:
         name: corpus
         path: corpus.tar
-    - name: Run the corpus through valgrind (normal 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      
-          find out/$fuzzer -type f |sort|xargs valgrind build-plain-noavx/fuzz/fuzz_$fuzzer  2>&1|tee valgrind-$fuzzer-noavx.txt
-        done
-    - name: Run the corpus through valgrind (noavx build)
-      run: |
-        for fuzzer in $allfuzzers; do      
-          find out/$fuzzer -type f |sort|xargs valgrind build-plain-normal/fuzz/fuzz_$fuzzer 2>&1|tee valgrind-$fuzzer-normal.txt      
-        done  
+        for fuzzer in $defaultimplfuzzers $implfuzzers; do
+          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@v2
+      if: always()
       with:
         name: valgrindresults
         path: valgrind.tar
+        if-no-files-found: ignore
+
     - name: Upload the corpus and results to bintray if we are on master
+      if: ${{ github.event_name == 'schedule' }} 
       run: |
-        if [ $(git rev-parse --verify HEAD) = $(git rev-parse --verify origin/master) ] ; then
-          echo uploading each artifact twice, otherwise it will not be published
-          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"
-          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"
-          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"
-          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"
-        else
-          echo "not on master, won't upload to bintray"
-        fi
+        echo uploading each artifact twice, otherwise it will not be published
+        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"
+        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"
+        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"
+        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: Archive any crashes as an artifact
+      uses: actions/upload-artifact@v2
+      if: always()
+      with:
+        name: crashes
+        path: |
+          crash-*
+          leak-*
+          timeout-*
+        if-no-files-found: ignore

.github/workflows/mingw-ci.yml

@@ -0,0 +1,68 @@
+name: MinGW32-CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+# Important: scoop will either install 32-bit GCC or 64-bit GCC, not both.
+
+# It is important to build static libraries because cmake is not smart enough under Windows/mingw to take care of the path. So
+# with a dynamic library, you could get failures due to the fact that the EXE can't find its DLL.
+
+jobs:
+  ci:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    name: windows-gcc
+    runs-on: windows-2016
+
+    env:
+      CMAKE_GENERATOR: Ninja # This is critical, try ' cmake  -GNinja-DSIMDJSON_BUILD_STATIC=ON .. ' if using the command line
+      CC: gcc
+      CXX: g++
+
+    steps: # To reproduce what is below, start a powershell with administrative rights, using scoop *is* a good idea
+      - uses: actions/checkout@v2
+
+      - uses: actions/cache@v2 # we cache the scoop setup with 32-bit GCC
+        id: cache
+        with:
+          path: |
+            C:\ProgramData\scoop
+          key: scoop32 # static key: should be good forever
+
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+
+      - name: Setup Windows # This should almost never run if the cache works.
+        if: steps.cache.outputs.cache-hit != 'true'
+        shell: powershell
+        run: |
+          Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh')
+          scoop install sudo --global
+          sudo scoop install git --global 
+          sudo scoop install ninja --global
+          sudo scoop install cmake --global
+          sudo scoop install gcc --arch 32bit --global
+          $env:path
+          Write-Host 'Everything has been installed, you are good!'
+      - name: Build and Test 32-bit x86
+        shell: powershell
+        run: |
+          $ENV:PATH="C:\ProgramData\scoop\shims;C:\ProgramData\scoop\apps\gcc\current\bin;C:\ProgramData\scoop\apps\ninja\current;$ENV:PATH"
+          g++ --version
+          cmake --version
+          ninja --version
+          git --version
+          mkdir build32
+          cd build32
+          cmake -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_COMPETITION=OFF -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_ENABLE_THREADS=OFF ..
+          cmake --build . --target acceptance_tests --verbose
+          ctest -L acceptance --output-on-failure

.github/workflows/mingw64-ci.yml

@@ -0,0 +1,74 @@
+name: MinGW64-CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+# Important: scoop will either install 32-bit GCC or 64-bit GCC, not both.
+
+# It is important to build static libraries because cmake is not smart enough under Windows/mingw to take care of the path. So
+# with a dynamic library, you could get failures due to the fact that the EXE can't find its DLL.
+
+jobs:
+  ci:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    name: windows-gcc
+    runs-on: windows-2016
+
+    env:
+      CMAKE_GENERATOR: Ninja # This is critical, try ' cmake  -GNinja-DSIMDJSON_BUILD_STATIC=ON .. ' if using the command line
+      CC: gcc
+      CXX: g++
+
+    steps: # To reproduce what is below, start a powershell with administrative rights, using scoop *is* a good idea
+      - uses: actions/checkout@v2
+
+      - uses: actions/cache@v2 # we cache the scoop setup with 64-bit GCC
+        id: cache
+        with:
+          path: |
+            C:\ProgramData\scoop
+          key: scoop64 # static key: should be good forever
+
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+
+      - name: Setup Windows # This should almost never run if the cache works.
+        if: steps.cache.outputs.cache-hit != 'true'
+        shell: powershell
+        run: |
+          Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh')
+          scoop install sudo --global
+          sudo scoop install git --global
+          sudo scoop install ninja --global
+          sudo scoop install cmake --global
+          sudo scoop install gcc --arch 64bit --global
+          $env:path
+          Write-Host 'Everything has been installed, you are good!'
+      - name: Build and Test 64-bit x64
+        shell: powershell
+        run: |
+          $ENV:PATH="C:\ProgramData\scoop\shims;C:\ProgramData\scoop\apps\gcc\current\bin;C:\ProgramData\scoop\apps\ninja\current;$ENV:PATH"
+          g++ --version
+          cmake --version
+          ninja --version
+          git --version
+          mkdir build64
+          cd build64
+          cmake -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_COMPETITION=OFF -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_ENABLE_THREADS=OFF ..
+          cmake --build . --target acceptance_tests --verbose
+          ctest -L acceptance --output-on-failure
+          cd ..
+          mkdir build64debug
+          cd build64debug
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_COMPETITION=OFF -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_ENABLE_THREADS=OFF ..
+          cmake --build . --target acceptance_tests --verbose
+          ctest -L acceptance --output-on-failure

.github/workflows/msys2-clang.yml

@@ -0,0 +1,54 @@
+name: MSYS2-CLANG-CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+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-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
+            type: Release
+          - msystem: "MINGW32"
+            install: mingw-w64-i686-cmake mingw-w64-i686-ninja mingw-w64-i686-clang
+            type: Release
+          - msystem: "MINGW64"
+            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
+            type: Debug
+          - msystem: "MINGW32"
+            install: mingw-w64-i686-cmake mingw-w64-i686-ninja mingw-w64-i686-clang
+            type: Debug
+    env:
+      CMAKE_GENERATOR: Ninja
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        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 -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_BUILD_TYPE=${{ matrix.type }} -DSIMDJSON_BUILD_STATIC=ON -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,57 @@
+name: MSYS2-CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+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: "MINGW32"
+            install: mingw-w64-i686-cmake mingw-w64-i686-ninja mingw-w64-i686-gcc
+            type: Release
+          - msystem: "MINGW64"
+            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
+            type: Debug
+          - msystem: "MINGW32"
+            install: mingw-w64-i686-cmake mingw-w64-i686-ninja mingw-w64-i686-gcc
+            type: Debug
+    env:
+      CMAKE_GENERATOR: Ninja
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        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 -DCMAKE_BUILD_TYPE=${{ matrix.type }} -DSIMDJSON_BUILD_STATIC=ON -DSIMDJSON_DO_NOT_USE_THREADS_NO_MATTER_WHAT=ON ..
+          cmake --build . --verbose
+          ctest -j4 --output-on-failure -LE explicitonly

.github/workflows/power-fuzz.yml

@@ -0,0 +1,65 @@
+name: short fuzz on the power arch
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  armv7_job:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    # The host should always be Linux
+    runs-on: ubuntu-20.04
+    name: Build on ubuntu-20.04 ppc64le
+    steps:
+      - uses: actions/checkout@v2.1.0
+      - uses: uraimo/run-on-arch-action@v2.0.5
+        name: Run commands
+        id: runcmd
+        env:
+          DEBIAN_FRONTEND: noninteractive
+        with:
+          arch: ppc64le
+          distro: buster
+
+          # Not required, but speeds up builds by storing container images in
+          # a GitHub package registry.
+          githubToken: ${{ github.token }}
+
+          run: |
+            export CLANGSUFFIX="-7"
+            apt-get -qq update
+            apt-get install -q -y clang-7 libfuzzer-7-dev cmake git wget zip ninja-build
+            mkdir -p build ; cd build
+            cmake .. -GNinja \
+                  -DCMAKE_CXX_COMPILER=clang++$CLANGSUFFIX \
+                  -DCMAKE_C_COMPILER=clang$CLANGSUFFIX \
+                  -DSIMDJSON_BUILD_STATIC=Off \
+                  -DENABLE_FUZZING=On \
+                  -DSIMDJSON_COMPETITION=OFF \
+                  -DSIMDJSON_GOOGLE_BENCHMARKS=OFF \
+                  -DSIMDJSON_DISABLE_DEPRECATED_API=On \
+                  -DSIMDJSON_FUZZ_LDFLAGS=-lFuzzer \
+                  -DCMAKE_CXX_FLAGS="-fsanitize=fuzzer-no-link -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=" \
+                  -DCMAKE_C_FLAGS="-fsanitize=fuzzer-no-link" \
+                  -DCMAKE_BUILD_TYPE=Release \
+                  -DSIMDJSON_FUZZ_LINKMAIN=Off
+            cd ..
+            builddir=build
+            cmake --build $builddir
+            wget --quiet https://dl.bintray.com/pauldreik/simdjson-fuzz-corpus/corpus/corpus.tar
+            tar xf corpus.tar && rm corpus.tar
+            fuzzernames=$(cmake --build $builddir --target print_all_fuzzernames |tail -n1)
+            for fuzzer in $fuzzernames ; do
+               exe=$builddir/fuzz/$fuzzer
+               shortname=$(echo $fuzzer |cut -f2- -d_)
+               echo found fuzzer $shortname with executable $exe
+               mkdir -p out/$shortname
+               others=$(find out -type d -not -name $shortname -not -name out -not -name cmin)
+               $exe -max_total_time=20  -max_len=4000 out/$shortname $others
+               echo "*************************************************************************"
+            done
+            echo "all is good, no errors found in any of these fuzzers: $fuzzernames"

.github/workflows/ubuntu18-checkperf.yml

@@ -0,0 +1,29 @@
+name: Performance check on Ubuntu 18.04 CI (GCC 7)
+
+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-18.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_BUILD_STATIC=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build . --target checkperf  &&
+          ctest --output-on-failure -R checkperf  ubuntu18-checkperf.yml

.github/workflows/ubuntu18-threadsani.yml

@@ -0,0 +1,30 @@
+name: Ubuntu 18.04 CI (GCC 7) with Thread Sanitizer
+
+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-18.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_SANITIZE_THREADS=ON ..  &&
+          cmake --build . --target 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/ubuntu18.yml

@@ -0,0 +1,31 @@
+name: Ubuntu 18.04 CI (GCC 7)
+
+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-18.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_BUILD_STATIC=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
+          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

.github/workflows/ubuntu20-checkperf.yml

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

.github/workflows/ubuntu20-noexcept.yml

@@ -0,0 +1,34 @@
+name: Ubuntu 20.04 CI (GCC 9) without exceptions
+
+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-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_EXCEPTIONS=OFF -DSIMDJSON_BUILD_STATIC=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
+          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.1)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .

.github/workflows/ubuntu20-nothread.yml

@@ -0,0 +1,34 @@
+name: Ubuntu 20.04 CI (GCC 9) without threads
+
+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-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_ENABLE_THREADS=OFF -DSIMDJSON_BUILD_STATIC=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
+          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.1)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .

.github/workflows/ubuntu20-threadsani.yml

@@ -0,0 +1,30 @@
+name: Ubuntu 20.04 CI (GCC 9) with Thread Sanitizer
+
+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-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_SANITIZE_THREADS=ON ..  &&
+          cmake --build . --target 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/ubuntu20.yml

@@ -0,0 +1,33 @@
+name: Ubuntu 20.04 CI (GCC 9)
+
+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-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_BUILD_STATIC=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
+          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/vs15-ci.yml

@@ -0,0 +1,46 @@
+name: VS15-CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ci:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    name: windows-vs15
+    runs-on: windows-2016
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {gen: Visual Studio 15 2017, arch: Win32, static: ON}
+          - {gen: Visual Studio 15 2017, arch: Win32, static: OFF}
+          - {gen: Visual Studio 15 2017, arch: x64, static: ON}
+          - {gen: Visual Studio 15 2017, arch: x64, static: OFF}
+    steps:
+    - name: checkout
+      uses: actions/checkout@v2
+    - name: Configure
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_COMPETITION=OFF -DSIMDJSON_BUILD_STATIC=${{matrix.static}} -B build
+    - name: Build Debug
+      run: cmake --build build --config Debug --verbose
+    - name: Build Release
+      run: cmake --build build --config Release --verbose
+    - name: Run tests
+      run: |
+        cd build
+        ctest -C Release  -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/vs16-ci.yml

@@ -0,0 +1,46 @@
+name: VS16-CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ci:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    name: windows-vs16
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {gen: Visual Studio 16 2019, arch: Win32, static: ON}
+          - {gen: Visual Studio 16 2019, arch: Win32, static: OFF}
+          - {gen: Visual Studio 16 2019, arch: x64, static: ON}
+          - {gen: Visual Studio 16 2019, arch: x64, static: OFF}
+    steps:
+    - name: checkout
+      uses: actions/checkout@v2
+    - name: Configure
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_COMPETITION=OFF -DSIMDJSON_BUILD_STATIC=${{matrix.static}} -B build
+    - name: Build Debug
+      run: cmake --build build --config Debug --verbose
+    - name: Build Release
+      run: cmake --build build --config Release --verbose
+    - name: Run tests
+      run: |
+        cd build
+        ctest -C Release  -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/vs16-clang-ci.yml

@@ -0,0 +1,37 @@
+name: VS16-CLANG-CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ci:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    name: windows-vs16
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/cache@v2
+      with:
+        path: dependencies/.cache
+        key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+    - name: 'Run CMake with VS16 Clang'
+      uses: lukka/run-cmake@v3
+      with:
+        cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+        cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
+        buildDirectory: "${{ github.workspace }}/../../_temp/windows"
+        cmakeBuildType: Release
+        buildWithCMake: true
+        cmakeAppendedArgs:  -T ClangCL -DSIMDJSON_COMPETITION=OFF  -DSIMDJSON_BUILD_STATIC=ON
+        buildWithCMakeArgs: --config Release
+    
+    - name: 'Run CTest'
+      run: ctest -C Release -LE explicitonly  --output-on-failure
+      working-directory: "${{ github.workspace }}/../../_temp/windows"

.github/workflows/vs16-ninja-ci.yml

@@ -0,0 +1,51 @@
+name: VS16-Ninja-CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ci:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    name: windows-vs16
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/cache@v2
+      with:
+        path: dependencies/.cache
+        key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+    - name: 'Run CMake with VS16'
+      uses: lukka/run-cmake@v2
+      with:
+        cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+        cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
+        buildDirectory: "${{ github.workspace }}/../../_temp/windows"
+        cmakeBuildType: Release
+        buildWithCMake: true
+        cmakeAppendedArgs:  -G Ninja -DSIMDJSON_COMPETITION=OFF   -DSIMDJSON_BUILD_STATIC=ON
+        buildWithCMakeArgs: --config Release
+    - name: 'Run CTest'
+      run: ctest -C Release  -LE explicitonly  --output-on-failure
+      working-directory: "${{ github.workspace }}/../../_temp/windows"
+    - name: 'Install with CMake'
+      uses: lukka/run-cmake@v3
+      with:
+        cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
+        buildWithCMakeArgs: '--target install'
+    - name: 'Test Installation with CMake'
+      uses: lukka/run-cmake@v3
+      with:
+        cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+        cmakeListsTxtPath: '${{ github.workspace }}/tests/installation_tests/find/CMakeLists.txt'
+        cmakeBuildType: Release
+        buildWithCMake: true
+        buildDirectory: '${{ github.workspace }}/tests/installation_tests/find/buildDirectory'
+        cmakeAppendedArgs:  -G Ninja
+        buildWithCMakeArgs: '--config Release --verbose'

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

@@ -0,0 +1,36 @@
+name: VS16-NoExcept-CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  ci:
+    name: windows-vs16
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/cache@v2
+      with:
+        path: dependencies/.cache
+        key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+    - name: 'Run CMake with VS16'
+      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_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
@@ -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,17 @@ 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

.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,188 @@
 language: cpp
-sudo: false
-addons:
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-    packages:
-      - gcc-7
-      - g++-7
-      - clang-format
-      - python
-branches:
-  only:
-    - master
 
-script: 
-   - export CXX=g++-7
-   - export CC=gcc-7
-   - make
-   - make test 
-   - make everything
-   - make amalgamate
-   - make clean
-   - 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/
+dist: bionic
 
+arch:
+  - ppc64le
+
+cache:
+  directories:
+    - $HOME/.dep_cache
+
+env:
+  global:
+    - 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
+
+    - 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
+
+    - 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} -DSIMDJSON_BUILD_STATIC=ON";
+    fi
+  - export CTEST_FLAGS="-j4 --output-on-failure -LE explicitonly"
+
+script:
+  - mkdir build
+  - cd build
+  - cmake $CMAKE_FLAGS ..
+  - cmake --build . -- -j2
+  - SIMDJSON_FORCE_IMPLEMENTATION=ppc64 ctest $CTEST_FLAGS -L per_implementation
+  - SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation
+  - ctest $CTEST_FLAGS -LE "acceptance|per_implementation"

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,90 +1,93 @@
-cmake_minimum_required(VERSION 3.9) # CMP0069 NEW
-
-if (NOT CMAKE_BUILD_TYPE)
-  message(STATUS "No build type selected, default to Release")
-  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
-endif()
-
+cmake_minimum_required(VERSION 3.13)
+# CMP0025: Compiler id for Apple Clang is now AppleClang.
+# https://cmake.org/cmake/help/v3.17/policy/CMP0025.html
+cmake_policy(SET CMP0025 NEW)
 project(simdjson
   DESCRIPTION "Parsing gigabytes of JSON per second"
-  LANGUAGES CXX
+  LANGUAGES CXX C
 )
 
-# LTO seems to create all sorts of fun problems. Let us
-# disable temporarily.
-#include(CheckIPOSupported)
-#check_ipo_supported(RESULT ltoresult)
-#if(ltoresult)
-#  set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
-#endif()
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_MACOSX_RPATH OFF)
-set(CMAKE_THREAD_PREFER_PTHREAD ON)
-set(THREADS_PREFER_PTHREAD_FLAG ON)
-
-set(SIMDJSON_LIB_NAME simdjson)
 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")
+set(PROJECT_VERSION_MINOR 9)
+set(PROJECT_VERSION_PATCH 0)
+set(SIMDJSON_SEMANTIC_VERSION "0.9.0" CACHE STRING "simdjson semantic version")
+set(SIMDJSON_LIB_VERSION "8.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "8" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_GITHUB_REPOSITORY https://github.com/simdjson/simdjson)
 
-option(SIMDJSON_IMPLEMENTATION_HASWELL "Include the haswell implementation" ON)
-option(SIMDJSON_IMPLEMENTATION_WESTMERE "Include the westmere implementation" ON)
-option(SIMDJSON_IMPLEMENTATION_ARM64 "Include the arm64 implementation" ON)
-option(SIMDJSON_IMPLEMENTATION_FALLBACK "Include the fallback implementation" ON)
-if(NOT MSVC)
-  option(SIMDJSON_BUILD_STATIC "Build a static library" OFF) # turning it on disables the production of a dynamic library
-else()
-  option(SIMDJSON_BUILD_STATIC "Build a static library" ON) # turning it on disables the production of a dynamic library
-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)
+include(GNUInstallDirs)
+include(cmake/simdjson-flags.cmake)
+include(cmake/simdjson-user-cmakecache.cmake)
 
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/tools/cmake")
 
-find_package(CTargets)
-find_package(Options)
 
-# We used to have install(DIRECTORY include/${SIMDJSON_LIB_NAME} DESTINATION include)
-# alone.
-# However, this fails because we also need the root level simdjson.h file.
-install(DIRECTORY include/${SIMDJSON_LIB_NAME} DESTINATION include)
-install(FILES include/${SIMDJSON_LIB_NAME}.h DESTINATION include)
-set (TEST_DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/jsonchecker/")
-set (BENCHMARK_DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/jsonexamples/")
-add_definitions(-DSIMDJSON_TEST_DATA_DIR="${TEST_DATA_DIR}")
-add_definitions(-DSIMDJSON_BENCHMARK_DATA_DIR="${TEST_DATA_DIR}")
-enable_testing()
-include(include/CMakeLists.txt)
+if(SIMDJSON_JUST_LIBRARY)
+  message( STATUS "Building just the library, omitting all tests, tools and benchmarks." )
+else(SIMDJSON_JUST_LIBRARY)
+  # Setup tests
+  enable_testing()
+  add_subdirectory(jsonchecker)
+  add_subdirectory(jsonexamples)
+  add_library(test-data INTERFACE)
+  target_link_libraries(test-data INTERFACE jsonchecker-data jsonchecker-minefield-data jsonexamples-data)
+endif(SIMDJSON_JUST_LIBRARY)
+
+# Create the top level simdjson library (must be done at this level to use both src/ and include/
+# directories) and tools
+#
+add_subdirectory(include)
 add_subdirectory(src)
-add_subdirectory(tools)
-add_subdirectory(tests)
-add_subdirectory(benchmark)
-
-if (SIMDJSON_GOOGLE_BENCHMARKS)
-  if(NOT EXISTS dependencies/benchmark/CMakeLists.txt)
-    # message(STATUS "Unable to find dependencies/benchmark/CMakeLists.txt")
-    execute_process(COMMAND git submodule update --init -- dependencies/benchmark
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-  endif()
-  option(BENCHMARK_ENABLE_TESTING OFF)
-  set(BENCHMARK_ENABLE_TESTING OFF)
-  option(BENCHMARK_ENABLE_INSTALL OFF)
-  set(BENCHMARK_ENABLE_INSTALL OFF)
-  add_subdirectory(dependencies/benchmark)
+add_subdirectory(windows)
+if(NOT(SIMDJSON_JUST_LIBRARY))
+  add_subdirectory(dependencies) ## This needs to be before tools because of cxxopts
+  add_subdirectory(tools)  ## This needs to be before tests because of cxxopts
+  add_subdirectory(singleheader)
 endif()
+install(FILES singleheader/simdjson.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 
-# for fuzzing, read the comments in the fuzz/CMakeLists.txt file
-option(ENABLE_FUZZING "enable building the fuzzers" ON)
-if(ENABLE_FUZZING)
+option(SIMDJSON_ENABLE_THREADS "Link with thread support" ON)
+include(CMakePackageConfigHelpers)
+configure_package_config_file("${PROJECT_SOURCE_DIR}/cmake/simdjson-config.cmake.in"
+      "${PROJECT_BINARY_DIR}/simdjson-config.cmake"
+      INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/simdjson"
+      NO_SET_AND_CHECK_MACRO
+      NO_CHECK_REQUIRED_COMPONENTS_MACRO)
+write_basic_package_version_file(
+      "${PROJECT_BINARY_DIR}/simdjson-config-version.cmake"
+      VERSION ${SIMDJSON_SEMANTIC_VERSION}
+      COMPATIBILITY SameMinorVersion)
+install(FILES "${PROJECT_BINARY_DIR}/simdjson-config.cmake"
+              "${PROJECT_BINARY_DIR}/simdjson-config-version.cmake"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/simdjson")
+
+#
+# Compile tools / tests / benchmarks
+#
+if(NOT(SIMDJSON_JUST_LIBRARY))
+  add_subdirectory(tests)
+  add_subdirectory(examples)
+  add_subdirectory(benchmark)
   add_subdirectory(fuzz)
 endif()
 
+#
+# Source files should be just ASCII
+#
+find_program(FIND find)
+find_program(FILE file)
+find_program(GREP grep)
+if((FIND) AND (FILE) AND (GREP))
+    add_test(
+      NAME "just_ascii"
+      COMMAND sh -c "${FIND}  include src windows tools singleheader tests examples benchmark -path benchmark/checkperf-reference -prune -name '*.h'  -o -name '*.cpp' -type f  -exec ${FILE} '{}' \; |${GREP} -v ASCII || exit 0  && exit 1"
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+endif()
+
+
+#
+# CPack
+#
 set(CPACK_PACKAGE_VENDOR "Daniel Lemire")
 set(CPACK_PACKAGE_CONTACT "lemire@gmail.com")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Parsing gigabytes of JSON per second")
@@ -99,5 +102,3 @@ set(CPACK_RPM_PACKAGE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
 set(CPACK_SOURCE_GENERATOR "TGZ;ZIP")
 
 include(CPack)
-
-

CONTRIBUTING.md

@@ -5,7 +5,7 @@ The simdjson library is an open project written in C++. Contributions are invite
 agree to the project's license.
 
 We have an extensive list of issues, and contributions toward any of these issues is invited.
-Contributions can take the form of code samples, better documentation or design ideas. 
+Contributions can take the form of code samples, better documentation or design ideas.
 
 In particular, the following contributions are invited:
 
@@ -32,7 +32,21 @@ 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 :
@@ -43,11 +57,43 @@ Contributors are encouraged to :
 - 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.
 - Provide tests for any new feature. We will not merge a new feature without tests.
 
+Pull Requests
+--------------
+
+Pull requests are always invited. However, we ask that you follow these guidelines:
+
+- It is wiser to discuss your ideas first as part of an issue before you start coding. If you omit this step and code first, be prepare 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 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 be 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 of new tests, in general.
+- Your code should pass our continuous-integration tests. It is your responsability 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 discusssed 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
 -----------------------

CONTRIBUTORS

@@ -31,5 +31,10 @@ Paul Dreik
 Jeremie Piotte
 Matthew Wilson
 Dušan Jovanović
+Matjaž Ostroveršnik
+Nong Li
+Furkan Taşkale
+Brendan Knapp
+Danila Kutenin
 # if you have contributed to the project and your name does not 
 # appear in this list, please let us know!

Dockerfile

@@ -1,10 +1,88 @@
-# 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"]
+###
+#
+# Though simdjson requires only commonly available compilers and tools, it can
+# be convenient to build it and test it inside a docker container: it makes it
+# possible to test and benchmark simdjson under even relatively out-of-date
+# Linux servers. It should also work under macOS and Windows, though not
+# at native speeds, maybe.
+#
+# Assuming that you have a working docker server, this file
+# allows you to build, test and benchmark simdjson.
+#
+#  We build the library and associated files in the dockerbuild subdirectory.
+# It may be necessary to delete it before creating the image:
+#
+# rm -r -f dockerbuild
+#
+# The need to delete the directory has nothing to do with docker per se: it is
+# simply cleaner in CMake to start from a fresh directory. This is important: if you
+# reuse the same directory with different configurations, you may get broken builds.
+#
+#
+# Then you can build the image as follows:
+#
+# docker build -t simdjson --build-arg USER_ID=$(id -u)  --build-arg GROUP_ID=$(id -g) .
+#
+# Please note that the image does not contain a copy of the code. However, the image will contain the
+# the compiler and the build system. This means that if you change the source code, after you have built
+# the image, you won't need to rebuild the image. In fact, unless you want to try a different compiler, you
+# do not need to ever rebuild the image, even if you do a lot of work on the source code.
+#
+# We specify the users to avoid having files owned by a privileged user (root) in our directory. Some
+# people like to run their machine as the "root" user. We do not think it is cool.
+#
+# Then you need to build the project:
+#
+# docker run  -v $(pwd):/project:Z  simdjson
+#
+# Should you change a source file, you may need to call this command again. Because the output
+# files are persistent between calls to this command (they reside in the dockerbuild directory),
+# this command can be fast.
+#
+# Next you can test it as follows:
+#
+# docker run -it -v $(pwd):/project:Z   simdjson sh -c "cd dockerbuild && ctest . --output-on-failure -LE explicitonly"
+#
+# The run the complete tests requires you to have built all of simdjson.
+#
+# Building all of simdjson takes a long time. Instead, you can build just one target:
+#
+# docker run -it -v $(pwd):/project:Z  simdjson sh -c "[ -d dockerbuild ] || mkdir dockerbuild && cd dockerbuild && cmake ..  && cmake --build . --target parse"
+#
+# Note that it is safe to remove dockerbuild before call the previous command, as the repository gets rebuild. It is also possible, by changing the command, to use a different directory name.
+#
+# You can run performance tests:
+#
+# docker run -it --privileged -v $(pwd):/project:Z  simdjson sh -c "cd dockerbuild && for i in ../jsonexamples/*.json; do echo \$i; ./benchmark/parse \$i;  done"
+#
+# The "--privileged" is recommended so you can get performance counters under Linux.
+#
+# You can also grab a fresh copy of simdjson and rebuild it, to make comparisons:
+#
+# docker run -it -v $(pwd):/project:Z  simdjson sh -c "git clone https://github.com/simdjson/simdjson.git && cd simdjson && mkdir build && cd build && cmake .. && cmake --build . --target parse "
+#
+# Then you can run comparisons:
+#
+# docker run -it --privileged -v $(pwd):/project:Z  simdjson sh -c "for i in jsonexamples/*.json; do echo \$i; dockerbuild/benchmark/parse \$i| grep GB| head -n 1; simdjson/build/benchmark/parse \$i | grep GB |head -n 1;  done"
+#
+####
+FROM ubuntu:20.10
+################
+# We would prefer to use the conan io images but they do not support 64-bit ARM? The small gcc images appear to
+# be broken on ARM.
+# Furthermore, we would not expect users to frequently rebuild the container, so using ubuntu is probably fine.
+###############
+ARG USER_ID
+ARG GROUP_ID
+RUN apt-get update -qq
+RUN DEBIAN_FRONTEND="noninteractive" apt-get -y install tzdata
+RUN apt-get install -y cmake g++ git
+RUN mkdir project
+
+RUN addgroup --gid $GROUP_ID user; exit 0
+RUN adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID user; exit 0
+USER user
+RUN gcc --version
+WORKDIR /project
+
+CMD ["sh","-c","[ -d dockerbuild ] || mkdir dockerbuild && cd dockerbuild && cmake .. && cmake --build . "]

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         = "0.9.0"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -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
 
 # 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

HACKING.md

@@ -1,33 +1,63 @@
 Hacking simdjson
 ================
 
-Here is wisdom about how to build, test and run simdjson from within the repository. *Users* of
-simdjson should use the released simdjson.h and simdjson.cpp files.
+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.
+
+If you plan to contribute to simdjson, please read our [CONTRIBUTING](https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md) guide.
+
+
+Design notes
+------------------------------
+
+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.
+
+
+The role of stage 1 is to identify pseudo-structural characters as quickly as possible. 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 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 }
+
+Stage 1 also does unicode validation.
+
+Stage 2 handles all of the rest: number parsings, recognizing atoms like true, false, null, and so forth.
+
 
 Directory Structure and Source
 ------------------------------
 
 simdjson's source structure, from the top level, looks like this:
 
-* **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.
+* **CMakeLists.txt:** The main build system.
 * **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
+  * simdjson.h: 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/inline/*.h: Definitions for public simdjson classes and functions.
+  * simdjson/*-inl.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
+  * simdjson.cpp: A "main 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 
+  * arm64/|fallback/|haswell/|ppc64/|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"
+    namespace simdjson {
+      namespace haswell {
+        #include "generic/stage1/json_structural_indexer.h"
+      }
     }
     ```
 
@@ -35,91 +65,144 @@ 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.
+* **.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).
 * **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:
+  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, unnnecessary system calls. We recommend checking the performance as follows:
   ```bash
-  make parse && ./parse jsonexamples/twitter.json
+  mkdir build
+  cd build
+  cmake ..
+  cmake --build . --config Release
+  benchmark/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 ..
+  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 .. - TClangCL`.
+* **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.
-* **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
+* **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.
+
 
 > **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
+multiple files under include/ and src/. The files include/simdjson.h and src/simdjson.cpp are the "spine" for
+these, and you can include them as if they were the corresponding singleheader/ files.
 
-Regenerating Single Headers From Master
+
+
+Runtime Dispatching
+--------------------
+
+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 responsability, 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
 ---------------------------------------
 
-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:
+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
-make amalgamate
+mkdir build
+cd build
+cmake ..
+cmake --build . # needed, because currently dependencies do not work fully for the amalgamate target
+cmake --build . --target amalgamate
 ```
 
-The amalgamator is at `amalgamation.sh` at the top level. It generates singleheader/simdjson.h by
+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 (old-school Makefile on platforms like Linux or macOS)
+### Usage (CMake on 64-bit platforms like Linux, FreeBSD or macOS)
 
-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:
-
-```
-make
-make test
-```
-
-To run benchmarks:
-
-```
-make parse
-./parse jsonexamples/twitter.json
-```
-
-Under Linux, the `parse` command gives a detailed analysis of the performance counters.
-
-To run comparative benchmarks (with other parsers):
-
-```
-make benchmark
-```
-
-### 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
+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
 ```
 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:
-
+2. Under Linux, you might be able to install CMake as follows:
 ```
-brew install gcc@8
+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
 ```
 
-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`.
+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:
 
@@ -127,8 +210,8 @@ Building: While in the project repository, do the following:
 mkdir build
 cd build
 cmake ..
-make
-make test
+cmake --build .
+ctest
 ```
 
 CMake will build a library. By default, it builds a shared library (e.g., libsimdjson.so on Linux).
@@ -139,11 +222,11 @@ You can build a static library:
 mkdir buildstatic
 cd buildstatic
 cmake -DSIMDJSON_BUILD_STATIC=ON ..
-make
-make test
+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 may proceed as follows:
+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
@@ -151,213 +234,50 @@ mkdir build
 cd build
 export CXX=g++-8 CC=gcc-8
 cmake ..
-make
-make test
+cmake --build .
+ctest
 ```
 
-### Usage (CMake on 64-bit Windows using Visual Studio)
+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$"`.
 
-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).
+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)
+
+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 `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 ..`.)
+- 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`.
 
-### 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.
+Though having Visual Studio installed is necessary, one can build simdjson using only cmake commands:
 
-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:
-  > 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.
-
-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
-
-### 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).
+- `mkdir build`
+- `cd build`
+- `cmake ..`
+- `cmake --build . -config Release`
 
 
-- [ZippyJSON](https://github.com/michaeleisel/zippyjson): Swift bindings for the simdjson project.
-- [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.
+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:
 
-### Tools
 
-- `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.
+- `mkdir build`
+- `cd build`
+- `cmake ..  -T ClangCL`
+- `cmake --build . -config Release`
 
-### In-depth comparisons
-
-If you want to see how a wide range of parsers validate a given JSON file:
-
-```
-make allparserscheckfile
-./allparserscheckfile myfile.json
-```
-
-For performance comparisons:
-
-```
-make parsingcompetition
-./parsingcompetition myfile.json
-```
-
-For broader comparisons:
-
-```
-make allparsingcompetition
-./allparsingcompetition myfile.json
-```
-
-Both the `parsingcompetition` and `allparsingcompetition` tools take a `-t` flag which produces
-a table-oriented output that can be conveniently parsed by other tools.
 
 ### 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 +291,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.

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,8 +1,9 @@
-[![Build Status](https://cloud.drone.io/api/badges/simdjson/simdjson/status.svg)](https://cloud.drone.io/simdjson/simdjson)
-[![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)
-[![][license img]][license]
+![Ubuntu 18.04 CI](https://github.com/simdjson/simdjson/workflows/Ubuntu%2018.04%20CI%20(GCC%207)/badge.svg)
+[![Ubuntu 20.04 CI](https://github.com/simdjson/simdjson/workflows/Ubuntu%2020.04%20CI%20(GCC%209)/badge.svg)](https://simdjson.org/plots.html)
+![VS16-CI](https://github.com/simdjson/simdjson/workflows/VS16-CI/badge.svg)
+![MinGW64-CI](https://github.com/simdjson/simdjson/workflows/MinGW64-CI/badge.svg)
+[![][license img]][license]  [![Doxygen Documentation](https://img.shields.io/badge/docs-doxygen-green.svg)](https://simdjson.org/api/0.9.0/index.html)
 
 simdjson : Parsing gigabytes of JSON per second
 ===============================================
@@ -10,13 +11,15 @@ simdjson : Parsing gigabytes of JSON per second
 <img src="images/logo.png" width="10%" 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.
-* **Easy:** First-class, easy to use API.
+* **Fast:** Over 4x faster than commonly used production-grade JSON parsers.
+* **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.
 
@@ -24,6 +27,7 @@ Table of Contents
 -----------------
 
 * [Quick Start](#quick-start)
+  * [On Demand](#on-demand)
 * [Documentation](#documentation)
 * [Performance results](#performance-results)
 * [Real-world usage](#real-world-usage)
@@ -36,25 +40,31 @@ Table of Contents
 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.
-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).
+0. Prerequisites: `g++` (version 7 or better) or `clang++` (version 6 or better), and a 64-bit
+   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.
+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).
+
    ```
    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++
-   #include "simdjson.h"
-   int main(void) {
-     simdjson::dom::parser parser;
-     simdjson::dom::element tweets = parser.load("twitter.json");
-     std::cout << tweets["search_metadata"]["count"] << " results." << std::endl;
-   }
+```c++
+#include "simdjson.h"
+using namespace simdjson;
+int main(void) {
+    ondemand::parser parser;
+    padded_string json = padded_string::load("twitter.json");
+    ondemand::document tweets = parser.iterate(json);
+    std::cout << uint64_t(tweets["search_metadata"]["count"]) << " results." << std::endl;
+}
+
    ```
-3. `c++ -o quickstart quickstart.cpp simdjson.cpp -std=c++17`
+3. `c++ -o quickstart quickstart.cpp simdjson.cpp`
 4. `./quickstart`
    ```
    100 results.
@@ -69,65 +79,42 @@ Usage documentation is available:
 * [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.org/api/0.9.0/annotated.html) contains the automatically generated API documentation.
 
 Performance results
 -------------------
 
-The simdjson library uses three-quarters less instructions than state-of-the-art parser RapidJSON and
-fifty percent less than sajson. To our knowledge, simdjson is the first fully-validating JSON parser
-to run at gigabytes per second on commodity processors. It can parse millions of JSON documents
-per second on a single core.
+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
+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.
 
 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).
-We compare against the best and fastest C++ libraries.
-The simdjson library offers full unicode (UTF-8) validation and exact
-number parsing. The RapidJSON library is tested in two modes: fast and
-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 |
+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 on benchmarks that load and process the data.
+The simdjson library offers full unicode ([UTF-8](https://en.wikipedia.org/wiki/UTF-8)) validation and exact
+number parsing.
 
+<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).
 
+
+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).
+
+
+
 Real-world usage
 ----------------
 
 - [Microsoft FishStore](https://github.com/microsoft/FishStore)
 - [Yandex ClickHouse](https://github.com/yandex/ClickHouse)
 - [Clang Build Analyzer](https://github.com/aras-p/ClangBuildAnalyzer)
+- [Shopify HeapProfiler](https://github.com/Shopify/heap-profiler)
 
 If you are planning to use simdjson in a product, please work from one of our releases.
 
@@ -137,15 +124,20 @@ 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.
+
 
 About simdjson
 --------------
@@ -155,8 +147,12 @@ instructions, reducing branch misprediction, and reducing data dependency to tak
 CPU's multiple execution cores.
 
 Some people [enjoy reading our 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.
+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 (to appear)
 
 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/).
 
@@ -167,7 +163,8 @@ For the video inclined, <br />
 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 grant
+number RGPIN-2017-03910.
 
 [license]: LICENSE
 [license img]: https://img.shields.io/badge/License-Apache%202-blue.svg
@@ -181,6 +178,8 @@ Head over to [CONTRIBUTING.md](CONTRIBUTING.md) for information on contributing
 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).
 
 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.
+
+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.

RELEASES.md

@@ -1,3 +1,39 @@
+# 0.5
+
+## Highlights
+
+Performance
+* Faster and simpler UTF-8 validation with the lookup4 algorithm https://github.com/simdjson/simdjson/pull/993
+* We improved the performance of simdjson under Visual Studio by about 25%. Users will still get better performance with clang-cl (+30%) but the gap has been reduced. https://github.com/simdjson/simdjson/pull/1031
+
+Code usability
+* In `parse_many`, when parsing streams of JSON documetns, we give to the users runtime control as to whether threads are used (via the parser.threaded attribute). https://github.com/simdjson/simdjson/issues/925
+* Prefixed public macros to avoid name clashes with other libraries. https://github.com/simdjson/simdjson/issues/1035
+* Better documentation regarding package managers (brew, MSYS2, conan, apt, vcpkg, FreeBSD package manager, etc.).
+* Better documentation regarding  CMake usage.
+
+Standards
+* We improved standard compliance with respect to both the JSON RFC 8259 and JSON Pointer RFC 6901. We added the at_pointer method to nodes for standard-compliant JSON Pointer queries. The legacy `at(std::string_view)` method remains but is deprecated since it is not standard-compliant as per  RFC 6901.
+* We removed computed GOTOs without sacrificing performance thus improving the C++ standard compliance (since computed GOTOs are compiler-specific extensions).
+* Better support for C++20 https://github.com/simdjson/simdjson/pull/1050
+
+# 0.4
+
+## Highlights
+
+- Test coverage has been greatly improved and we have resolved many static-analysis warnings on different systems.
+- We added a fast (8GB/s) minifier that works directly on JSON strings.
+- We added fast (10GB/s) UTF-8 validator that works directly on strings (any strings, including non-JSON).
+- The array and object elements have a constant-time size() method.
+- Performance improvements to the API (type(), get<>()).
+- The parse_many function (ndjson) has been entirely reworked. It now uses a single secondary thread instead of several new threads.
+- We have introduced a faster UTF-8 validation algorithm (lookup3) for all kernels (ARM, x64 SSE, x64 AVX).
+- C++11 support for older compilers and systems.
+- FreeBSD support (and tests).
+- We support the clang front-end compiler (clangcl) under Visual Studio.
+- It is now possible to target ARM platforms under Visual Studio.
+- The simdjson library will never abort or print to standard output/error.
+
 # 0.3
 
 ## Highlights

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,40 @@
-target_include_directories(${SIMDJSON_LIB_NAME}
-  INTERFACE
-  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/benchmark>
-  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/benchmark/linux>
-)
+include_directories( . linux )
+link_libraries(simdjson-windows-headers test-data)
+link_libraries(simdjson simdjson-flags)
 
-add_cpp_benchmark(parse)
-add_cpp_benchmark(statisticalmodel)
-add_cpp_benchmark(parse_stream)
-add_cpp_benchmark(get_corpus_benchmark)
+add_executable(benchfeatures benchfeatures.cpp)
+add_executable(get_corpus_benchmark get_corpus_benchmark.cpp)
 add_executable(perfdiff perfdiff.cpp)
+add_executable(parse parse.cpp)
+add_executable(parse_stream parse_stream.cpp)
+add_executable(statisticalmodel statisticalmodel.cpp)
 
-# Google Benchmarks
-if (SIMDJSON_GOOGLE_BENCHMARKS)
-  add_cpp_benchmark(bench_parse_call)
-  target_link_libraries(bench_parse_call benchmark::benchmark)
+add_executable(parse_noutf8validation parse.cpp)
+target_compile_definitions(parse_noutf8validation PRIVATE SIMDJSON_SKIPUTF8VALIDATION)
+add_executable(parse_nonumberparsing parse.cpp)
+target_compile_definitions(parse_nonumberparsing PRIVATE SIMDJSON_SKIPNUMBERPARSING)
+add_executable(parse_nostringparsing parse.cpp)
+target_compile_definitions(parse_nostringparsing PRIVATE SIMDJSON_SKIPSTRINGPARSING)
 
-  add_cpp_benchmark(bench_dom_api)
-  target_link_libraries(bench_dom_api benchmark::benchmark)
-  target_compile_definitions(bench_dom_api PRIVATE JSON_TEST_PATH="${PROJECT_SOURCE_DIR}/jsonexamples/twitter.json")
-endif()
+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)
+  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()
+  endif()
+endif()
+
+include(checkperf.cmake)

benchmark/bench_dom_api.cpp

@@ -6,32 +6,480 @@ 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);
-  for (auto _ : state) {
+  dom::element doc = parser.load(TWITTER_JSON);
+  for (simdjson_unused auto _ : state) {
     uint64_t result_count = doc["search_metadata"]["count"];
     if (result_count != 100) { return; }
   }
 }
 BENCHMARK(twitter_count);
 
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
 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);
+  padded_string json = padded_string::load(TWITTER_JSON);
   ParsedJson pj = build_parsed_json(json);
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
     ParsedJson::Iterator iter(pj);
     // uint64_t result_count = doc["search_metadata"]["count"];
     if (!iter.move_to_key("search_metadata")) { return; }
@@ -44,17 +492,18 @@ static void iterator_twitter_count(State& state) {
 }
 BENCHMARK(iterator_twitter_count);
 SIMDJSON_POP_DISABLE_WARNINGS
+#endif // SIMDJSON_DISABLE_DEPRECATED_API
 
 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);
-  for (auto _ : state) {
+  dom::element doc = parser.load(TWITTER_JSON);
+  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 +514,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);
-  for (auto _ : state) {
+  dom::element doc = parser.load(TWITTER_JSON);
+  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>()) {
-      auto [media, not_found] = tweet["entities"]["media"];
-      if (!not_found) {
-        for (dom::object image : media.get<dom::array>()) {
-          for (auto [key, size] : image["sizes"].get<dom::object>()) {
-            image_sizes.insert({ size["w"], size["h"] });
+    for (dom::object tweet : doc["statuses"]) {
+      dom::array media;
+      if (not (error = tweet["entities"]["media"].get(media))) {
+        for (dom::object image : media) {
+          for (auto size : image["sizes"].get_object()) {
+             image_sizes.emplace(size.value["w"], size.value["h"]);
           }
         }
       }
@@ -88,10 +538,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);
-  for (auto _ : state) {
-    auto [value, error] = doc["search_metadata"]["count"].get<uint64_t>();
-    if (error) { return; }
+  simdjson::error_code error;
+  dom::element doc;
+  if ((error = parser.load(TWITTER_JSON).get(doc))) { return; }
+  for (simdjson_unused auto _ : state) {
+    uint64_t value;
+    if ((error = doc["search_metadata"]["count"].get(value))) { return; }
     if (value != 100) { return; }
   }
 }
@@ -100,20 +552,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);
-  for (auto _ : state) {
+  simdjson::error_code error;
+  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>();
-    if (error) { return; }
+    dom::array tweets;
+    if ((error = doc["statuses"].get(tweets))) { return; }
     for (dom::element tweet : tweets) {
-      auto [user, error2] = tweet["user"].get<dom::object>();
-      if (error2) { return; }
-      auto [default_profile, error3] = user["default_profile"].get<bool>();
-      if (error3) { return; }
+      dom::object user;
+      if ((error = tweet["user"].get(user))) { return; }
+      bool default_profile;
+      if ((error = user["default_profile"].get(default_profile))) { return; }
       if (default_profile) {
-        auto [screen_name, error4] = user["screen_name"].get<std::string_view>();
-        if (error4) { return; }
+        std::string_view screen_name;
+        if ((error = user["screen_name"].get(screen_name))) { return; }
         default_users.insert(screen_name);
       }
     }
@@ -123,17 +577,22 @@ static void error_code_twitter_default_profile(State& state) noexcept {
 }
 BENCHMARK(error_code_twitter_default_profile);
 
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
+
 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);
+  padded_string json;
+  auto error = padded_string::load(TWITTER_JSON).get(json);
+  if (error) { std::cerr << error << std::endl; return; }
   ParsedJson pj = build_parsed_json(json);
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
     set<string_view> default_users;
     ParsedJson::Iterator iter(pj);
 
-    // for (dom::object tweet : doc["statuses"].get<dom::array>()) {
+    // for (dom::object tweet : doc["statuses"]) {
     if (!(iter.move_to_key("statuses") && iter.is_array())) { return; }
     if (iter.down()) { // first status
       do {
@@ -148,7 +607,7 @@ static void iterator_twitter_default_profile(State& state) {
 
             // 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()));
+            default_users.emplace(iter.get_string(), iter.get_string_length());
           }
           if (!iter.up()) { return; } // back to user
         }
@@ -161,28 +620,32 @@ static void iterator_twitter_default_profile(State& state) {
     if (default_users.size() != 86) { return; }
   }
 }
+
 SIMDJSON_POP_DISABLE_WARNINGS
 BENCHMARK(iterator_twitter_default_profile);
+#endif // SIMDJSON_DISABLE_DEPRECATED_API
 
 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);
-  for (auto _ : state) {
+  simdjson::error_code error;
+  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>();
-    if (error) { return; }
+    dom::array statuses;
+    if ((error = doc["statuses"].get(statuses))) { return; }
     for (dom::element tweet : statuses) {
-      auto [images, not_found] = tweet["entities"]["media"].get<dom::array>();
-      if (!not_found) {
+      dom::array images;
+      if (not (error = tweet["entities"]["media"].get(images))) {
         for (dom::element image : images) {
-          auto [sizes, error2] = image["sizes"].get<dom::object>();
-          if (error2) { return; }
-          for (auto [key, size] : sizes) {
-            auto [width, error3] = size["w"].get<uint64_t>();
-            auto [height, error4] = size["h"].get<uint64_t>();
-            if (error3 || error4) { return; }
-            image_sizes.insert({ width, height });
+          dom::object sizes;
+          if ((error = image["sizes"].get(sizes))) { return; }
+          for (auto size : sizes) {
+            uint64_t width, height;
+            if ((error = size.value["w"].get(width))) { return; }
+            if ((error = size.value["h"].get(height))) { return; }
+            image_sizes.emplace(width, height);
           }
         }
       }
@@ -192,33 +655,38 @@ static void error_code_twitter_image_sizes(State& state) noexcept {
 }
 BENCHMARK(error_code_twitter_image_sizes);
 
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
+
 SIMDJSON_PUSH_DISABLE_WARNINGS
 SIMDJSON_DISABLE_DEPRECATED_WARNING
 static void iterator_twitter_image_sizes(State& state) {
   // Count unique image sizes
-  padded_string json = padded_string::load(JSON_TEST_PATH);
+  padded_string json;
+  auto error = padded_string::load(TWITTER_JSON).get(json);
+  if (error) { std::cerr << error << std::endl; return; }
   ParsedJson pj = build_parsed_json(json);
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
     set<tuple<uint64_t, uint64_t>> image_sizes;
     ParsedJson::Iterator iter(pj);
 
-    // for (dom::object tweet : doc["statuses"].get<dom::array>()) {
+    // for (dom::object tweet : doc["statuses"]) {
     if (!(iter.move_to_key("statuses") && iter.is_array())) { return; }
     if (iter.down()) { // first status
       do {
 
-        // auto [media, not_found] = tweet["entities"]["media"];
+        // dom::object media;
+        // not_found = tweet["entities"]["media"].get(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>()) {
+            //   for (dom::object image : media) {
             if (iter.down()) { // first media
               do {
 
-                // for (auto [key, size] : image["sizes"].get<dom::object>()) {
+                // for (auto [key, size] : dom::object(image["sizes"])) {
                 if (!(iter.move_to_key("sizes") && iter.is_object())) { return; }
                 if (iter.down()) { // first size
                   do {
@@ -231,7 +699,7 @@ static void iterator_twitter_image_sizes(State& state) {
                     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 });
+                    image_sizes.emplace(width, height);
 
                   } while (iter.next()); // next size
                   if (!iter.up()) { return; } // back to sizes
@@ -243,7 +711,7 @@ static void iterator_twitter_image_sizes(State& state) {
             if (!iter.up()) { return; } // back to entities
           }
           if (!iter.up()) { return; } // back to status
-        } 
+        }
       } while (iter.next()); // next status
     }
 
@@ -252,17 +720,26 @@ static void iterator_twitter_image_sizes(State& state) {
 }
 BENCHMARK(iterator_twitter_image_sizes);
 
+#endif // SIMDJSON_DISABLE_DEPRECATED_API
+
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
 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; }
-  for (auto _ : state) {
+
+  padded_string json;
+  auto error = padded_string::load(TWITTER_JSON).get(json);
+  if (error) { std::cerr << error << std::endl; return; }
+
+  int code = json_parse(json, parser);
+  if (code) { cerr << error_message(code) << endl; return; }
+  for (simdjson_unused auto _ : state) {
     std::stringstream s;
     if (!parser.print_json(s)) { cerr << "print_json failed" << endl; return; }
   }
 }
 BENCHMARK(print_json);
+#endif // SIMDJSON_DISABLE_DEPRECATED_API
 SIMDJSON_POP_DISABLE_WARNINGS
 
-BENCHMARK_MAIN();
+BENCHMARK_MAIN();

benchmark/bench_ondemand.cpp

@@ -0,0 +1,72 @@
+#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
+
+// This has to be last, for reasons I don't yet understand
+#include <benchmark/benchmark.h>
+
+SIMDJSON_POP_DISABLE_WARNINGS
+
+#include "partial_tweets/simdjson_dom.h"
+#include "partial_tweets/simdjson_ondemand.h"
+#include "partial_tweets/yyjson.h"
+#include "partial_tweets/sajson.h"
+#include "partial_tweets/rapidjson.h"
+#include "partial_tweets/nlohmann_json.h"
+
+#include "large_random/simdjson_dom.h"
+#include "large_random/simdjson_ondemand.h"
+#include "large_random/simdjson_ondemand_unordered.h"
+#include "large_random/yyjson.h"
+#include "large_random/sajson.h"
+#include "large_random/rapidjson.h"
+#include "large_random/nlohmann_json.h"
+
+#include "kostya/simdjson_dom.h"
+#include "kostya/simdjson_ondemand.h"
+#include "kostya/yyjson.h"
+#include "kostya/sajson.h"
+#include "kostya/rapidjson.h"
+#include "kostya/nlohmann_json.h"
+
+#include "distinct_user_id/simdjson_dom.h"
+#include "distinct_user_id/simdjson_ondemand.h"
+#include "distinct_user_id/yyjson.h"
+#include "distinct_user_id/sajson.h"
+#include "distinct_user_id/rapidjson.h"
+#include "distinct_user_id/nlohmann_json.h"
+
+#include "find_tweet/simdjson_dom.h"
+#include "find_tweet/simdjson_ondemand.h"
+#include "find_tweet/yyjson.h"
+#include "find_tweet/sajson.h"
+#include "find_tweet/rapidjson.h"
+#include "find_tweet/nlohmann_json.h"
+
+#include "top_tweet/simdjson_dom.h"
+#include "top_tweet/simdjson_ondemand.h"
+#include "top_tweet/yyjson.h"
+#include "top_tweet/sajson.h"
+#include "top_tweet/rapidjson.h"
+#include "top_tweet/nlohmann_json.h"
+
+BENCHMARK_MAIN();

benchmark/bench_parse_call.cpp

@@ -5,69 +5,193 @@ 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";
 
+
+
+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);
+
+
+
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
 SIMDJSON_PUSH_DISABLE_WARNINGS
 SIMDJSON_DISABLE_DEPRECATED_WARNING
 static void json_parse(State& state) {
   ParsedJson pj;
   if (!pj.allocate_capacity(EMPTY_ARRAY.length())) { return; }
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
     auto error = json_parse(EMPTY_ARRAY, pj);
     if (error) { return; }
   }
 }
 SIMDJSON_POP_DISABLE_WARNINGS
 BENCHMARK(json_parse);
+#endif // SIMDJSON_DISABLE_DEPRECATED_API
+
 static void parser_parse_error_code(State& state) {
   dom::parser parser;
   if (parser.allocate(EMPTY_ARRAY.length())) { return; }
-  for (auto _ : state) {
-    auto [doc, error] = parser.parse(EMPTY_ARRAY);
+  for (simdjson_unused auto _ : state) {
+    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);
 
+#endif // SIMDJSON_EXCEPTIONS
+
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
 SIMDJSON_PUSH_DISABLE_WARNINGS
 SIMDJSON_DISABLE_DEPRECATED_WARNING
 static void build_parsed_json(State& state) {
-  for (auto _ : state) {
+  for (simdjson_unused auto _ : state) {
     dom::parser parser = simdjson::build_parsed_json(EMPTY_ARRAY);
     if (!parser.valid) { return; }
   }
 }
 SIMDJSON_POP_DISABLE_WARNINGS
+
 BENCHMARK(build_parsed_json);
+#endif
+
 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);
 
-BENCHMARK_MAIN();
+#endif // SIMDJSON_EXCEPTIONS
+
+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 << "             or ARM64). By default, detects best supported architecture." << endl;
+  out << "-a ARCH    - Use the parser with the designated architecture (HASWELL, WESTMERE," << 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) {
-        switch (c) {
-        case 'n':
-          iterations = atoi(optarg);
-          break;
-        case 'i':
-          iteration_step = atoi(optarg);
-          break;
-        case 'v':
-          verbose = true;
-          break;
-        case 'a':
-          arch = parse_architecture(optarg);
-          if (arch == architecture::UNSUPPORTED) {
-            exit_usage(string("Unsupported option value -a ") + optarg + ": expected -a HASWELL, WESTMERE or ARM64");
-          }
-          break;
-        case 's':
-          if (!strcmp(optarg, "stage1")) {
-            stage1_only = true;
-          } else if (!strcmp(optarg, "all")) {
-            stage1_only = false;
+    while ((c = getopt(argc, argv, "vtn:i:a:s:")) != -1) {
+      switch (c) {
+      case 'n':
+        iterations = atoi(optarg);
+        break;
+      case 'i':
+        iteration_step = atoi(optarg);
+        break;
+      case 'v':
+        verbose = true;
+        break;
+      case 'a': {
+          auto impl = simdjson::available_implementations[optarg];
+          if(impl && impl->supported_by_runtime_system()) {
+            simdjson::active_implementation = impl;
           } 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) :
-    utf8               ("jsonexamples/generated/utf-8.json", parser, collector),
-    utf8_miss          ("jsonexamples/generated/utf-8-miss.json", parser, collector),
-    escape               ("jsonexamples/generated/escape.json", parser, collector),
-    escape_miss          ("jsonexamples/generated/escape-miss.json", parser, collector),
-    empty              ("jsonexamples/generated/0-structurals.json", parser, collector),
-    empty_miss         ("jsonexamples/generated/0-structurals-miss.json", parser, collector),
-    struct7           ("jsonexamples/generated/7-structurals.json", parser, collector),
-    struct7_miss      ("jsonexamples/generated/7-structurals-miss.json", parser, collector),
-    struct7_full       ("jsonexamples/generated/7-structurals-full.json", parser, collector),
-    struct15     ("jsonexamples/generated/15-structurals.json", parser, collector),
-    struct15_miss("jsonexamples/generated/15-structurals-miss.json", parser, collector),
-    struct23     ("jsonexamples/generated/23-structurals.json", parser, collector),
-    struct23_miss("jsonexamples/generated/23-structurals-miss.json", parser, collector)
+  feature_benchmarker(event_collector& collector) :
+    utf8               (SIMDJSON_BENCHMARK_DATA_DIR "generated/utf-8.json", collector),
+    utf8_miss          (SIMDJSON_BENCHMARK_DATA_DIR "generated/utf-8-miss.json", collector),
+    escape               (SIMDJSON_BENCHMARK_DATA_DIR "generated/escape.json", collector),
+    escape_miss          (SIMDJSON_BENCHMARK_DATA_DIR "generated/escape-miss.json", collector),
+    empty              (SIMDJSON_BENCHMARK_DATA_DIR "generated/0-structurals.json", collector),
+    empty_miss         (SIMDJSON_BENCHMARK_DATA_DIR "generated/0-structurals-miss.json", collector),
+    struct7           (SIMDJSON_BENCHMARK_DATA_DIR "generated/7-structurals.json", collector),
+    struct7_miss      (SIMDJSON_BENCHMARK_DATA_DIR "generated/7-structurals-miss.json", collector),
+    struct7_full       (SIMDJSON_BENCHMARK_DATA_DIR "generated/7-structurals-full.json", collector),
+    struct15     (SIMDJSON_BENCHMARK_DATA_DIR "generated/15-structurals.json", collector),
+    struct15_miss(SIMDJSON_BENCHMARK_DATA_DIR "generated/15-structurals-miss.json", collector),
+    struct23     (SIMDJSON_BENCHMARK_DATA_DIR "generated/23-structurals.json", 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_really_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
@@ -213,7 +205,7 @@ struct feature_benchmarker {
   // Rate of 1-7-structural misses per 8-structural flip
   double struct1_7_miss_rate(BenchmarkStage stage) const {
     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);
   }
 
   // Extra cost of an 8-15 structural block over a 1-7 structural block
@@ -227,7 +219,7 @@ struct feature_benchmarker {
   // Rate of 8-15-structural misses per 8-structural flip
   double struct8_15_miss_rate(BenchmarkStage stage) const {
     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);
   }
 
   // Extra cost of a 16+-structural block over an 8-15 structural block (actual varies based on # of structurals!)
@@ -241,7 +233,7 @@ struct feature_benchmarker {
   // Rate of 16-structural misses per 16-structural flip
   double struct16_miss_rate(BenchmarkStage stage) const {
     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);
   }
 
   // Extra cost of having UTF-8 in a block
@@ -255,7 +247,7 @@ struct feature_benchmarker {
   // Rate of UTF-8 misses per UTF-8 flip
   double utf8_miss_rate(BenchmarkStage stage) const {
     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);
   }
 
   // Extra cost of having escapes in a block
@@ -269,39 +261,39 @@ struct feature_benchmarker {
   // Rate of escape misses per escape flip
   double escape_miss_rate(BenchmarkStage stage) const {
     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);
   }
 
   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;
-    expected +=       struct1_7_cost(stage)  * stats.blocks_with_1_structural;
-    expected +=       utf8_cost(stage)       * stats.blocks_with_utf8;
-    expected +=       escape_cost(stage)     * stats.blocks_with_escapes;
-    expected +=       struct8_15_cost(stage) * stats.blocks_with_8_structurals;
-    expected +=       struct16_cost(stage)   * stats.blocks_with_16_structurals;
-    return expected / stats.blocks;
+    double expected = base_cost(stage)       * double(stats.blocks);
+    expected +=       struct1_7_cost(stage)  * double(stats.blocks_with_1_structural);
+    expected +=       utf8_cost(stage)       * double(stats.blocks_with_utf8);
+    expected +=       escape_cost(stage)     * double(stats.blocks_with_escapes);
+    expected +=       struct8_15_cost(stage) * double(stats.blocks_with_8_structurals);
+    expected +=       struct16_cost(stage)   * double(stats.blocks_with_16_structurals);
+    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);
-    expected +=       utf8_miss_cost(stage)       * stats.blocks_with_utf8_flipped * utf8_miss_rate(stage);
-    expected +=       escape_miss_cost(stage)     * 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 +=       struct16_miss_cost(stage)   * stats.blocks_with_16_structurals_flipped * struct16_miss_rate(stage);
-    return expected / stats.blocks;
+    double expected = struct1_7_miss_cost(stage)  * double(stats.blocks_with_1_structural_flipped) * struct1_7_miss_rate(stage);
+    expected +=       utf8_miss_cost(stage)       * double(stats.blocks_with_utf8_flipped) * utf8_miss_rate(stage);
+    expected +=       escape_miss_cost(stage)     * double(stats.blocks_with_escapes_flipped) * escape_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)   * double(stats.blocks_with_16_structurals_flipped) * struct16_miss_rate(stage);
+    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);
-    expected +=       stats.blocks_with_utf8_flipped           * utf8_miss_rate(stage);
-    expected +=       stats.blocks_with_escapes_flipped        * escape_miss_rate(stage);
-    expected +=       stats.blocks_with_8_structurals_flipped  * struct8_15_miss_rate(stage);
-    expected +=       stats.blocks_with_16_structurals_flipped * struct16_miss_rate(stage);
+    double expected = double(stats.blocks_with_1_structural_flipped)   * struct1_7_miss_rate(stage);
+    expected +=       double(stats.blocks_with_utf8_flipped)           * utf8_miss_rate(stage);
+    expected +=       double(stats.blocks_with_escapes_flipped)        * escape_miss_rate(stage);
+    expected +=       double(stats.blocks_with_8_structurals_flipped)  * struct8_15_miss_rate(stage);
+    expected +=       double(stats.blocks_with_16_structurals_flipped) * struct16_miss_rate(stage);
     return expected;
   }
 
@@ -368,10 +360,10 @@ struct feature_benchmarker {
 };
 
 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();
-  uint64_t calc_misses = uint64_t(features.calc_expected_misses(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);
@@ -380,10 +372,10 @@ 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));
   if (features.has_events()) {
-    printf("| %13lu ",  actual_misses);
-    printf("| %+13ld ", int64_t(actual_misses - calc_misses));
+    printf("| %13llu ", (long long unsigned)(actual_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));
@@ -405,9 +397,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 twitter("jsonexamples/twitter.json", collector);
-  benchmarker random("jsonexamples/random.json", collector);
+  benchmarker gsoc_2018(SIMDJSON_BENCHMARK_DATA_DIR "gsoc-2018.json", collector);
+  benchmarker twitter(SIMDJSON_BENCHMARK_DATA_DIR "twitter.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";
-
-#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;
-}
+#include "event_counter.h"
 
 /*
  * 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;                          \
-    uint64_t min_diff = (uint64_t)-1;                                          \
-    double min_sumclockdiff = DBL_MAX;                                         \
-    uint64_t sum_diff = 0;                                                     \
-    double sumclockdiff = 0;                                                   \
-    struct timespec time1, time2;                                              \
-    for (int i = 0; i < repeat; i++) {                                         \
+    event_collector collector;                                                 \
+    event_aggregate aggregate{};                                               \
+    for (decltype(repeat) i = 0; i < repeat; i++) {                            \
       pre;                                                                     \
-      __asm volatile("" ::: /* pretend to clobber */ "memory");                \
-      clock_gettime(CLOCK_REALTIME, &time1);                                   \
-      RDTSC_START(cycles_start);                                               \
+      std::atomic_thread_fence(std::memory_order_acquire);                     \
+      collector.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);                                                \
-      clock_gettime(CLOCK_REALTIME, &time2);                                   \
-      double thistiming = diff(time1, time2);                                  \
-      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;                                                 \
+      std::atomic_thread_fence(std::memory_order_release);                     \
+      event_count allocate_count = collector.end();                            \
+      aggregate << allocate_count;                                             \
     }                                                                          \
-    uint64_t S = size;                                                         \
-    float cycle_per_op = (min_diff) / (double)S;                               \
-    float avg_cycle_per_op = (sum_diff) / ((double)S * repeat);                \
-    double avg_gb_per_s =                                                      \
-        ((double)S * repeat) / ((sumclockdiff)*1000.0 * 1000.0 * 1000.0);      \
-    double max_gb_per_s =                                                      \
-        ((double)S) / ((min_sumclockdiff)*1000.0 * 1000.0 * 1000.0);           \
-    if (verbose)                                                               \
-      printf(" %7.3f %s per input byte (best) ", cycle_per_op, unitname);      \
-    if (verbose)                                                               \
-      printf(" %7.3f %s (avg) ", avg_cycle_per_op, unitname);                  \
-    if (verbose)                                                               \
-      printf(" %7.3f GB/s (error margin: %5.3f GB/s)", max_gb_per_s,            \
-             -avg_gb_per_s + max_gb_per_s);                                    \
-    if (verbose)                                                               \
-      printf(" %13.0f documents/s (best)", 1.0/min_sumclockdiff);             \
-    if (verbose)                                                               \
-      printf(" %13.0f documents/s (avg)", 1.0/(sumclockdiff/repeat));         \
-    if (!verbose)                                                              \
-      printf(" %20.3f %20.3f %20.3f %20.3f", cycle_per_op,                     \
-             avg_cycle_per_op - cycle_per_op, max_gb_per_s,                    \
-             -avg_gb_per_s + max_gb_per_s);                                    \
-    printf("\n");                                                              \
-    fflush(NULL);                                                              \
+    if (collector.has_events()) {                                              \
+      std::printf("%7.3f",                                                     \
+                  aggregate.best.cycles() / static_cast<double>(size));        \
+      if (verbose) {                                                           \
+        std::printf(" cycles/byte ");                                          \
+      }                                                                        \
+      std::printf("\t");                                                       \
+      std::printf("%7.3f",                                                     \
+                  aggregate.best.instructions() / static_cast<double>(size));  \
+      if (verbose) {                                                           \
+        std::printf(" instructions/byte ");                                    \
+      }                                                                        \
+      std::printf("\t");                                                       \
+    }                                                                          \
+    double gb = static_cast<double>(size) / 1000000000.0;                      \
+    std::printf("%7.3f", gb / aggregate.best.elapsed_sec());                   \
+    if (verbose) {                                                             \
+      std::printf(" GB/s ");                                                   \
+    }                                                                          \
+    std::printf("\t"); \
+    std::printf("%7.3f", 1.0 / aggregate.best.elapsed_sec());                  \
+    if (verbose) {                                                             \
+      std::printf(" documents/s ");                                            \
+    }                                                                          \
+    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);                                               \
-    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++) {                                         \
+      std::printf("%-40s\t: ", name);                                          \
+    else                                                                       \
+      std::printf("\"%-40s\"", name);                                          \
+    std::fflush(NULL);                                                         \
+    event_collector collector;                                                 \
+    event_aggregate aggregate{};                                               \
+    for (decltype(repeat) i = 0; i < repeat; i++) {                            \
       pre;                                                                     \
-      __asm volatile("" ::: /* pretend to clobber */ "memory");                \
-      RDTSC_START(cycles_start);                                               \
+      std::atomic_thread_fence(std::memory_order_acquire);                     \
+      collector.start();                                                       \
       test;                                                                    \
-      RDTSC_STOP(cycles_final);                                                \
-      cycles_diff = (cycles_final - cycles_start - global_rdtsc_overhead);     \
-      if (cycles_diff < min_diff)                                              \
-        min_diff = cycles_diff;                                                \
-      sum_diff += cycles_diff;                                                 \
+      std::atomic_thread_fence(std::memory_order_release);                     \
+      event_count allocate_count = collector.end();                            \
+      aggregate << allocate_count;                                             \
     }                                                                          \
-    uint64_t S = size;                                                         \
-    float cycle_per_op = (min_diff) / (double)S;                               \
-    float avg_cycle_per_op = (sum_diff) / ((double)S * repeat);                \
-    if (verbose)                                                               \
-      printf(" %.3f %s per input byte (best) ", cycle_per_op, unitname);       \
-    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;                                                                 \
+    if (collector.has_events()) {                                              \
+      std::printf("%7.3f",                                                     \
+                  aggregate.best.cycles() / static_cast<double>(size));        \
+      if (verbose) {                                                           \
+        std::printf(" cycles/byte ");                                          \
       }                                                                        \
-      cycles_diff = (cycles_final - cycles_start - global_rdtsc_overhead);     \
-      if (cycles_diff < min_diff)                                              \
-        min_diff = cycles_diff;                                                \
-      sum_diff += cycles_diff;                                                 \
+      std::printf("\t");                                                       \
+      std::printf("%7.3f",                                                     \
+                  aggregate.best.instructions() / static_cast<double>(size));  \
+      if (verbose) {                                                           \
+        std::printf(" instructions/byte ");                                    \
+      }                                                                        \
+      std::printf("\t");                                                       \
     }                                                                          \
-    uint64_t S = size;                                                         \
-    float cycle_per_op = (min_diff) / (double)S;                               \
-    float avg_cycle_per_op = (sum_diff) / ((double)S * repeat);                \
-    if (verbose)                                                               \
-      printf(" %.3f cycles per operation (best) ", cycle_per_op);              \
-    if (verbose)                                                               \
-      printf("\t%.3f cycles per operation (avg) ", avg_cycle_per_op);          \
-    if (verbose)                                                               \
-      printf("\n");                                                            \
-    if (!verbose)                                                              \
-      printf(" %.3f ", cycle_per_op);                                          \
-    fflush(NULL);                                                              \
+    double gb = static_cast<double>(size) / 1000000000.0;                      \
+    std::printf("%7.3f", gb / aggregate.best.elapsed_sec());                   \
+    if (verbose) {                                                             \
+      std::printf(" GB/s ");                                                   \
+    }                                                                          \
+    std::printf("\t");                                                       \
+    std::printf("%7.3f", 1.0 / aggregate.best.elapsed_sec());                  \
+    if (verbose) {                                                             \
+      std::printf(" documents/s ");                                            \
+    }                                                                          \
+    std::printf("\n");                                                         \
+    std::fflush(NULL);                                                         \
   } while (0)
 
 #endif

benchmark/benchmarker.h

@@ -2,13 +2,14 @@
 #define __BENCHMARKER_H
 
 #include "event_counter.h"
+#include "simdjson.h" // For SIMDJSON_DISABLE_DEPRECATED_WARNINGS
 
 #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)
-  event_aggregate all_stages;
+  // Speed and event summary for full parse (stage 1 and stage 2, but *excluding* allocation)
+  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;
-    padded_string::load(filename).tie(this->json, error);
+    auto error = padded_string::load(filename).get(json);
     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_really_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(), false);
     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,43 +384,44 @@ struct benchmarker {
     loop << all_loop_count;
   }
 
-  really_inline void run_iterations(size_t iterations, bool stage1_only, bool hotbuffers=false) {
+  simdjson_really_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
-      100.0 * stage.elapsed_sec() / all_stages.elapsed_sec(), // %
-      stage.elapsed_ns() / stats->bytes, // per byte
-      stage.elapsed_ns() / stats->structurals, // per structural
-      (json.size() / 1000000000.0) / stage.elapsed_sec() // GB/s
+      stage.elapsed_ns() / static_cast<double>(stats->blocks), // per block
+      percent(stage.elapsed_sec(), all_stages_without_allocation.elapsed_sec()), // %
+      stage.elapsed_ns() / static_cast<double>(stats->bytes), // per byte
+      stage.elapsed_ns() / static_cast<double>(stats->structurals), // per structural
+      (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,
-        100.0 * stage.cycles() / all_stages.cycles(),
-        stage.cycles() / stats->bytes,
-        stage.cycles() / stats->structurals,
+        stage.cycles() / static_cast<double>(stats->blocks),
+        percent(stage.cycles(), all_stages_without_allocation.cycles()),
+        stage.cycles() / static_cast<double>(stats->bytes),
+        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,
-        100.0 * stage.instructions() / all_stages.instructions(),
-        stage.instructions() / stats->bytes,
-        stage.instructions() / stats->structurals,
-        stage.instructions() / stage.cycles()
+        stage.instructions() / static_cast<double>(stats->blocks),
+        percent(stage.instructions(), all_stages_without_allocation.instructions()),
+        stage.instructions() / static_cast<double>(stats->bytes),
+        stage.instructions() / static_cast<double>(stats->structurals),
+        stage.instructions() / static_cast<double>(stage.cycles())
       );
 
       // NOTE: removed cycles/miss because it is a somewhat misleading stat
@@ -411,18 +429,29 @@ struct benchmarker {
         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()
       );
     }
   }
 
-  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) 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 +461,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(),
-                stage1.best.cycles() / json.size(),
-                stage2.best.cycles() / json.size(),
-                all_stages.best.cycles() / json.size(),
-                gb / all_stages.best.elapsed_sec(),
+                allocate_stage.best.cycles() / static_cast<double>(json.size()),
+                stage1.best.cycles() / static_cast<double>(json.size()),
+                stage2.best.cycles() / static_cast<double>(json.size()),
+                all_stages_without_allocation.best.cycles() / static_cast<double>(json.size()),
+                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,28 +484,28 @@ 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_escapes, 100.0 * stats->blocks_with_escapes / stats->blocks,
-          stats->blocks_with_0_structurals, 100.0 * stats->blocks_with_0_structurals / stats->blocks,
-          stats->blocks_with_1_structural, 100.0 * stats->blocks_with_1_structural / stats->blocks,
-          stats->blocks_with_8_structurals, 100.0 * stats->blocks_with_8_structurals / stats->blocks,
-          stats->blocks_with_16_structurals, 100.0 * stats->blocks_with_16_structurals / stats->blocks);
+          stats->blocks_with_utf8, percent(stats->blocks_with_utf8, stats->blocks),
+          stats->blocks_with_escapes, percent(stats->blocks_with_escapes, stats->blocks),
+          stats->blocks_with_0_structurals, percent(stats->blocks_with_0_structurals, stats->blocks),
+          stats->blocks_with_1_structural, percent(stats->blocks_with_1_structural, stats->blocks),
+          stats->blocks_with_8_structurals, percent(stats->blocks_with_8_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_escapes_flipped, 100.0 * 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_1_structural_flipped, 100.0 * 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_16_structurals_flipped, 100.0 * stats->blocks_with_16_structurals_flipped / stats->blocks);
+          stats->blocks_with_utf8_flipped, percent(stats->blocks_with_utf8_flipped, stats->blocks),
+          stats->blocks_with_escapes_flipped, percent(stats->blocks_with_escapes_flipped, stats->blocks),
+          stats->blocks_with_0_structurals_flipped, percent(stats->blocks_with_0_structurals_flipped, stats->blocks),
+          stats->blocks_with_1_structural_flipped, percent(stats->blocks_with_1_structural_flipped, stats->blocks),
+          stats->blocks_with_8_structurals_flipped, percent(stats->blocks_with_8_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");
-      print_aggregate("|    "   , all_stages.best);
+      printf("All Stages (excluding allocation)\n");
+      print_aggregate("|    "   , all_stages_without_allocation.best);
       // frequently, allocation is a tiny fraction of the running time so we omit it
-      if(allocate_stage.best.elapsed_sec() > 0.01 * all_stages.best.elapsed_sec()) {
+      if(allocate_stage.best.elapsed_sec() > 0.01 * all_stages_without_allocation.best.elapsed_sec()) {
         printf("|- Allocation\n");
         print_aggregate("|    ", allocate_stage.best);
       }
@@ -487,17 +516,16 @@ struct benchmarker {
       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 freqmin = std::min(freq1, freq2);
-        double freqmax = std::max(freq1, freq2);
+        double freqall = (all_stages_without_allocation.best.cycles() / all_stages_without_allocation.best.elapsed_sec()) / 1000000000.0;
+        double freqmin = min(freq1, freq2);
+        double freqmax = max(freq1, freq2);
         if((freqall < 0.95 * freqmin) or (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/checkperf.cmake

@@ -0,0 +1,101 @@
+# Relevant targets:
+# checkperf-parse: builds the reference checkperf-parse, syncing reference repository if needed
+# checkperf: builds the targets needed for checkperf (parse, perfdiff, checkperf-parse)
+# update-checkperf-repo: updates the reference repository we're checking performance against
+# checkperf-repo: initialize and sync reference repository (first time only)
+# TEST checkperf: runs the actual checkperf test
+
+# Clone the repository if it's not there
+find_package(Git QUIET)
+if (Git_FOUND AND (GIT_VERSION_STRING VERSION_GREATER  "2.1.4") AND (NOT CMAKE_GENERATOR MATCHES Ninja) AND (NOT MSVC) ) # We use "-C" which requires a recent git
+  message(STATUS "Git is available and it is recent. We are enabling checkperf targets.")
+  # sync_git_repository(myrepo ...) creates two targets:
+  # myrepo - if the repo does not exist, creates and syncs it against the origin branch
+  # update_myrepo - will update the repo against the origin branch (and create if needed)
+  function(sync_git_repository name dir remote branch url)
+    # This conditionally creates the git repository
+    add_custom_command(
+      OUTPUT ${dir}/.git/config
+      COMMAND ${GIT_EXECUTABLE} init ${dir}
+      COMMAND ${GIT_EXECUTABLE} -C ${dir} remote add ${remote} ${url}
+    )
+    add_custom_target(init-${name} DEPENDS ${dir}/.git/config)
+    # This conditionally syncs the git repository, first time only
+    add_custom_command(
+      OUTPUT ${dir}/.git/FETCH_HEAD
+      COMMAND ${GIT_EXECUTABLE} remote set-url ${remote} ${url}
+      COMMAND ${GIT_EXECUTABLE} fetch --depth=1 ${remote} ${branch}
+      COMMAND ${GIT_EXECUTABLE} reset --hard ${remote}/${branch}
+      WORKING_DIRECTORY ${dir}
+      DEPENDS init-${name}
+    )
+    # This is the ${name} target, which will create and sync the repo first time only
+    add_custom_target(${name} DEPENDS ${dir}/.git/FETCH_HEAD)
+    # This is the update-${name} target, which will sync the repo (creating it if needed)
+    add_custom_target(
+      update-${name}
+      COMMAND ${GIT_EXECUTABLE} remote set-url ${remote} ${url}
+      COMMAND ${GIT_EXECUTABLE} fetch --depth=1 ${remote} ${branch}
+      COMMAND ${GIT_EXECUTABLE} reset --hard ${remote}/${branch}
+      WORKING_DIRECTORY ${dir}
+      DEPENDS init-${name}
+    )
+  endfunction(sync_git_repository)
+
+  set(SIMDJSON_CHECKPERF_REMOTE origin CACHE STRING "Remote repository to compare performance against")
+  set(SIMDJSON_CHECKPERF_BRANCH master CACHE STRING "Branch to compare performance against")
+  set(SIMDJSON_CHECKPERF_DIR ${CMAKE_CURRENT_BINARY_DIR}/checkperf-reference/${SIMDJSON_CHECKPERF_BRANCH} CACHE STRING "Location to put checkperf performance comparison repository")
+  set(SIMDJSON_CHECKPERF_ARGS ${EXAMPLE_JSON} CACHE STRING "Arguments to pass to parse during checkperf")
+  sync_git_repository(checkperf-repo ${SIMDJSON_CHECKPERF_DIR} ${SIMDJSON_CHECKPERF_REMOTE} ${SIMDJSON_CHECKPERF_BRANCH} ${SIMDJSON_GITHUB_REPOSITORY})
+
+  # Commands to cause cmake on benchmark/checkperf-master/build/
+  # - first, copy CMakeCache.txt
+  add_custom_command(
+    OUTPUT ${SIMDJSON_CHECKPERF_DIR}/build/CMakeCache.txt
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${SIMDJSON_CHECKPERF_DIR}/build
+    COMMAND ${CMAKE_COMMAND} -E copy ${SIMDJSON_USER_CMAKECACHE} ${SIMDJSON_CHECKPERF_DIR}/build/CMakeCache.txt
+    DEPENDS checkperf-repo simdjson-user-cmakecache
+  )
+  # - second, cmake ..
+  add_custom_command(
+    OUTPUT ${SIMDJSON_CHECKPERF_DIR}/build/cmake_install.cmake # We make many things but this seems the most cross-platform one we can depend on
+    COMMAND
+    ${CMAKE_COMMAND} -E env CXX=${CMAKE_CXX_COMPILER} CC=${CMAKE_C_COMPILER}
+    ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_COMPETITION=OFF -G ${CMAKE_GENERATOR} ..
+    WORKING_DIRECTORY ${SIMDJSON_CHECKPERF_DIR}/build
+    DEPENDS ${SIMDJSON_CHECKPERF_DIR}/build/CMakeCache.txt
+  )
+
+  # - third, build parse.
+  if (CMAKE_CONFIGURATION_TYPES)
+    set(CHECKPERF_PARSE ${SIMDJSON_CHECKPERF_DIR}/build/benchmark/$<CONFIGURATION>/parse)
+  else()
+    set(CHECKPERF_PARSE ${SIMDJSON_CHECKPERF_DIR}/build/benchmark/parse)
+  endif()
+  add_custom_target(
+    checkperf-parse ALL # TODO is ALL necessary?
+    # Build parse
+    COMMAND ${CMAKE_COMMAND} --build . --target parse --config $<CONFIGURATION>
+    WORKING_DIRECTORY ${SIMDJSON_CHECKPERF_DIR}/build
+    DEPENDS ${SIMDJSON_CHECKPERF_DIR}/build/cmake_install.cmake # We make many things but this seems the most cross-platform one we can depend on
+  )
+
+  # Target to build everything needed for the checkperf test
+  add_custom_target(checkperf DEPENDS parse perfdiff checkperf-parse)
+
+  # Add the actual checkperf test
+  add_test(
+    NAME checkperf
+    # COMMAND ECHO $<TARGET_FILE:perfdiff> \"$<TARGET_FILE:parse> -t ${SIMDJSON_CHECKPERF_ARGS}\" \"${CHECKPERF_PARSE} -t ${SIMDJSON_CHECKPERF_ARGS}\" }
+    COMMAND $<TARGET_FILE:perfdiff> $<TARGET_FILE:parse> ${CHECKPERF_PARSE} -H -t ${SIMDJSON_CHECKPERF_ARGS}
+  )
+  set_property(TEST checkperf APPEND PROPERTY LABELS per_implementation explicitonly)
+  set_property(TEST checkperf APPEND PROPERTY DEPENDS parse perfdiff ${SIMDJSON_USER_CMAKECACHE})
+  set_property(TEST checkperf PROPERTY RUN_SERIAL TRUE)
+else()
+  if (CMAKE_GENERATOR MATCHES Ninja)
+   message(STATUS "We disable the checkperf targets under Ninja.")
+  else()
+   message(STATUS "Either git is unavailable or else it is too old. We are disabling checkperf targets.")
+  endif()
+endif ()

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_really_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/rapidjson.h

@@ -0,0 +1,58 @@
+#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();
+
+struct rapidjson_insitu : rapidjson_base {
+  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag>(json.data()), result);
+  }
+};
+BENCHMARK_TEMPLATE(distinct_user_id, rapidjson_insitu)->UseManualTime();
+
+} // namespace partial_tweets
+
+#endif // SIMDJSON_COMPETITION_RAPIDJSON

benchmark/distinct_user_id/sajson.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_SAJSON
+
+#include "distinct_user_id.h"
+
+namespace distinct_user_id {
+
+struct sajson {
+  size_t ast_buffer_size{0};
+  size_t *ast_buffer{nullptr};
+  simdjson_really_inline std::string_view get_string_view(const ::sajson::value &obj, std::string_view key) {
+    auto val = obj.get_value_of_key({key.data(), key.length()});
+    if (val.get_type() != ::sajson::TYPE_STRING) { throw "field is not a string"; }
+    return { val.as_cstring(), val.get_string_length() };
+  }
+  simdjson_really_inline uint64_t get_str_uint64(const ::sajson::value &obj, std::string_view key) {
+    // Since sajson only supports 53-bit numbers, and IDs in twitter.json can be > 53 bits, we read the corresponding id_str and parse that.
+    auto val = obj.get_value_of_key({key.data(), key.length()});
+    if (val.get_type() != ::sajson::TYPE_STRING) { throw "field not a string"; }
+    auto str = val.as_cstring();
+    char *endptr;
+    uint64_t result = strtoull(str, &endptr, 10);
+    if (endptr != &str[val.get_string_length()]) { throw "field is a string, but not an integer string"; }
+    return result;
+  }
+
+  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+    using namespace sajson;
+    if (!ast_buffer) {
+      ast_buffer_size = json.size();
+      ast_buffer = (size_t *)std::malloc(ast_buffer_size * sizeof(size_t));
+    }
+    auto doc = parse(
+      bounded_allocation(ast_buffer, ast_buffer_size),
+      mutable_string_view(json.size(), json.data())
+    );
+    if (!doc.is_valid()) { return false; }
+
+    auto root = doc.get_root();
+    if (root.get_type() != TYPE_OBJECT) { return false; }
+    auto statuses = root.get_value_of_key({"statuses", strlen("statuses")});
+    if (statuses.get_type() != TYPE_ARRAY) { return false; }
+
+    for (size_t i=0; i<statuses.get_length(); i++) {
+      auto tweet = statuses.get_array_element(i);
+
+      // get tweet.user.id
+      if (tweet.get_type() != TYPE_OBJECT) { return false; }
+      auto user = tweet.get_value_of_key({"user", strlen("user")});
+      if (user.get_type() != TYPE_OBJECT) { return false; }
+      result.push_back(get_str_uint64(user, "id_str"));
+
+      // get tweet.retweeted_status.user.id
+      auto retweet = tweet.get_value_of_key({"retweeted_status", strlen("retweeted_status")});
+      switch (retweet.get_type()) {
+        case TYPE_OBJECT: {
+          auto retweet_user = retweet.get_value_of_key({"user", strlen("user")});
+          if (retweet_user.get_type() != TYPE_OBJECT) { return false; }
+          result.push_back(get_str_uint64(retweet_user, "id_str"));
+          break;
+        }
+        // TODO distinguish null and missing. null is bad. missing is fine.
+        case TYPE_NULL:
+          break;
+        default:
+          return false;
+      }
+    }
+
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(distinct_user_id, sajson)->UseManualTime();
+
+} // namespace distinct_user_id
+
+#endif // SIMDJSON_COMPETITION_SAJSON
+

benchmark/distinct_user_id/simdjson_dom.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "distinct_user_id.h"
+
+namespace distinct_user_id {
+
+using namespace simdjson;
+
+struct simdjson_dom {
+  dom::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+    // Walk the document, parsing as we go
+    auto doc = parser.parse(json);
+    for (dom::object tweet : doc["statuses"]) {
+      // We believe that all statuses have a matching
+      // user, and we are willing to throw when they do not.
+      result.push_back(tweet["user"]["id"]);
+      // Not all tweets have a "retweeted_status", but when they do
+      // we want to go and find the user within.
+      auto retweet = tweet["retweeted_status"];
+      if (retweet.error() != NO_SUCH_FIELD) {
+        result.push_back(retweet["user"]["id"]);
+      }
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(distinct_user_id, simdjson_dom)->UseManualTime();
+
+} // namespace distinct_user_id
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/distinct_user_id/simdjson_ondemand.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "distinct_user_id.h"
+
+namespace distinct_user_id {
+
+using namespace simdjson;
+
+struct simdjson_ondemand {
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+    // Walk the document, parsing as we go
+    auto doc = parser.iterate(json);
+    for (ondemand::object tweet : doc.find_field("statuses")) {
+      // We believe that all statuses have a matching
+      // user, and we are willing to throw when they do not.
+      result.push_back(tweet.find_field("user").find_field("id"));
+      // Not all tweets have a "retweeted_status", but when they do
+      // we want to go and find the user within.
+      auto retweet = tweet.find_field("retweeted_status");
+      if (!retweet.error()) {
+        result.push_back(retweet.find_field("user").find_field("id"));
+      }
+    }
+
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(distinct_user_id, simdjson_ondemand)->UseManualTime();
+
+} // namespace distinct_user_id
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/distinct_user_id/yyjson.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_YYJSON
+
+#include "distinct_user_id.h"
+
+namespace distinct_user_id {
+
+struct yyjson_base {
+  bool run(yyjson_doc *doc, std::vector<uint64_t> &result) {
+    if (!doc) { return false; }
+    yyjson_val *root = yyjson_doc_get_root(doc);
+    if (!yyjson_is_obj(root)) { return false; }
+    yyjson_val *statuses = yyjson_obj_get(root, "statuses");
+    if (!yyjson_is_arr(statuses)) { return false; }
+
+    // Walk the document, parsing the tweets as we go
+    size_t tweet_idx, tweets_max;
+    yyjson_val *tweet;
+    yyjson_arr_foreach(statuses, tweet_idx, tweets_max, tweet) {
+      auto user = yyjson_obj_get(tweet, "user");
+      if (!yyjson_is_obj(user)) { return false; }
+      auto id = yyjson_obj_get(user, "id");
+      if (!yyjson_is_uint(id)) { return false; }
+      result.push_back(yyjson_get_uint(id));
+
+      // Not all tweets have a "retweeted_status", but when they do
+      // we want to go and find the user within.
+      auto retweet = yyjson_obj_get(tweet, "retweeted_status");
+      if (retweet) {
+        if (!yyjson_is_obj(retweet)) { return false; }
+        user = yyjson_obj_get(retweet, "user");
+        if (!yyjson_is_obj(user)) { return false; }
+        id = yyjson_obj_get(user, "id");
+        if (!yyjson_is_uint(id)) { return false; }
+        result.push_back(yyjson_get_sint(id));
+      }
+    }
+
+    return true;
+  }
+
+};
+
+struct yyjson : yyjson_base {
+  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
+  }
+};
+BENCHMARK_TEMPLATE(distinct_user_id, yyjson)->UseManualTime();
+
+struct yyjson_insitu : yyjson_base {
+  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
+  }
+};
+BENCHMARK_TEMPLATE(distinct_user_id, yyjson_insitu)->UseManualTime();
+
+} // namespace distinct_user_id
+
+#endif // SIMDJSON_COMPETITION_YYJSON

benchmark/distinctuseridcompetition.cpp

@@ -1,392 +0,0 @@
-#include "simdjson.h"
-#include <algorithm>
-#include <unistd.h>
-#include <vector>
-
-#include "benchmark.h"
-
-SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
-
-// #define RAPIDJSON_SSE2 // bad for performance
-// #define RAPIDJSON_SSE42 // bad for performance
-#include "rapidjson/document.h"
-#include "rapidjson/reader.h"
-#include "rapidjson/stringbuffer.h"
-#include "rapidjson/writer.h"
-
-#include "sajson.h"
-
-SIMDJSON_POP_DISABLE_WARNINGS
-
-using namespace rapidjson;
-
-bool equals(const char *s1, const char *s2) { return strcmp(s1, s2) == 0; }
-
-void remove_duplicates(std::vector<int64_t> &v) {
-  std::sort(v.begin(), v.end());
-  auto last = std::unique(v.begin(), v.end());
-  v.erase(last, v.end());
-}
-
-void print_vec(const std::vector<int64_t> &v) {
-  for (auto i : v) {
-    std::cout << i << " ";
-  }
-  std::cout << std::endl;
-}
-
-// clang-format off
-
-// simdjson_recurse below come be implemented like so but it is slow:
-/*void simdjson_recurse(std::vector<int64_t> & v, simdjson::dom::element element) {
-  if (element.is<simdjson::dom::array>()) {
-    auto [array, array_error] = element.get<simdjson::dom::array>();
-    for (auto child : array) {
-      if (child.is<simdjson::dom::array>() || child.is<simdjson::dom::object>()) {
-        simdjson_recurse(v, child);
-      }
-    }
-  } else if (element.is<simdjson::dom::object>()) {
-    auto [object, error] = element.get<simdjson::dom::object>();
-    int64_t id;
-    object["user"]["id"].get<int64_t>().tie(id,error);
-    if(!error) {
-      v.push_back(id);
-    }
-    for (auto [key, value] : object) {
-      if (value.is<simdjson::dom::array>() || value.is<simdjson::dom::object>()) {
-        simdjson_recurse(v, value);
-      }
-    }
-  }
-}*/
-// clang-format on
-
-
-void simdjson_recurse(std::vector<int64_t> & v, simdjson::dom::element element) {
-  if (element.is<simdjson::dom::array>()) {
-    auto array = element.get<simdjson::dom::array>();
-    for (auto child : array) {
-      if (child.is<simdjson::dom::array>() || child.is<simdjson::dom::object>()) {
-        simdjson_recurse(v, child);
-      }
-    }
-  } else if (element.is<simdjson::dom::object>()) {
-    auto object = element.get<simdjson::dom::object>();
-    for (auto [key, value] : object) {
-      if((key.size() == 4) && (memcmp(key.data(), "user", 4) == 0)) {
-        // we are in an object under the key "user"
-        if(value.is<simdjson::dom::object>()) {
-          auto child_object = value.get<simdjson::dom::object>();
-          for (auto [child_key, child_value] : child_object) {
-            if((child_key.size() == 2) && (memcmp(child_key.data(), "id", 2) == 0)) {
-              if(child_value.is<int64_t>()) {
-                v.push_back(child_value.get<int64_t>());
-              }
-            }
-            if (child_value.is<simdjson::dom::array>() || child_value.is<simdjson::dom::object>()) {
-              simdjson_recurse(v, child_value);
-            }    
-          }
-        } else if (value.is<simdjson::dom::array>()) {
-          simdjson_recurse(v, value);
-        }
-        // end of: we are in an object under the key "user"
-      } else if (value.is<simdjson::dom::array>() || value.is<simdjson::dom::object>()) {
-          simdjson_recurse(v, value);
-      }
-    }
-  }
-}
-
-__attribute__((noinline)) std::vector<int64_t>
-simdjson_just_dom(simdjson::dom::element doc) {
-  std::vector<int64_t> answer;
-  simdjson_recurse(answer, doc);
-  remove_duplicates(answer);
-  return answer;
-}
-
-__attribute__((noinline)) std::vector<int64_t>
-simdjson_compute_stats(const simdjson::padded_string &p) {
-  std::vector<int64_t> answer;
-  simdjson::dom::parser parser;
-  simdjson::dom::element doc = parser.parse(p);
-  simdjson_recurse(answer, doc);
-  remove_duplicates(answer);
-  return answer;
-}
-
-__attribute__((noinline)) simdjson::error_code
-simdjson_just_parse(const simdjson::padded_string &p) {
-  simdjson::dom::parser parser;
-  return parser.parse(p).error();
-}
-
-void sajson_traverse(std::vector<int64_t> &answer, const sajson::value &node) {
-  using namespace sajson;
-  switch (node.get_type()) {
-  case TYPE_ARRAY: {
-    auto length = node.get_length();
-    for (size_t i = 0; i < length; ++i) {
-      sajson_traverse(answer, node.get_array_element(i));
-    }
-    break;
-  }
-  case TYPE_OBJECT: {
-    auto length = node.get_length();
-    // sajson has O(log n) find_object_key, but we still visit each node anyhow
-    // because we need to visit all values.
-    for (auto i = 0u; i < length; ++i) {
-      auto key = node.get_object_key(i); // expected: sajson::string
-      bool found_user =
-          (key.length() == 4) && (memcmp(key.data(), "user", 4) == 0);
-      if (found_user) {                             // found a user!!!
-        auto user_value = node.get_object_value(i); // get the value
-        if (user_value.get_type() ==
-            TYPE_OBJECT) { // the value should be an object
-          // now we know that we only need one value
-          auto user_value_length = user_value.get_length();
-          auto right_index =
-              user_value.find_object_key(sajson::string("id", 2));
-          if (right_index < user_value_length) {
-            auto v = user_value.get_object_value(right_index);
-            if (v.get_type() == TYPE_INTEGER) { // check that it is an integer
-              answer.push_back(v.get_integer_value()); // record it!
-            } else if (v.get_type() == TYPE_DOUBLE) {
-              answer.push_back((int64_t)v.get_double_value()); // record it!
-            }
-          }
-        }
-      }
-      sajson_traverse(answer, node.get_object_value(i));
-    }
-    break;
-  }
-  case TYPE_NULL:
-  case TYPE_FALSE:
-  case TYPE_TRUE:
-  case TYPE_STRING:
-  case TYPE_DOUBLE:
-  case TYPE_INTEGER:
-    break;
-  default:
-    assert(false && "unknown node type");
-  }
-}
-
-__attribute__((noinline)) std::vector<int64_t>
-sasjon_just_dom(sajson::document &d) {
-  std::vector<int64_t> answer;
-  sajson_traverse(answer, d.get_root());
-  remove_duplicates(answer);
-  return answer;
-}
-
-__attribute__((noinline)) std::vector<int64_t>
-sasjon_compute_stats(const simdjson::padded_string &p) {
-  std::vector<int64_t> answer;
-  char *buffer = (char *)malloc(p.size());
-  memcpy(buffer, p.data(), p.size());
-  auto d = sajson::parse(sajson::dynamic_allocation(),
-                         sajson::mutable_string_view(p.size(), buffer));
-  if (!d.is_valid()) {
-    free(buffer);
-    return answer;
-  }
-  sajson_traverse(answer, d.get_root());
-  free(buffer);
-  remove_duplicates(answer);
-  return answer;
-}
-
-__attribute__((noinline)) bool
-sasjon_just_parse(const simdjson::padded_string &p) {
-  char *buffer = (char *)malloc(p.size());
-  memcpy(buffer, p.data(), p.size());
-  auto d = sajson::parse(sajson::dynamic_allocation(),
-                         sajson::mutable_string_view(p.size(), buffer));
-  bool answer = !d.is_valid();
-  free(buffer);
-  return answer;
-}
-
-void rapid_traverse(std::vector<int64_t> &answer, const rapidjson::Value &v) {
-  switch (v.GetType()) {
-  case kObjectType:
-    for (Value::ConstMemberIterator m = v.MemberBegin(); m != v.MemberEnd();
-         ++m) {
-      bool found_user = (m->name.GetStringLength() == 4) &&
-                        (memcmp(m->name.GetString(), "user", 4) == 0);
-      if (found_user) {
-        const rapidjson::Value &child = m->value;
-        if (child.GetType() == kObjectType) {
-          for (Value::ConstMemberIterator k = child.MemberBegin();
-               k != child.MemberEnd(); ++k) {
-            if (equals(k->name.GetString(), "id")) {
-              const rapidjson::Value &val = k->value;
-              if (val.GetType() == kNumberType) {
-                answer.push_back(val.GetInt64());
-              }
-            }
-          }
-        }
-      }
-      rapid_traverse(answer, m->value);
-    }
-    break;
-  case kArrayType:
-    for (Value::ConstValueIterator i = v.Begin(); i != v.End();
-         ++i) { // v.Size();
-      rapid_traverse(answer, *i);
-    }
-    break;
-  case kNullType:
-  case kFalseType:
-  case kTrueType:
-  case kStringType:
-  case kNumberType:
-  default:
-    break;
-  }
-}
-
-__attribute__((noinline)) std::vector<int64_t>
-rapid_just_dom(rapidjson::Document &d) {
-  std::vector<int64_t> answer;
-  rapid_traverse(answer, d);
-  remove_duplicates(answer);
-  return answer;
-}
-
-__attribute__((noinline)) std::vector<int64_t>
-rapid_compute_stats(const simdjson::padded_string &p) {
-  std::vector<int64_t> answer;
-  char *buffer = (char *)malloc(p.size() + 1);
-  memcpy(buffer, p.data(), p.size());
-  buffer[p.size()] = '\0';
-  rapidjson::Document d;
-  d.ParseInsitu<kParseValidateEncodingFlag>(buffer);
-  if (d.HasParseError()) {
-    free(buffer);
-    return answer;
-  }
-  rapid_traverse(answer, d);
-  free(buffer);
-  remove_duplicates(answer);
-  return answer;
-}
-
-__attribute__((noinline)) bool
-rapid_just_parse(const simdjson::padded_string &p) {
-  char *buffer = (char *)malloc(p.size() + 1);
-  memcpy(buffer, p.data(), p.size());
-  buffer[p.size()] = '\0';
-  rapidjson::Document d;
-  d.ParseInsitu<kParseValidateEncodingFlag>(buffer);
-  bool answer = d.HasParseError();
-  free(buffer);
-  return answer;
-}
-
-int main(int argc, char *argv[]) {
-  bool verbose = false;
-  bool just_data = false;
-
-  int c;
-  while ((c = getopt(argc, argv, "vt")) != -1)
-    switch (c) {
-    case 't':
-      just_data = true;
-      break;
-    case 'v':
-      verbose = true;
-      break;
-    default:
-      abort();
-    }
-  if (optind >= argc) {
-    std::cerr
-        << "Using different parsers, we compute the content statistics of "
-           "JSON documents."
-        << std::endl;
-    std::cerr << "Usage: " << argv[0] << " <jsonfile>" << std::endl;
-    std::cerr << "Or " << argv[0] << " -v <jsonfile>" << std::endl;
-    exit(1);
-  }
-  const char *filename = argv[optind];
-  if (optind + 1 < argc) {
-    std::cerr << "warning: ignoring everything after " << argv[optind + 1]
-              << std::endl;
-  }
-  auto [p, error] = simdjson::padded_string::load(filename);
-  if (error) {
-    std::cerr << "Could not load the file " << filename << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  if (verbose) {
-    std::cout << "Input has ";
-    if (p.size() > 1024 * 1024)
-      std::cout << p.size() / (1024 * 1024) << " MB ";
-    else if (p.size() > 1024)
-      std::cout << p.size() / 1024 << " KB ";
-    else
-      std::cout << p.size() << " B ";
-    std::cout << std::endl;
-  }
-  std::vector<int64_t> s1 = simdjson_compute_stats(p);
-  if (verbose) {
-    printf("simdjson: ");
-    print_vec(s1);
-  }
-  std::vector<int64_t> s2 = rapid_compute_stats(p);
-  if (verbose) {
-    printf("rapid:    ");
-    print_vec(s2);
-  }
-  std::vector<int64_t> s3 = sasjon_compute_stats(p);
-  if (verbose) {
-    printf("sasjon:   ");
-    print_vec(s3);
-  }
-  assert(s1 == s2);
-  assert(s1 == s3);
-  size_t size = s1.size();
-
-  int repeat = 500;
-  int volume = p.size();
-  if (just_data) {
-    printf(
-        "name cycles_per_byte cycles_per_byte_err  gb_per_s gb_per_s_err \n");
-  }
-  BEST_TIME("simdjson ", simdjson_compute_stats(p).size(), size, , repeat,
-            volume, !just_data);
-  BEST_TIME("rapid  ", rapid_compute_stats(p).size(), size, , repeat, volume,
-            !just_data);
-  BEST_TIME("sasjon  ", sasjon_compute_stats(p).size(), size, , repeat, volume,
-            !just_data);
-  BEST_TIME("simdjson (just parse)  ", simdjson_just_parse(p), simdjson::error_code::SUCCESS, , repeat,
-            volume, !just_data);
-  BEST_TIME("rapid  (just parse) ", rapid_just_parse(p), false, , repeat,
-            volume, !just_data);
-  BEST_TIME("sasjon (just parse) ", sasjon_just_parse(p), false, , repeat,
-            volume, !just_data);
-  simdjson::dom::parser parser;
-  simdjson::dom::element doc = parser.parse(p);
-  BEST_TIME("simdjson (just dom)  ", simdjson_just_dom(doc).size(), size,
-            , repeat, volume, !just_data);
-  char *buffer = (char *)malloc(p.size() + 1);
-  buffer[p.size()] = '\0';
-  memcpy(buffer, p.data(), p.size());
-  rapidjson::Document drapid;
-  drapid.ParseInsitu<kParseValidateEncodingFlag>(buffer);
-  BEST_TIME("rapid  (just dom) ", rapid_just_dom(drapid).size(), size, , repeat,
-            volume, !just_data);
-  memcpy(buffer, p.data(), p.size());
-  auto dsasjon = sajson::parse(sajson::dynamic_allocation(),
-                               sajson::mutable_string_view(p.size(), buffer));
-  BEST_TIME("sasjon (just dom) ", sasjon_just_dom(dsasjon).size(), size, ,
-            repeat, volume, !just_data);
-  free(buffer);
-}

benchmark/event_counter.h

@@ -5,8 +5,8 @@
 #include <cctype>
 #ifndef _MSC_VER
 #include <dirent.h>
-#include <unistd.h>
 #endif
+#include <unistd.h>
 #include <cinttypes>
 
 #include <cstdio>
@@ -56,11 +56,11 @@ struct event_count {
 
   double elapsed_sec() const { return duration<double>(elapsed).count(); }
   double elapsed_ns() const { return duration<double, std::nano>(elapsed).count(); }
-  double cycles() const { return event_counts[CPU_CYCLES]; }
-  double instructions() const { return event_counts[INSTRUCTIONS]; }
-  double branch_misses() const { return event_counts[BRANCH_MISSES]; }
-  double cache_references() const { return event_counts[CACHE_REFERENCES]; }
-  double cache_misses() const { return event_counts[CACHE_MISSES]; }
+  double cycles() const { return static_cast<double>(event_counts[CPU_CYCLES]); }
+  double instructions() const { return static_cast<double>(event_counts[INSTRUCTIONS]); }
+  double branch_misses() const { return static_cast<double>(event_counts[BRANCH_MISSES]); }
+  double cache_references() const { return static_cast<double>(event_counts[CACHE_REFERENCES]); }
+  double cache_misses() const { return static_cast<double>(event_counts[CACHE_MISSES]); }
 
   event_count& operator=(const event_count& other) {
     this->elapsed = other.elapsed;
@@ -84,9 +84,9 @@ struct event_count {
 
 struct event_aggregate {
   int iterations = 0;
-  event_count total;
-  event_count best;
-  event_count worst;
+  event_count total{};
+  event_count best{};
+  event_count worst{};
 
   event_aggregate() {}
 
@@ -111,35 +111,35 @@ struct event_aggregate {
 };
 
 struct event_collector {
-  event_count count;
-  time_point<steady_clock> start_clock;
+  event_count count{};
+  time_point<steady_clock> start_clock{};
 
 #if defined(__linux__)
   LinuxEvents<PERF_TYPE_HARDWARE> linux_events;
-  event_collector() : linux_events(vector<int>{
+  event_collector(bool quiet = false) : linux_events(vector<int>{
     PERF_COUNT_HW_CPU_CYCLES,
     PERF_COUNT_HW_INSTRUCTIONS,
     PERF_COUNT_HW_BRANCH_MISSES,
     PERF_COUNT_HW_CACHE_REFERENCES,
     PERF_COUNT_HW_CACHE_MISSES
-  }) {}
+  }, quiet) {}
   bool has_events() {
     return linux_events.is_working();
   }
 #else
-  event_collector() {}
+  event_collector(simdjson_unused bool _quiet = false) {}
   bool has_events() {
     return false;
   }
 #endif
 
-  really_inline void start() {
+  simdjson_really_inline void start() {
 #if defined(__linux)
     linux_events.start();
 #endif
     start_clock = steady_clock::now();
   }
-  really_inline event_count& end() {
+  simdjson_really_inline event_count& end() {
     time_point<steady_clock> end_clock = steady_clock::now();
 #if defined(__linux)
     linux_events.end(count.event_counts);
@@ -149,4 +149,4 @@ struct event_collector {
   }
 };
 
-#endif
+#endif

benchmark/find_tweet/find_tweet.h

@@ -0,0 +1,40 @@
+
+#pragma once
+
+#include "json_benchmark/file_runner.h"
+
+namespace find_tweet {
+
+using namespace json_benchmark;
+
+template<typename I>
+struct runner : public file_runner<I> {
+  typename I::StringType 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 = "";
+    return true;
+  }
+
+  bool run(benchmark::State &) {
+    return this->implementation.run(this->json, 505874901689851904ULL, result);
+  }
+
+  template<typename R>
+  bool diff(benchmark::State &state, runner<R> &reference) {
+    return diff_results(state, result, reference.result, diff_flags::NONE);
+  }
+};
+
+struct simdjson_dom;
+
+template<typename I> simdjson_really_inline static void find_tweet(benchmark::State &state) {
+  run_json_benchmark<runner<I>, runner<simdjson_dom>>(state);
+}
+
+} // namespace find_tweet

benchmark/find_tweet/nlohmann_json.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_NLOHMANN_JSON
+
+#include "find_tweet.h"
+
+namespace find_tweet {
+
+struct nlohmann_json {
+  using StringType=std::string;
+
+  bool run(simdjson::padded_string &json, uint64_t find_id, std::string &result) {
+    auto root = nlohmann::json::parse(json.data(), json.data() + json.size());
+    for (auto tweet : root["statuses"]) {
+      if (tweet["id"] == find_id) {
+        result = tweet["text"];
+        return true;
+      }
+    }
+
+    return false;
+  }
+};
+
+BENCHMARK_TEMPLATE(find_tweet, nlohmann_json)->UseManualTime();
+
+} // namespace find_tweet
+
+#endif // SIMDJSON_COMPETITION_NLOHMANN_JSON

benchmark/find_tweet/rapidjson.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_RAPIDJSON
+
+#include "find_tweet.h"
+
+namespace find_tweet {
+
+using namespace rapidjson;
+
+struct rapidjson_base {
+  using StringType=std::string_view;
+
+  Document doc{};
+
+  bool run(Document &root, uint64_t find_id, std::string_view &result) {
+    if (root.HasParseError() || !root.IsObject()) { return false; }
+    auto statuses = root.FindMember("statuses");
+    if (statuses == root.MemberEnd() || !statuses->value.IsArray()) { return false; }
+    for (auto &tweet : statuses->value.GetArray()) {
+      if (!tweet.IsObject()) { return false; }
+      auto id = tweet.FindMember("id");
+      if (id == tweet.MemberEnd() || !id->value.IsUint64()) { return false; }
+      if (id->value.GetUint64() == find_id) {
+        auto text = tweet.FindMember("text");
+        if (text == tweet.MemberEnd() || !text->value.IsString()) { return false; }
+        result = { text->value.GetString(), text->value.GetStringLength() };
+        return true;
+      }
+    }
+
+    return false;
+  }
+};
+
+struct rapidjson : rapidjson_base {
+  bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
+    return rapidjson_base::run(doc.Parse<kParseValidateEncodingFlag>(json.data()), find_id, result);
+  }
+};
+BENCHMARK_TEMPLATE(find_tweet, rapidjson)->UseManualTime();
+
+struct rapidjson_insitu : rapidjson_base {
+  bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
+    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag>(json.data()), find_id, result);
+  }
+};
+BENCHMARK_TEMPLATE(find_tweet, rapidjson_insitu)->UseManualTime();
+
+} // namespace partial_tweets
+
+#endif // SIMDJSON_COMPETITION_RAPIDJSON

benchmark/find_tweet/sajson.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_SAJSON
+
+#include "find_tweet.h"
+
+namespace find_tweet {
+
+struct sajson {
+  using StringType=std::string_view;
+
+  size_t ast_buffer_size{0};
+  size_t *ast_buffer{nullptr};
+  simdjson_really_inline std::string_view get_string_view(const ::sajson::value &obj, std::string_view key) {
+    auto val = obj.get_value_of_key({key.data(), key.length()});
+    if (val.get_type() != ::sajson::TYPE_STRING) { throw "field is not a string"; }
+    return { val.as_cstring(), val.get_string_length() };
+  }
+  simdjson_really_inline uint64_t get_str_uint64(const ::sajson::value &obj, std::string_view key) {
+    // Since sajson only supports 53-bit numbers, and IDs in twitter.json can be > 53 bits, we read the corresponding id_str and parse that.
+    auto val = obj.get_value_of_key({key.data(), key.length()});
+    if (val.get_type() != ::sajson::TYPE_STRING) { throw "field not a string"; }
+    auto str = val.as_cstring();
+    char *endptr;
+    uint64_t result = strtoull(str, &endptr, 10);
+    if (endptr != &str[val.get_string_length()]) { throw "field is a string, but not an integer string"; }
+    return result;
+  }
+
+  bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
+    if (!ast_buffer) {
+      ast_buffer_size = json.size();
+      ast_buffer = (size_t *)std::malloc(ast_buffer_size * sizeof(size_t));
+    }
+    auto doc = ::sajson::parse(
+      ::sajson::bounded_allocation(ast_buffer, ast_buffer_size),
+      ::sajson::mutable_string_view(json.size(), json.data())
+    );
+    if (!doc.is_valid()) { return false; }
+
+    auto root = doc.get_root();
+    if (root.get_type() != ::sajson::TYPE_OBJECT) { printf("a\n"); return false; }
+    auto statuses = root.get_value_of_key({"statuses", strlen("statuses")});
+    if (statuses.get_type() != ::sajson::TYPE_ARRAY) { return false; }
+
+    for (size_t i=0; i<statuses.get_length(); i++) {
+      auto tweet = statuses.get_array_element(i);
+      if (tweet.get_type() != ::sajson::TYPE_OBJECT) { printf("b\n"); return false; }
+      // TODO if there is a way to get the raw string, it might be faster to iota find_id and then
+      // compare it to each id_str, instead of parsing each int and comparing to find_id.
+      if (get_str_uint64(tweet, "id_str") == find_id) {
+        result = get_string_view(tweet, "text");
+        return true;
+      }
+    }
+
+    return false;
+  }
+};
+
+BENCHMARK_TEMPLATE(find_tweet, sajson)->UseManualTime();
+
+} // namespace find_tweet
+
+#endif // SIMDJSON_COMPETITION_SAJSON
+

benchmark/find_tweet/simdjson_dom.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "find_tweet.h"
+
+namespace find_tweet {
+
+using namespace simdjson;
+
+struct simdjson_dom {
+  using StringType=std::string_view;
+
+  dom::parser parser{};
+
+  bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
+    result = "";
+    auto doc = parser.parse(json);
+    for (auto tweet : doc["statuses"]) {
+      if (uint64_t(tweet["id"]) == find_id) {
+        result = tweet["text"];
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+BENCHMARK_TEMPLATE(find_tweet, simdjson_dom)->UseManualTime();
+
+} // namespace find_tweet
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/find_tweet/simdjson_ondemand.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "find_tweet.h"
+
+namespace find_tweet {
+
+using namespace simdjson;
+
+struct simdjson_ondemand {
+  using StringType=std::string_view;
+
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
+    // Walk the document, parsing as we go
+    auto doc = parser.iterate(json);
+    for (auto tweet : doc.find_field("statuses")) {
+      if (uint64_t(tweet.find_field("id")) == find_id) {
+        result = tweet.find_field("text");
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+BENCHMARK_TEMPLATE(find_tweet, simdjson_ondemand)->UseManualTime();
+
+} // namespace find_tweet
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/find_tweet/yyjson.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_YYJSON
+
+#include "find_tweet.h"
+
+namespace find_tweet {
+
+struct yyjson_base {
+  using StringType=std::string_view;
+
+  bool run(yyjson_doc *doc, uint64_t find_id, std::string_view &result) {
+    if (!doc) { return false; }
+    yyjson_val *root = yyjson_doc_get_root(doc);
+    if (!yyjson_is_obj(root)) { return false; }
+    yyjson_val *statuses = yyjson_obj_get(root, "statuses");
+    if (!yyjson_is_arr(statuses)) { return false; }
+
+    // Walk the document, parsing the tweets as we go
+    size_t tweet_idx, tweets_max;
+    yyjson_val *tweet;
+    yyjson_arr_foreach(statuses, tweet_idx, tweets_max, tweet) {
+      if (!yyjson_is_obj(tweet)) { return false; }
+      auto id = yyjson_obj_get(tweet, "id");
+      if (!yyjson_is_uint(id)) { return false; }
+      if (yyjson_get_uint(id) == find_id) {
+        auto text = yyjson_obj_get(tweet, "text");
+        if (yyjson_is_str(id)) { return false; }
+        result = { yyjson_get_str(text), yyjson_get_len(text) };
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+struct yyjson : yyjson_base {
+  bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), find_id, result);
+  }
+};
+BENCHMARK_TEMPLATE(find_tweet, yyjson)->UseManualTime();
+
+struct yyjson_insitu : yyjson_base {
+  bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), find_id, result);
+  }
+};
+BENCHMARK_TEMPLATE(find_tweet, yyjson_insitu)->UseManualTime();
+
+} // namespace find_tweet
+
+#endif // SIMDJSON_COMPETITION_YYJSON

benchmark/get_corpus_benchmark.cpp

@@ -4,15 +4,16 @@
 #include <cstring>
 #include <iostream>
 
-never_inline
+// Gigabyte: https://en.wikipedia.org/wiki/Gigabyte
+simdjson_never_inline
 double bench(std::string filename, simdjson::padded_string& p) {
   std::chrono::time_point<std::chrono::steady_clock> start_clock =
       std::chrono::steady_clock::now();
-  simdjson::padded_string::load(filename).first.swap(p);
+  simdjson::padded_string::load(filename).value_unsafe().swap(p);
   std::chrono::time_point<std::chrono::steady_clock> end_clock =
       std::chrono::steady_clock::now();
   std::chrono::duration<double> elapsed = end_clock - start_clock;
-  return (p.size() / (1024. * 1024 * 1024.)) / elapsed.count();
+  return (static_cast<double>(p.size()) / (1000000000.)) / elapsed.count();
 }
 
 int main(int argc, char *argv[]) {
@@ -28,12 +29,12 @@ int main(int argc, char *argv[]) {
               << std::endl;
   }
   simdjson::padded_string p;
-  bench(filename, p); 
+  bench(filename, p);
   double meanval = 0;
   double maxval = 0;
   double minval = 10000;
-std::cout << "file size: "<<  (p.size() / (1024. * 1024 * 1024.)) << " GB" <<std::endl;
-  size_t times = p.size() > 1024*1024*1024 ? 5 : 50;
+std::cout << "file size: "<<  (static_cast<double>(p.size()) / (1000000000.)) << " GB" <<std::endl;
+  size_t times = p.size() > 1000000000 ? 5 : 50;
 #if __cpp_exceptions
   try {
 #endif
@@ -49,7 +50,7 @@ std::cout << "file size: "<<  (p.size() / (1024. * 1024 * 1024.)) << " GB" <<std
     return EXIT_FAILURE;
    }
 #endif
-   std::cout << "average speed: " << meanval / times << " GB/s"<< std::endl;
+   std::cout << "average speed: " << meanval / static_cast<double>(times) << " GB/s"<< std::endl;
    std::cout << "min speed    : " << minval << " GB/s" << std::endl;
    std::cout << "max speed    : " << maxval << " GB/s" << std::endl;
    return EXIT_SUCCESS;

benchmark/json_benchmark/constants.h

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace json_benchmark {
+
+static constexpr const char *TWITTER_JSON = SIMDJSON_BENCHMARK_DATA_DIR "twitter.json";
+static constexpr const char *NUMBERS_JSON = SIMDJSON_BENCHMARK_DATA_DIR "numbers.json";
+
+}

benchmark/json_benchmark/diff_results.h

@@ -0,0 +1,92 @@
+#pragma once
+
+#include <vector>
+#include <sstream>
+#include <limits>
+
+namespace json_benchmark {
+
+enum class diff_flags {
+  NONE = 0,
+  IMPRECISE_FLOATS = 1
+};
+
+template<typename T, typename U>
+static bool diff_results(benchmark::State &state, const T &result, const U &reference, diff_flags flags);
+
+template<typename T, typename U>
+struct result_differ {
+  static bool diff(benchmark::State &state, const T &result, const U &reference, diff_flags flags) {
+    if (result != reference) {
+      std::stringstream str;
+      str << "result incorrect: " << result << " ... reference: " << reference;
+      state.SkipWithError(str.str().data());
+      return false;
+    }
+    return true;
+  }
+};
+
+template<typename T, typename U>
+struct result_differ<std::vector<T>, std::vector<U>> {
+  static bool diff(benchmark::State &state, const std::vector<T> &result, const std::vector<U> &reference, diff_flags flags) {
+    auto result_iter = result.begin();
+    auto reference_iter = reference.begin();
+    while (result_iter != result.end() && reference_iter != reference.end()) {
+      if (!diff_results(state, *result_iter, *reference_iter, flags)) { return false; }
+      result_iter++;
+      reference_iter++;
+    }
+    if (result_iter != result.end()) {
+      std::stringstream str;
+      str << "extra results (got " << result.size() << ", expected " << reference.size() << "): first extra element: " << *result_iter;
+      state.SkipWithError(str.str().data());
+      return false;
+    } else if (reference_iter != reference.end()) {
+      std::stringstream str;
+      str << "missing results (got " << result.size() << ", expected " << reference.size() << "): first missing element: " << *reference_iter;
+      state.SkipWithError(str.str().data());
+      return false;
+    }
+    return true;
+  }
+};
+
+template<>
+struct result_differ<double, double> {
+  static bool diff(benchmark::State &state, const double &result, const double &reference, diff_flags flags) {
+    bool different;
+    if (int(flags) & int(diff_flags::IMPRECISE_FLOATS)) {
+      different = f64_ulp_dist(result, reference) > 1;
+    } else {
+      different = result != reference;
+    }
+    if (different) {
+      std::stringstream str;
+      // We print it out using full precision.
+      constexpr auto precision = std::numeric_limits<double>::max_digits10;
+      str << std::setprecision(precision);
+      str << "incorrect double result: " << std::endl;
+      str << "   result: " << std::left << std::setw(precision+2) << result    << " (hexfloat " << std::hexfloat << result    << ")" << std::defaultfloat << std::endl;
+      str << "reference: " << std::left << std::setw(precision+2) << reference << " (hexfloat " << std::hexfloat << reference << ")" << std::defaultfloat << std::endl;
+      state.SkipWithError(str.str().data());
+    }
+    return true;
+  }
+
+  static uint64_t f64_ulp_dist(double a, double b) {
+    uint64_t ua, ub;
+    std::memcpy(&ua, &a, sizeof(ua));
+    std::memcpy(&ub, &b, sizeof(ub));
+    if ((int64_t)(ub ^ ua) >= 0)
+      return (int64_t)(ua - ub) >= 0 ? (ua - ub) : (ub - ua);
+    return ua + ub + 0x80000000;
+  }
+};
+
+template<typename T, typename U>
+static bool diff_results(benchmark::State &state, const T &result, const U &reference, diff_flags flags) {
+  return result_differ<T, U>::diff(state, result, reference, flags);
+}
+
+} // namespace json_benchmark

benchmark/json_benchmark/file_runner.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "json_benchmark/runner_base.h"
+#include "simdjson.h"
+
+namespace json_benchmark {
+
+template<typename I>
+struct file_runner : public runner_base<I> {
+  simdjson::padded_string original_json{};
+  simdjson::padded_string json{};
+
+  simdjson_warn_unused bool load_json(benchmark::State &state, const char *file) {
+    simdjson::error_code error;
+    if ((error = simdjson::padded_string::load(file).get(original_json))) {
+      std::stringstream err;
+      err << "error loading " << file << ": " << error;
+      state.SkipWithError(err.str().data());
+      return false;
+    }
+    json = simdjson::padded_string(original_json.data(), original_json.size());
+    return true;
+  }
+
+  simdjson_warn_unused bool before_run(benchmark::State &state) {
+    if (!runner_base<I>::after_run(state)) { return false; };
+    // Copy the original json in case we did *in situ* last time
+    std::memcpy(json.data(), original_json.data(), original_json.size());
+    return true;
+  }
+
+  /** Get the total number of bytes processed in each iteration. Used for metrics like bytes/second. */
+  size_t bytes_per_iteration() {
+    return json.size();
+  }
+
+  /** Get the total number of documents processed in each iteration. Used for metrics like documents/second. */
+  size_t documents_per_iteration() {
+    return 1;
+  }
+
+  /** Get the total number of items processed in each iteration. Used for metrics like items/second. */
+  size_t items_per_iteration() {
+    return 1;
+  }
+};
+
+} // namespace json_benchmark

benchmark/json_benchmark/point.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "diff_results.h"
+
+namespace json_benchmark {
+
+struct point {
+  double x;
+  double y;
+  double z;
+};
+
+template<>
+struct result_differ<point, point> {
+  static bool diff(benchmark::State &state, const point &result, const point &reference, diff_flags flags) {
+    return diff_results(state, result.x, reference.x, flags)
+        && diff_results(state, result.y, reference.y, flags)
+        && diff_results(state, result.z, reference.z, flags);
+  }
+};
+
+static simdjson_unused std::ostream &operator<<(std::ostream &o, const point &p) {
+  return o << p.x << "," << p.y << "," << p.z << std::endl;
+}
+
+} // namespace json_benchmark

benchmark/json_benchmark/run_json_benchmark.h

@@ -0,0 +1,107 @@
+#pragma once
+
+#include "simdjson.h"
+#include "event_counter.h"
+#include <iostream>
+
+namespace json_benchmark {
+
+void maybe_display_implementation() {
+  static bool displayed_implementation = false;
+  if(!displayed_implementation) {
+    displayed_implementation = true;
+    std::cout << "simdjson::dom implementation:      " << simdjson::active_implementation->name() << std::endl;
+    std::cout << "simdjson::ondemand implementation (stage 1): " << simdjson::active_implementation->name() << std::endl;
+    std::cout << "simdjson::ondemand implementation (stage 2): " << simdjson::builtin_implementation()->name() << std::endl;
+  }
+}
+
+template<typename B, typename R> static void run_json_benchmark(benchmark::State &state) {
+  maybe_display_implementation();
+
+  event_collector collector(true);
+  event_aggregate events;
+
+  // Warmup and equality check (make sure the data is right!)
+  B bench;
+  if (!bench.setup(state)) { return; }
+  if (!bench.before_run(state)) { state.SkipWithError("warmup document before_run failed"); return; }
+  if (!bench.run(state)) { state.SkipWithError("warmup document reading failed"); return; }
+  if (!bench.after_run(state)) { state.SkipWithError("warmup document after_run failed"); return; }
+  {
+    R reference;
+    if (!reference.setup(state)) { return; }
+    if (!reference.before_run(state)) { state.SkipWithError("reference before_run failed"); };
+    if (!reference.run(state)) { state.SkipWithError("reference document reading failed"); return; }
+    if (!reference.after_run(state)) { state.SkipWithError("reference before_run failed"); };
+    if (!bench.diff(state, reference)) { return; }
+  }
+
+  // Run the benchmark
+  for (simdjson_unused auto _ : state) {
+    if (!bench.before_run(state)) { state.SkipWithError("before_run failed"); };
+    collector.start();
+    if (!bench.run(state)) { state.SkipWithError("run failed"); return; }
+    auto event = collector.end();
+    events << event;
+    state.SetIterationTime(event.elapsed_sec());
+    if (!bench.after_run(state)) { state.SkipWithError("after_run failed"); return; };
+  }
+
+  state.SetBytesProcessed(bench.bytes_per_iteration() * state.iterations());
+  state.SetItemsProcessed(bench.items_per_iteration() * state.iterations());
+  state.counters["best_docs_per_sec"] = benchmark::Counter(double(bench.documents_per_iteration()) / events.best.elapsed_sec());
+  state.counters["best_bytes_per_sec"] = benchmark::Counter(double(bench.bytes_per_iteration()) / events.best.elapsed_sec());
+  state.counters["best_items_per_sec"] = benchmark::Counter(double(bench.items_per_iteration()) / events.best.elapsed_sec());
+  state.counters["docs_per_sec"] = benchmark::Counter(double(bench.documents_per_iteration()), benchmark::Counter::kIsIterationInvariantRate);
+
+  if (collector.has_events()) {
+    state.counters["instructions"] = events.instructions();
+    state.counters["cycles"]       = events.cycles();
+    state.counters["branch_miss"]  = events.branch_misses();
+    state.counters["cache_miss"]   = events.cache_misses();
+    state.counters["cache_ref"]    = events.cache_references();
+
+    state.counters["instructions_per_byte"]  = events.instructions() / double(bench.bytes_per_iteration());
+    state.counters["instructions_per_cycle"] = events.instructions() / events.cycles();
+    state.counters["cycles_per_byte"]        = events.cycles()       / double(bench.bytes_per_iteration());
+    state.counters["frequency"]              = benchmark::Counter(events.cycles(), benchmark::Counter::kIsIterationInvariantRate);
+
+    state.counters["best_instructions"] = events.best.instructions();
+    state.counters["best_cycles"]       = events.best.cycles();
+    state.counters["best_branch_miss"]  = events.best.branch_misses();
+    state.counters["best_cache_miss"]   = events.best.cache_misses();
+    state.counters["best_cache_ref"]    = events.best.cache_references();
+
+    state.counters["best_instructions_per_byte"]  = events.best.instructions() / double(bench.bytes_per_iteration());
+    state.counters["best_instructions_per_cycle"] = events.best.instructions() / events.best.cycles();
+    state.counters["best_cycles_per_byte"]        = events.best.cycles()       / double(bench.bytes_per_iteration());
+    state.counters["best_frequency"]              = events.best.cycles()       / events.best.elapsed_sec();
+  }
+  state.counters["bytes"] = benchmark::Counter(double(bench.bytes_per_iteration()));
+  state.counters["items"] = benchmark::Counter(double(bench.items_per_iteration()));
+
+  // Build the label
+  using namespace std;
+  stringstream label;
+  label << fixed << setprecision(2);
+  label << "[BEST:";
+  label << " throughput="     << setw(6)  << (double(bench.bytes_per_iteration()) / 1000000000.0     / events.best.elapsed_sec()) << " GB/s";
+  label << " doc_throughput=" << setw(6)  << uint64_t(bench.documents_per_iteration()                / events.best.elapsed_sec()) << " docs/s";
+
+  if (collector.has_events()) {
+    label << " instructions=" << setw(12) << uint64_t(events.best.instructions())     << setw(0);
+    label << " cycles="       << setw(12) << uint64_t(events.best.cycles())           << setw(0);
+    label << " branch_miss="  << setw(8)  << uint64_t(events.best.branch_misses())    << setw(0);
+    label << " cache_miss="   << setw(8)  << uint64_t(events.best.cache_misses())     << setw(0);
+    label << " cache_ref="    << setw(10) << uint64_t(events.best.cache_references()) << setw(0);
+  }
+
+  label << " items=" << setw(10) << bench.items_per_iteration() << setw(0);
+  label << " avg_time=" << setw(10) << uint64_t(events.elapsed_ns()) << setw(0) << " ns";
+  label << "]";
+
+  state.SetLabel(label.str());
+}
+
+} // namespace json_benchmark

benchmark/json_benchmark/runner_base.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "constants.h"
+#include "run_json_benchmark.h"
+#include "diff_results.h"
+
+namespace json_benchmark {
+
+//
+// Extend this to create a new type of test (e.g. partial_tweets).
+//
+template<typename I>
+struct runner_base {
+  /** Run once, before all iterations. */
+  simdjson_warn_unused bool setup(benchmark::State &) { return true; }
+
+  /** Run on each iteration. This is what gets benchmarked. */
+  simdjson_warn_unused bool run(benchmark::State &state) {
+    return implementation.run(state);
+  }
+
+  /** Called before each iteration, to clear / set up state. */
+  simdjson_warn_unused bool before_run(benchmark::State &state) { return true; }
+
+  /** Called after each iteration, to tear down / massage state. */
+  simdjson_warn_unused bool after_run(benchmark::State &) { return true; }
+
+  /** Get the total number of bytes processed in each iteration. Used for metrics like bytes/second. */
+  size_t bytes_per_iteration();
+
+  /** Get the total number of documents processed in each iteration. Used for metrics like documents/second. */
+  size_t documents_per_iteration();
+
+  /** Get the total number of items processed in each iteration. Used for metrics like items/second. */
+  size_t items_per_iteration();
+
+  I implementation{};
+};
+
+}

benchmark/json_benchmark/string_runner.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "runner_base.h"
+#include "simdjson.h"
+
+namespace json_benchmark {
+
+template<typename I>
+struct string_runner : public runner_base<I> {
+  const simdjson::padded_string &original_json;
+  simdjson::padded_string json;
+  string_runner(const simdjson::padded_string &_json) : original_json{_json}, json(original_json.data(), original_json.size()) {}
+
+  simdjson_warn_unused bool before_run(benchmark::State &state) {
+    if (!runner_base<I>::after_run(state)) { return false; };
+    // Copy the original json in case we did *in situ*
+    std::memcpy(json.data(), original_json.data(), original_json.size());
+    return true;
+  }
+
+  /** Get the total number of bytes processed in each iteration. Used for metrics like bytes/second. */
+  size_t bytes_per_iteration() {
+    return json.size();
+  }
+
+  /** Get the total number of documents processed in each iteration. Used for metrics like documents/second. */
+  size_t documents_per_iteration() {
+    return 1;
+  }
+
+  /** Get the total number of items processed in each iteration. Used for metrics like items/second. */
+  size_t items_per_iteration() {
+    return 1;
+  }
+};
+
+} // namespace json_benchmark

benchmark/kostya/kostya.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#include "json_benchmark/string_runner.h"
+#include "json_benchmark/point.h"
+#include <vector>
+#include <random>
+
+namespace kostya {
+
+using namespace json_benchmark;
+
+static const simdjson::padded_string &get_built_json_array();
+
+template<typename I>
+struct runner : public string_runner<I> {
+  std::vector<point> result;
+
+  runner() : string_runner<I>(get_built_json_array()) {}
+
+  bool before_run(benchmark::State &state) {
+    if (!string_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, I::DiffFlags);
+  }
+
+  size_t items_per_iteration() {
+    return result.size();
+  }
+};
+
+static void append_coordinate(std::default_random_engine &e, std::uniform_real_distribution<> &dis, std::stringstream &myss) {
+  using std::endl;
+  myss << R"(        {)" << endl;
+  myss << R"(            "x": )" << dis(e) << "," << endl;
+  myss << R"(            "y": )" << dis(e) << "," << endl;
+  myss << R"(            "z": )" << dis(e) << "," << endl;
+  myss << R"(            "name": ")" << char('a'+dis(e)*25) << char('a'+dis(e)*25) << char('a'+dis(e)*25) << char('a'+dis(e)*25) << char('a'+dis(e)*25) << char('a'+dis(e)*25) << " " << int(dis(e)*10000) << "\"," << endl;
+  myss << R"(            "opts": {)" << endl;
+  myss << R"(                "1": [)" << endl;
+  myss << R"(                    1,)" << endl;
+  myss << R"(                    true)" << endl;
+  myss << R"(                ])" << endl;
+  myss << R"(            })" << endl;
+  myss << R"(        })";
+}
+
+static std::string build_json_array(size_t N) {
+  using namespace std;
+  default_random_engine e;
+  uniform_real_distribution<> dis(0, 1);
+  stringstream myss;
+  myss << R"({)" << endl;
+  myss << R"(    "coordinates": [)" << endl;
+  for (size_t i=1; i<N; i++) {
+    append_coordinate(e, dis, myss); myss << "," << endl;
+  }
+  append_coordinate(e, dis, myss); myss << endl;
+  myss << R"(    ],)" << endl;
+  myss << R"(    "info": "some info")" << endl;
+  myss << R"(})" << endl;
+  string answer = myss.str();
+  cout << "Creating a source file spanning " << (answer.size() + 512) / 1024 << " KB " << endl;
+  return answer;
+}
+
+static const simdjson::padded_string &get_built_json_array() {
+  static simdjson::padded_string json = build_json_array(524288);
+  return json;
+}
+
+struct simdjson_dom;
+
+template<typename I> simdjson_really_inline static void kostya(benchmark::State &state) {
+  run_json_benchmark<runner<I>, runner<simdjson_dom>>(state);
+}
+
+} // namespace kostya

benchmark/kostya/nlohmann_json.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_NLOHMANN_JSON
+
+#include "kostya.h"
+
+namespace kostya {
+
+struct nlohmann_json {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    auto root = nlohmann::json::parse(json.data(), json.data() + json.size());
+    for (auto point : root["coordinates"]) {
+      result.emplace_back(json_benchmark::point{point["x"], point["y"], point["z"]});
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(kostya, nlohmann_json)->UseManualTime();
+
+} // namespace kostya
+
+#endif // SIMDJSON_COMPETITION_NLOHMANN_JSON

benchmark/kostya/rapidjson.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_RAPIDJSON
+
+#include "kostya.h"
+
+namespace kostya {
+
+using namespace rapidjson;
+
+struct rapidjson_base {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  Document doc;
+
+  simdjson_really_inline double get_double(Value &object, std::string_view key) {
+    auto field = object.FindMember(key.data());
+    if (field == object.MemberEnd()) { throw "Missing double field"; }
+    if (!field->value.IsNumber()) { throw "Field is not double"; }
+    return field->value.GetDouble();
+  }
+
+  bool run(Document &root, std::vector<point> &result) {
+    if (root.HasParseError()) { return false; }
+    if (!root.IsObject()) { return false; }
+    auto coords = root.FindMember("coordinates");
+    if (coords == root.MemberEnd()) { return false; }
+    if (!coords->value.IsArray()) { return false; }
+    for (auto &coord : coords->value.GetArray()) {
+      if (!coord.IsObject()) { return false; }
+      result.emplace_back(json_benchmark::point{get_double(coord, "x"), get_double(coord, "y"), get_double(coord, "z")});
+    }
+
+    return true;
+  }
+};
+
+struct rapidjson : rapidjson_base {
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    return rapidjson_base::run(doc.Parse<kParseValidateEncodingFlag>(json.data()), result);
+  }
+};
+BENCHMARK_TEMPLATE(kostya, rapidjson)->UseManualTime();
+
+struct rapidjson_lossless : rapidjson_base {
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    return rapidjson_base::run(doc.Parse<kParseValidateEncodingFlag | kParseFullPrecisionFlag>(json.data()), result);
+  }
+};
+BENCHMARK_TEMPLATE(kostya, rapidjson_lossless)->UseManualTime();
+
+struct rapidjson_insitu : rapidjson_base {
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag>(json.data()), result);
+  }
+};
+BENCHMARK_TEMPLATE(kostya, rapidjson_insitu)->UseManualTime();
+
+} // namespace kostya
+
+#endif // SIMDJSON_COMPETITION_RAPIDJSON

benchmark/kostya/sajson.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_SAJSON
+
+#include "kostya.h"
+
+namespace kostya {
+
+struct sajson {
+  static constexpr diff_flags DiffFlags = diff_flags::IMPRECISE_FLOATS;
+
+  size_t ast_buffer_size{0};
+  size_t *ast_buffer{nullptr};
+
+  simdjson_really_inline double get_double(const ::sajson::value &obj, std::string_view key) {
+    using namespace sajson;
+
+    auto val = obj.get_value_of_key({key.data(), key.length()});
+    switch (val.get_type()) {
+      case TYPE_INTEGER:
+      case TYPE_DOUBLE:
+        return val.get_number_value();
+      default:
+        throw "field not double";
+    }
+  }
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    using namespace sajson;
+
+    if (!ast_buffer) {
+      ast_buffer_size = json.size();
+      ast_buffer = (size_t *)std::malloc(ast_buffer_size * sizeof(size_t));
+    }
+    auto doc = parse(
+      bounded_allocation(ast_buffer, ast_buffer_size),
+      mutable_string_view(json.size(), json.data())
+    );
+    if (!doc.is_valid()) { return false; }
+
+    auto root = doc.get_root();
+    if (root.get_type() != TYPE_OBJECT) { return false; }
+    auto points = root.get_value_of_key({"coordinates", strlen("coordinates")});
+    if (points.get_type() != TYPE_ARRAY) { return false; }
+
+    for (size_t i=0; i<points.get_length(); i++) {
+      auto point = points.get_array_element(i);
+      if (point.get_type() != TYPE_OBJECT) { return false; }
+      result.emplace_back(json_benchmark::point{
+        get_double(point, "x"),
+        get_double(point, "y"),
+        get_double(point, "z")
+      });
+    }
+
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(kostya, sajson)->UseManualTime();
+
+} // namespace kostya
+
+#endif // SIMDJSON_COMPETITION_SAJSON
+

benchmark/kostya/simdjson_dom.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "kostya.h"
+
+namespace kostya {
+
+using namespace simdjson;
+
+struct simdjson_dom {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  dom::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    for (auto point : parser.parse(json)["coordinates"]) {
+      result.emplace_back(json_benchmark::point{point["x"], point["y"], point["z"]});
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(kostya, simdjson_dom)->UseManualTime();
+
+} // namespace kostya
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/kostya/simdjson_ondemand.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "kostya.h"
+
+namespace kostya {
+
+using namespace simdjson;
+
+struct simdjson_ondemand {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    auto doc = parser.iterate(json);
+    for (ondemand::object point : doc.find_field("coordinates")) {
+      result.emplace_back(json_benchmark::point{point.find_field("x"), point.find_field("y"), point.find_field("z")});
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(kostya, simdjson_ondemand)->UseManualTime();
+
+} // namespace kostya
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/kostya/yyjson.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_YYJSON
+
+#include "kostya.h"
+
+namespace kostya {
+
+struct yyjson_base {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  simdjson_really_inline double get_double(yyjson_val *obj, std::string_view key) {
+    yyjson_val *val = yyjson_obj_getn(obj, key.data(), key.length());
+    if (!val) { throw "missing point field!"; }
+    if (yyjson_get_type(val) != YYJSON_TYPE_NUM) { throw "Number is not a type!"; }
+
+    switch (yyjson_get_subtype(val)) {
+      case YYJSON_SUBTYPE_UINT:
+        return double(yyjson_get_uint(val));
+      case YYJSON_SUBTYPE_SINT:
+        return double(yyjson_get_sint(val));
+      case YYJSON_SUBTYPE_REAL:
+        return yyjson_get_real(val);
+      default:
+        SIMDJSON_UNREACHABLE();
+    }
+    SIMDJSON_UNREACHABLE();
+    return 0.0; // unreachable
+  }
+
+  bool run(yyjson_doc *doc, std::vector<point> &result) {
+    if (!doc) { return false; }
+    yyjson_val *root = yyjson_doc_get_root(doc);
+    if (!yyjson_is_obj(root)) { return false; }
+    yyjson_val *coords = yyjson_obj_get(root, "coordinates");
+    if (!yyjson_is_arr(coords)) { return false; }
+
+    size_t idx, max;
+    yyjson_val *coord;
+    yyjson_arr_foreach(coords, idx, max, coord) {
+      if (!yyjson_is_obj(coord)) { return false; }
+      result.emplace_back(json_benchmark::point{get_double(coord, "x"), get_double(coord, "y"), get_double(coord, "z")});
+    }
+
+    return true;
+  }
+
+};
+
+struct yyjson : yyjson_base {
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
+  }
+};
+BENCHMARK_TEMPLATE(kostya, yyjson)->UseManualTime();
+
+struct yyjson_insitu : yyjson_base {
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
+  }
+};
+BENCHMARK_TEMPLATE(kostya, yyjson_insitu)->UseManualTime();
+
+} // namespace kostya
+
+#endif // SIMDJSON_COMPETITION_YYJSON

benchmark/large_random/large_random.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include "json_benchmark/string_runner.h"
+#include "json_benchmark/point.h"
+#include <random>
+
+namespace large_random {
+
+static const simdjson::padded_string &get_built_json_array();
+
+using namespace json_benchmark;
+
+simdjson_unused static std::ostream &operator<<(std::ostream &o, const point &p) {
+  return o << p.x << "," << p.y << "," << p.z << std::endl;
+}
+
+template<typename I>
+struct runner : public string_runner<I> {
+  std::vector<point> result;
+
+  runner() : string_runner<I>(get_built_json_array()) {}
+
+  bool before_run(benchmark::State &state) {
+    if (!string_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, I::DiffFlags);
+  }
+
+  size_t items_per_iteration() {
+    return result.size();
+  }
+};
+
+static std::string build_json_array(size_t N) {
+  std::default_random_engine e;
+  std::uniform_real_distribution<> dis(0, 1);
+  std::stringstream myss;
+  myss << "[" << std::endl;
+  if(N > 0) {
+    myss << "{ \"x\":" << dis(e) << ",  \"y\":" << dis(e) << ", \"z\":" << dis(e) << "}" << std::endl;
+  }
+  for(size_t i = 1; i < N; i++) {
+    myss << "," << std::endl;
+    myss << "{ \"x\":" << dis(e) << ",  \"y\":" << dis(e) << ", \"z\":" << dis(e) << "}";
+  }
+  myss << std::endl;
+  myss << "]" << std::endl;
+  std::string answer = myss.str();
+  std::cout << "Creating a source file spanning " << (answer.size() + 512) / 1024 << " KB " << std::endl;
+  return answer;
+}
+
+static const simdjson::padded_string &get_built_json_array() {
+  static simdjson::padded_string json = build_json_array(1000000);
+  return json;
+}
+
+struct simdjson_dom;
+
+template<typename T> static void large_random(benchmark::State &state) {
+  run_json_benchmark<runner<T>, runner<simdjson_dom>>(state);
+}
+
+} // namespace large_random

benchmark/large_random/nlohmann_json.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_NLOHMANN_JSON
+
+#include "large_random.h"
+
+namespace large_random {
+
+struct nlohmann_json {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    for (auto point : nlohmann::json::parse(json.data(), json.data() + json.size())) {
+      result.emplace_back(json_benchmark::point{point["x"], point["y"], point["z"]});
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(large_random, nlohmann_json)->UseManualTime();
+
+} // namespace large_random
+
+#endif // SIMDJSON_COMPETITION_NLOHMANN_JSON

benchmark/large_random/rapidjson.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_RAPIDJSON
+
+#include "large_random.h"
+
+namespace large_random {
+
+using namespace rapidjson;
+
+struct rapidjson_base {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  Document doc;
+
+  simdjson_really_inline double get_double(Value &object, std::string_view key) {
+    auto field = object.FindMember(key.data());
+    if (field == object.MemberEnd()) { throw "Missing double field"; }
+    if (!field->value.IsNumber()) { throw "Field is not double"; }
+    return field->value.GetDouble();
+  }
+
+  bool run(Document &coords, std::vector<point> &result) {
+    if (coords.HasParseError()) { return false; }
+    if (!coords.IsArray()) { return false; }
+    for (auto &coord : coords.GetArray()) {
+      if (!coord.IsObject()) { return false; }
+      result.emplace_back(json_benchmark::point{get_double(coord, "x"), get_double(coord, "y"), get_double(coord, "z")});
+    }
+
+    return true;
+  }
+};
+
+struct rapidjson : rapidjson_base {
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    return rapidjson_base::run(doc.Parse<kParseValidateEncodingFlag>(json.data()), result);
+  }
+};
+BENCHMARK_TEMPLATE(large_random, rapidjson)->UseManualTime();
+
+struct rapidjson_lossless : rapidjson_base {
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    return rapidjson_base::run(doc.Parse<kParseValidateEncodingFlag | kParseFullPrecisionFlag>(json.data()), result);
+  }
+};
+BENCHMARK_TEMPLATE(large_random, rapidjson_lossless)->UseManualTime();
+
+struct rapidjson_insitu : rapidjson_base {
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag>(json.data()), result);
+  }
+};
+BENCHMARK_TEMPLATE(large_random, rapidjson_insitu)->UseManualTime();
+
+
+} // namespace large_random
+
+#endif // SIMDJSON_COMPETITION_RAPIDJSON

benchmark/large_random/sajson.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_SAJSON
+
+#include "large_random.h"
+
+namespace large_random {
+
+struct sajson {
+  static constexpr diff_flags DiffFlags = diff_flags::IMPRECISE_FLOATS;
+
+  size_t ast_buffer_size{0};
+  size_t *ast_buffer{nullptr};
+
+  simdjson_really_inline double get_double(const ::sajson::value &obj, std::string_view key) {
+    using namespace sajson;
+
+    auto val = obj.get_value_of_key({key.data(), key.length()});
+    switch (val.get_type()) {
+      case TYPE_INTEGER:
+      case TYPE_DOUBLE:
+        return val.get_number_value();
+      default:
+        throw "field not double";
+    }
+  }
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    using namespace sajson;
+
+    if (!ast_buffer) {
+      ast_buffer_size = json.size();
+      ast_buffer = (size_t *)std::malloc(ast_buffer_size * sizeof(size_t));
+    }
+    auto doc = parse(
+      bounded_allocation(ast_buffer, ast_buffer_size),
+      mutable_string_view(json.size(), json.data())
+    );
+    if (!doc.is_valid()) { return false; }
+
+    auto points = doc.get_root();
+    if (points.get_type() != TYPE_ARRAY) { return false; }
+
+    for (size_t i=0; i<points.get_length(); i++) {
+      auto point = points.get_array_element(i);
+      if (point.get_type() != TYPE_OBJECT) { return false; }
+      result.emplace_back(json_benchmark::point{
+        get_double(point, "x"),
+        get_double(point, "y"),
+        get_double(point, "z")
+      });
+    }
+
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(large_random, sajson)->UseManualTime();
+
+} // namespace large_random
+
+#endif // SIMDJSON_COMPETITION_SAJSON
+

benchmark/large_random/simdjson_dom.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "large_random.h"
+
+namespace large_random {
+
+using namespace simdjson;
+
+struct simdjson_dom {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  dom::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    for (auto point : parser.parse(json)) {
+      result.emplace_back(json_benchmark::point{point["x"], point["y"], point["z"]});
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(large_random, simdjson_dom)->UseManualTime();
+
+} // namespace large_random
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/large_random/simdjson_ondemand.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "large_random.h"
+
+namespace large_random {
+
+using namespace simdjson;
+
+struct simdjson_ondemand {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    auto doc = parser.iterate(json);
+    for (ondemand::object coord : doc) {
+      result.emplace_back(json_benchmark::point{coord.find_field("x"), coord.find_field("y"), coord.find_field("z")});
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(large_random, simdjson_ondemand)->UseManualTime();
+
+} // namespace large_random
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/large_random/simdjson_ondemand_unordered.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "large_random.h"
+
+namespace large_random {
+
+using namespace simdjson;
+
+struct simdjson_ondemand_unordered {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    auto doc = parser.iterate(json);
+    for (ondemand::object coord : doc) {
+      result.emplace_back(json_benchmark::point{coord["x"], coord["y"], coord["z"]});
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(large_random, simdjson_ondemand_unordered)->UseManualTime();
+
+} // namespace large_random
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/large_random/yyjson.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_YYJSON
+
+#include "large_random.h"
+
+namespace large_random {
+
+struct yyjson_base {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  simdjson_really_inline double get_double(yyjson_val *obj, std::string_view key) {
+    yyjson_val *val = yyjson_obj_getn(obj, key.data(), key.length());
+    if (!val) { throw "missing point field!"; }
+    if (yyjson_get_type(val) != YYJSON_TYPE_NUM) { throw "Number is not a type!"; }
+
+    switch (yyjson_get_subtype(val)) {
+      case YYJSON_SUBTYPE_UINT:
+        return double(yyjson_get_uint(val));
+      case YYJSON_SUBTYPE_SINT:
+        return double(yyjson_get_sint(val));
+      case YYJSON_SUBTYPE_REAL:
+        return yyjson_get_real(val);
+      default:
+        SIMDJSON_UNREACHABLE();
+    }
+    SIMDJSON_UNREACHABLE();
+    return 0.0; // unreachable
+  }
+
+  bool run(yyjson_doc *doc, std::vector<point> &result) {
+    if (!doc) { return false; }
+    yyjson_val *coords = yyjson_doc_get_root(doc);
+    if (!yyjson_is_arr(coords)) { return false; }
+
+    // Walk the document, parsing the tweets as we go
+    size_t idx, max;
+    yyjson_val *coord;
+    yyjson_arr_foreach(coords, idx, max, coord) {
+      if (!yyjson_is_obj(coord)) { return false; }
+      result.emplace_back(json_benchmark::point{get_double(coord, "x"), get_double(coord, "y"), get_double(coord, "z")});
+    }
+
+    return true;
+  }
+};
+
+struct yyjson : yyjson_base {
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
+  }
+};
+BENCHMARK_TEMPLATE(large_random, yyjson)->UseManualTime();
+
+struct yyjson_insitu : yyjson_base {
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
+  }
+};
+BENCHMARK_TEMPLATE(large_random, yyjson_insitu)->UseManualTime();
+
+} // namespace large_random
+
+#endif // SIMDJSON_COMPETITION_YYJSON

benchmark/largerandom/iter.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "largerandom.h"
+
+namespace largerandom {
+
+using namespace simdjson;
+
+class Iter {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+
+  simdjson_really_inline const std::vector<my_point> &Result() { return container; }
+  simdjson_really_inline size_t ItemCount() { return container.size(); }
+
+private:
+  ondemand::parser parser{};
+  std::vector<my_point> container{};
+
+  simdjson_really_inline double first_double(ondemand::json_iterator &iter) {
+    if (iter.start_object().error() || iter.field_key().error() || iter.field_value()) { throw "Invalid field"; }
+    return iter.consume_double();
+  }
+
+  simdjson_really_inline double next_double(ondemand::json_iterator &iter) {
+    if (!iter.has_next_field() || iter.field_key().error() || iter.field_value()) { throw "Invalid field"; }
+    return iter.consume_double();
+  }
+
+};
+
+simdjson_really_inline bool Iter::Run(const padded_string &json) {
+  container.clear();
+
+  auto iter = parser.iterate_raw(json).value();
+  if (iter.start_array()) {
+    do {
+      container.emplace_back(my_point{first_double(iter), next_double(iter), next_double(iter)});
+      if (iter.has_next_field()) { throw "Too many fields"; }
+    } while (iter.has_next_element());
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(LargeRandom, Iter);
+
+} // namespace largerandom
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/largerandom/ondemand.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "largerandom.h"
+
+namespace largerandom {
+
+using namespace simdjson;
+
+class OnDemand {
+public:
+  simdjson_really_inline bool Run(const padded_string &json);
+  simdjson_really_inline const std::vector<my_point> &Result() { return container; }
+  simdjson_really_inline size_t ItemCount() { return container.size(); }
+
+private:
+  ondemand::parser parser{};
+  std::vector<my_point> container{};
+};
+
+simdjson_really_inline bool OnDemand::Run(const padded_string &json) {
+  container.clear();
+
+  auto doc = parser.iterate(json);
+  for (ondemand::object coord : doc) {
+    container.emplace_back(my_point{coord.find_field("x"), coord.find_field("y"), coord.find_field("z")});
+  }
+
+  return true;
+}
+
+BENCHMARK_TEMPLATE(LargeRandom, OnDemand);
+
+} // namespace largerandom
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/largerandom/sax.h

@@ -0,0 +1,120 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "largerandom.h"
+
+namespace largerandom {
+
+using namespace simdjson;
+using namespace simdjson::builtin::stage2;
+
+class Sax {
+public:
+  simdjson_really_inline bool Run(const padded_string &json) noexcept;
+
+  simdjson_really_inline const std::vector<my_point> &Result() { return container; }
+  simdjson_really_inline size_t ItemCount() { return container.size(); }
+
+private:
+  simdjson_really_inline error_code RunNoExcept(const padded_string &json) noexcept;
+  error_code Allocate(size_t new_capacity);
+  std::unique_ptr<uint8_t[]> string_buf{};
+  size_t capacity{};
+  dom_parser_implementation dom_parser{};
+  std::vector<my_point> container{};
+};
+
+struct sax_point_reader_visitor {
+public:
+  std::vector<my_point> &points;
+  enum {GOT_X=0, GOT_Y=1, GOT_Z=2, GOT_SOMETHING_ELSE=4};
+  size_t idx{GOT_SOMETHING_ELSE};
+  double buffer[3]={};
+
+  explicit sax_point_reader_visitor(std::vector<my_point> &_points) : points(_points) {}
+
+  simdjson_really_inline error_code visit_object_start(json_iterator &) {
+    idx = 0;
+    return SUCCESS;
+  }
+  simdjson_really_inline error_code visit_primitive(json_iterator &, const uint8_t *value) {
+    if(idx == GOT_SOMETHING_ELSE) { return simdjson::SUCCESS; }
+    return numberparsing::parse_double(value).get(buffer[idx]);
+  }
+  simdjson_really_inline error_code visit_object_end(json_iterator &)  {
+    points.emplace_back(my_point{buffer[0], buffer[1], buffer[2]});
+    return SUCCESS;
+  }
+
+  simdjson_really_inline error_code visit_document_start(json_iterator &) { return SUCCESS; }
+  simdjson_really_inline error_code visit_key(json_iterator &, const uint8_t * key) {
+    switch(key[1]) {
+      // Technically, we should check the other characters
+      // in the key, but we are cheating to go as fast
+      // as possible.
+      case 'x':
+        idx = GOT_X;
+        break;
+      case 'y':
+        idx = GOT_Y;
+        break;
+      case 'z':
+        idx = GOT_Z;
+        break;
+      default:
+        idx = GOT_SOMETHING_ELSE;
+    }
+    return SUCCESS;
+  }
+  simdjson_really_inline error_code visit_array_start(json_iterator &)  { return SUCCESS; }
+  simdjson_really_inline error_code visit_array_end(json_iterator &) { return SUCCESS; }
+  simdjson_really_inline error_code visit_document_end(json_iterator &)  { return SUCCESS; }
+  simdjson_really_inline error_code visit_empty_array(json_iterator &)  { return SUCCESS; }
+  simdjson_really_inline error_code visit_empty_object(json_iterator &)  { return SUCCESS; }
+  simdjson_really_inline error_code visit_root_primitive(json_iterator &, const uint8_t *)  { return SUCCESS; }
+  simdjson_really_inline error_code increment_count(json_iterator &) { return SUCCESS; }
+};
+
+// NOTE: this assumes the dom_parser is already allocated
+bool Sax::Run(const padded_string &json) noexcept {
+  auto error = RunNoExcept(json);
+  if (error) { std::cerr << error << std::endl; return false; }
+  return true;
+}
+
+error_code Sax::RunNoExcept(const padded_string &json) noexcept {
+  container.clear();
+
+  // Allocate capacity if needed
+  if (capacity < json.size()) {
+    SIMDJSON_TRY( Allocate(json.size()) );
+  }
+
+  // Run stage 1 first.
+  SIMDJSON_TRY( dom_parser.stage1(json.u8data(), json.size(), false) );
+
+  // Then walk the document, parsing the tweets as we go
+  json_iterator iter(dom_parser, 0);
+  sax_point_reader_visitor visitor(container);
+  SIMDJSON_TRY( iter.walk_document<false>(visitor) );
+  return SUCCESS;
+}
+
+error_code Sax::Allocate(size_t new_capacity) {
+  // string_capacity copied from document::allocate
+  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);
+  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
+  if (auto error = dom_parser.set_capacity(new_capacity)) { return error; }
+  if (capacity == 0) { // set max depth the first time only
+    if (auto error = dom_parser.set_max_depth(DEFAULT_MAX_DEPTH)) { return error; }
+  }
+  capacity = new_capacity;
+  return SUCCESS;
+}
+
+BENCHMARK_TEMPLATE(LargeRandom, Sax);
+
+} // namespace largerandom
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/linux/linux-perf-events.h

@@ -1,14 +1,22 @@
 // https://github.com/WojciechMula/toys/blob/master/000helpers/linux-perf-events.h
 #pragma once
 #ifdef __linux__
-
+#ifdef __has_include
+#if __has_include(<asm/unistd.h>)
 #include <asm/unistd.h>       // for __NR_perf_event_open
+#else
+#warning "Header asm/unistd.h cannot be found though it is a linux system. Are linux headers missing?"
+#endif
+#else // no __has_include
+// Please insure that linux headers have been installed.
+#include <asm/unistd.h>       // for __NR_perf_event_open
+#endif
 #include <linux/perf_event.h> // for perf event constants
 #include <sys/ioctl.h>        // for ioctl
 #include <unistd.h>           // for syscall
 
 #include <cerrno>  // for errno
-#include <cstring> // for memset
+#include <cstring> // for std::memset
 #include <stdexcept>
 
 #include <iostream>
@@ -17,14 +25,15 @@
 template <int TYPE = PERF_TYPE_HARDWARE> class LinuxEvents {
   int fd;
   bool working;
-  perf_event_attr attribs;
-  int num_events;
-  std::vector<uint64_t> temp_result_vec;
-  std::vector<uint64_t> ids;
+  perf_event_attr attribs{};
+  size_t num_events{};
+  std::vector<uint64_t> temp_result_vec{};
+  std::vector<uint64_t> result{};
+  bool quiet;
 
 public:
-  explicit LinuxEvents(std::vector<int> config_vec) : fd(0), working(true) {
-    memset(&attribs, 0, sizeof(attribs));
+  explicit LinuxEvents(std::vector<int> config_vec, bool _quiet=false) : fd(0), working(true), quiet{_quiet} {
+    std::memset(&attribs, 0, sizeof(attribs));
     attribs.type = TYPE;
     attribs.size = sizeof(attribs);
     attribs.disabled = 1;
@@ -39,15 +48,15 @@ public:
 
     int group = -1; // no group
     num_events = config_vec.size();
-    ids.resize(config_vec.size());
+    result.resize(config_vec.size());
     uint32_t i = 0;
     for (auto config : config_vec) {
       attribs.config = config;
-      fd = syscall(__NR_perf_event_open, &attribs, pid, cpu, group, flags);
+      fd = static_cast<int>(syscall(__NR_perf_event_open, &attribs, pid, cpu, group, flags));
       if (fd == -1) {
         report_error("perf_event_open");
       }
-      ioctl(fd, PERF_EVENT_IOC_ID, &ids[i++]);
+      ioctl(fd, PERF_EVENT_IOC_ID, &result[i++]);
       if (group == -1) {
         group = fd;
       }
@@ -81,7 +90,7 @@ public:
       }
     }
     // our actual results are in slots 1,3,5, ... of this structure
-    // we really should be checking our ids obtained earlier to be safe
+    // we really should be checking our result obtained earlier to be safe
     for (uint32_t i = 1; i < temp_result_vec.size(); i += 2) {
       results[i / 2] = temp_result_vec[i];
     }
@@ -93,8 +102,11 @@ public:
 
 private:
   void report_error(const std::string &context) {
-    if (working)
-      std::cerr << (context + ": " + std::string(strerror(errno))) << std::endl;
+    if (!quiet) {
+      if (working) {
+        std::cerr << (context + ": " + std::string(strerror(errno))) << std::endl;
+      }
+    }
     working = false;
   }
 };

benchmark/minifiercompetition.cpp

@@ -1,170 +0,0 @@
-#include <iostream>
-#include <unistd.h>
-
-#include "benchmark.h"
-#include "simdjson.h"
-
-SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
-
-// #define RAPIDJSON_SSE2 // bad
-// #define RAPIDJSON_SSE42 // bad
-#include "rapidjson/document.h"
-#include "rapidjson/reader.h" // you have to check in the submodule
-#include "rapidjson/stringbuffer.h"
-#include "rapidjson/writer.h"
-#include "sajson.h"
-
-SIMDJSON_POP_DISABLE_WARNINGS
-
-using namespace rapidjson;
-using namespace simdjson;
-
-std::string rapid_stringme_insitu(char *json) {
-  Document d;
-  d.ParseInsitu(json);
-  if (d.HasParseError()) {
-    std::cerr << "problem!" << std::endl;
-    return ""; // should do something
-  }
-  StringBuffer buffer;
-  Writer<StringBuffer> writer(buffer);
-  d.Accept(writer);
-  return buffer.GetString();
-}
-
-std::string rapid_stringme(char *json) {
-  Document d;
-  d.Parse(json);
-  if (d.HasParseError()) {
-    std::cerr << "problem!" << std::endl;
-    return ""; // should do something
-  }
-  StringBuffer buffer;
-  Writer<StringBuffer> writer(buffer);
-  d.Accept(writer);
-  return buffer.GetString();
-}
-
-
-int main(int argc, char *argv[]) {
-  int c;
-  bool verbose = false;
-  bool just_data = false;
-
-  while ((c = getopt(argc, argv, "vt")) != -1)
-    switch (c) {
-    case 't':
-      just_data = true;
-      break;
-    case 'v':
-      verbose = true;
-      break;
-    default:
-      abort();
-    }
-  if (optind >= argc) {
-    std::cerr << "Usage: " << argv[0] << " <jsonfile>" << std::endl;
-    exit(1);
-  }
-  const char *filename = argv[optind];
-  auto [p, error] = simdjson::padded_string::load(filename);
-  if (error) {
-    std::cerr << "Could not load the file " << filename << std::endl;
-    return EXIT_FAILURE;
-  }
-  if (verbose) {
-    std::cout << "Input has ";
-    if (p.size() > 1024 * 1024)
-      std::cout << p.size() / (1024 * 1024) << " MB ";
-    else if (p.size() > 1024)
-      std::cout << p.size() / 1024 << " KB ";
-    else
-      std::cout << p.size() << " B ";
-    std::cout << std::endl;
-  }
-  char *buffer = simdjson::internal::allocate_padded_buffer(p.size() + 1);
-  memcpy(buffer, p.data(), p.size());
-  buffer[p.size()] = '\0';
-
-  int repeat = 50;
-  int volume = p.size();
-  if (just_data) {
-    printf(
-        "name cycles_per_byte cycles_per_byte_err  gb_per_s gb_per_s_err \n");
-  }
-  size_t strlength = rapid_stringme((char *)p.data()).size();
-  if (verbose)
-    std::cout << "input length is " << p.size() << " stringified length is "
-              << strlength << std::endl;
-  BEST_TIME_NOCHECK("despacing with RapidJSON",
-                    rapid_stringme((char *)p.data()), , repeat, volume,
-                    !just_data);
-  BEST_TIME_NOCHECK(
-      "despacing with RapidJSON Insitu", rapid_stringme_insitu((char *)buffer),
-      memcpy(buffer, p.data(), p.size()), repeat, volume, !just_data);
-  memcpy(buffer, p.data(), p.size());
-  size_t outlength;
-  uint8_t *cbuffer = (uint8_t *)buffer;
-  for (auto imple : simdjson::available_implementations) {
-    BEST_TIME((std::string("simdjson->minify+")+imple->name()).c_str(), (imple->minify(cbuffer, p.size(), cbuffer, outlength) ? outlength : -1),
-            outlength, memcpy(buffer, p.data(), p.size()), repeat, volume,
-            !just_data);
-  }
-
-  printf("minisize = %zu, original size = %zu  (minified down to %.2f percent "
-         "of original) \n",
-         outlength, p.size(), outlength * 100.0 / p.size());
-
-  /***
-   * Is it worth it to minify before parsing?
-   ***/
-  rapidjson::Document d;
-  BEST_TIME("RapidJSON Insitu orig", d.ParseInsitu(buffer).HasParseError(),
-            false, memcpy(buffer, p.data(), p.size()), repeat, volume,
-            !just_data);
-
-  char *mini_buffer = simdjson::internal::allocate_padded_buffer(p.size() + 1);
-  size_t minisize;
-  auto minierror = simdjson::active_implementation->minify((const uint8_t *)p.data(), p.size(),
-                                                           (uint8_t *)mini_buffer, minisize);
-  if (!minierror) { std::cerr << minierror << std::endl; exit(1); }
-  mini_buffer[minisize] = '\0';
-
-  BEST_TIME("RapidJSON Insitu despaced", d.ParseInsitu(buffer).HasParseError(),
-            false, memcpy(buffer, mini_buffer, p.size()), repeat, volume,
-            !just_data);
-
-  size_t ast_buffer_size = p.size() * 2;
-  size_t *ast_buffer = (size_t *)malloc(ast_buffer_size * sizeof(size_t));
-
-  BEST_TIME(
-      "sajson orig",
-      sajson::parse(sajson::bounded_allocation(ast_buffer, ast_buffer_size),
-                    sajson::mutable_string_view(p.size(), buffer))
-          .is_valid(),
-      true, memcpy(buffer, p.data(), p.size()), repeat, volume, !just_data);
-
-  BEST_TIME(
-      "sajson despaced",
-      sajson::parse(sajson::bounded_allocation(ast_buffer, ast_buffer_size),
-                    sajson::mutable_string_view(minisize, buffer))
-          .is_valid(),
-      true, memcpy(buffer, mini_buffer, p.size()), repeat, volume, !just_data);
-
-  simdjson::dom::parser parser;
-  bool automated_reallocation = false;
-  BEST_TIME("simdjson orig",
-            parser.parse((const uint8_t *)buffer, p.size(),
-                                 automated_reallocation).error(),
-            simdjson::SUCCESS, memcpy(buffer, p.data(), p.size()), repeat, volume,
-            !just_data);
-  BEST_TIME("simdjson despaced",
-            parser.parse((const uint8_t *)buffer, minisize,
-                                 automated_reallocation).error(),
-            simdjson::SUCCESS, memcpy(buffer, mini_buffer, p.size()), repeat, volume,
-            !just_data);
-
-  free(buffer);
-  free(ast_buffer);
-  free(mini_buffer);
-}

benchmark/parse.cpp

@@ -4,8 +4,8 @@
 #include <cctype>
 #ifndef _MSC_VER
 #include <dirent.h>
-#include <unistd.h>
 #endif
+#include <unistd.h>
 #include <cinttypes>
 
 #include <cstdio>
@@ -62,11 +62,14 @@ void print_usage(ostream& out) {
   out << "-v           - Verbose output." << endl;
   out << "-s stage1    - Stop after find_structural_bits." << endl;
   out << "-s all       - Run all stages." << endl;
-  out << "-H           - Make the buffers hot (reduce page allocation during parsing)" << endl;
+  out << "-C           - Leave the buffers cold (includes page allocation and related OS tasks during parsing, speed tied to OS performance)" << endl;
+  out << "-H           - Make the buffers hot (reduce page allocation and related OS tasks during parsing) [default]" << endl;
   out << "-a IMPL      - Use the given parser implementation. By default, detects the most advanced" << endl;
   out << "               implementation supported on the host machine." << endl;
   for (auto impl : simdjson::available_implementations) {
-    out << "-a " << std::left << std::setw(9) << impl->name() << " - Use the " << impl->description() << " parser implementation." << endl;
+    if(impl->supported_by_runtime_system()) {
+      out << "-a " << std::left << std::setw(9) << impl->name() << " - Use the " << impl->description() << " parser implementation." << endl;
+    }
   }
 }
 
@@ -78,69 +81,83 @@ void exit_usage(string message) {
 }
 
 struct option_struct {
-  vector<char*> files;
+  vector<char*> files{};
   bool stage1_only = false;
 
   int32_t iterations = 200;
-  int32_t iteration_step = 50;
+  int32_t iteration_step = -1;
 
   bool verbose = false;
   bool tabbed_output = false;
-  bool hotbuffers = false;
+  /**
+   * Benchmarking on a cold parser instance means that the parsing may include
+   * memory allocation at the OS level. This may lead to apparently odd results
+   * such that higher speed under the Windows Subsystem for Linux than under the
+   * regular Windows, for the same machine. It is arguably misleading to benchmark
+   * how the OS allocates memory, when we really want to just benchmark simdjson.
+   */
+  bool hotbuffers = true;
 
   option_struct(int argc, char **argv) {
-    #ifndef _MSC_VER
-      int c;
+    int c;
 
-      while ((c = getopt(argc, argv, "vtn:i:a:s:H")) != -1) {
-        switch (c) {
-        case 'n':
-          iterations = atoi(optarg);
-          break;
-        case 'i':
-          iteration_step = atoi(optarg);
-          break;
-        case 't':
-          tabbed_output = true;
-          break;
-        case 'v':
-          verbose = true;
-          break;
-        case 'a': {
-          const implementation *impl = simdjson::available_implementations[optarg];
-          if (!impl) {
-            std::string exit_message = string("Unsupported option value -a ") + optarg + ": expected -a  with one of ";
-            for (auto imple : simdjson::available_implementations) {
+    while ((c = getopt(argc, argv, "vtn:i:a:s:HC")) != -1) {
+      switch (c) {
+      case 'n':
+        iterations = atoi(optarg);
+        break;
+      case 'i':
+        iteration_step = atoi(optarg);
+        break;
+      case 't':
+        tabbed_output = true;
+        break;
+      case 'v':
+        verbose = true;
+        break;
+      case 'a': {
+        const implementation *impl = simdjson::available_implementations[optarg];
+        if ((!impl) || (!impl->supported_by_runtime_system())) {
+          std::string exit_message = string("Unsupported option value -a ") + optarg + ": expected -a  with one of ";
+          for (auto imple : simdjson::available_implementations) {
+            if(imple->supported_by_runtime_system()) {
               exit_message += imple->name();
               exit_message += " ";
             }
-            exit_usage(exit_message);
           }
-          simdjson::active_implementation = impl;
-          break;
-        }
-        case 'H':
-          hotbuffers = true;
-          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:
-          // reaching here means an argument was given to getopt() which did not have a case label
-          exit_usage("Unexpected argument - missing case for option "+
-                     std::string(1,static_cast<char>(c))+
-                     " (programming error)");
+          exit_usage(exit_message);
         }
+        simdjson::active_implementation = impl;
+        break;
       }
-    #else
-      int optind = 1;
-    #endif
+      case 'C':
+        hotbuffers = false;
+        break;
+      case 'H':
+        hotbuffers = true;
+        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:
+        // reaching here means an argument was given to getopt() which did not have a case label
+        exit_usage("Unexpected argument - missing case for option "+
+                    std::string(1,static_cast<char>(c))+
+                    " (programming error)");
+      }
+    }
+
+    if (iteration_step == -1) {
+      iteration_step = iterations / 50;
+      if (iteration_step < 200) { iteration_step = 200; }
+      if (iteration_step > iterations) { iteration_step = iterations; }
+    }
 
     // All remaining arguments are considered to be files
     for (int i=optind; i<argc; i++) {
@@ -149,17 +166,6 @@ struct option_struct {
     if (files.empty()) {
       exit_usage("No files specified");
     }
-
-    // Keeps the numbers the same for CI (old ./parse didn't have a two-stage loop)
-    if (files.size() == 1) {
-      iteration_step = iterations;
-    }
-
-    #if !defined(__linux__)
-      if (tabbed_output) {
-        exit_error("tabbed_output (-t) flag only works under linux.\n");
-      }
-    #endif
   }
 };
 
@@ -212,7 +218,7 @@ int main(int argc, char *argv[]) {
   if (!options.verbose) { progress.erase(); }
 
   for (size_t i=0; i<options.files.size(); i++) {
-    benchmarkers[i]->print(options.tabbed_output, options.iterations);
+    benchmarkers[i]->print(options.tabbed_output);
     delete benchmarkers[i];
   }
 

benchmark/parse_stream.cpp

@@ -1,149 +1,192 @@
-#include <iostream>
 #include <algorithm>
 #include <chrono>
-#include <vector>
+#include <iostream>
 #include <map>
+#include <vector>
 
 #include "simdjson.h"
 
-#define NB_ITERATION 5
-#define MIN_BATCH_SIZE 200000
+#define NB_ITERATION 20
+#define MIN_BATCH_SIZE 10000
 #define MAX_BATCH_SIZE 10000000
 
 bool test_baseline = false;
 bool test_per_batch = true;
-bool test_best_batch = true;
+bool test_best_batch = false;
 
-bool compare(std::pair<size_t, double> i, std::pair<size_t, double> j){
-    return i.second > j.second;
+bool compare(std::pair<size_t, double> i, std::pair<size_t, double> j) {
+  return i.second > j.second;
 }
 
-int main (int argc, char *argv[]){
+int main(int argc, char *argv[]) {
 
-    if (argc <= 1) {
-        std::cerr << "Usage: " << argv[0] << " <jsonfile>" << std::endl;
-        exit(1);
-    }
-    const char *filename = argv[1];
-    auto [p, err] = simdjson::padded_string::load(filename);
-    if (err) {
-        std::cerr << "Could not load the file " << filename << std::endl;
+  if (argc <= 1) {
+    std::cerr << "Usage: " << argv[0] << " <jsonfile>" << std::endl;
+    exit(1);
+  }
+  const char *filename = argv[1];
+  auto v = simdjson::padded_string::load(filename);
+  if (v.error()) {
+    std::cerr << "Could not load the file " << filename << std::endl;
+    return EXIT_FAILURE;
+  }
+  const simdjson::padded_string& p = v.value_unsafe();
+  if (test_baseline) {
+    std::wclog << "Baseline: Getline + normal parse... " << std::endl;
+    std::cout << "Gigabytes/second\t"
+              << "Nb of documents parsed" << std::endl;
+    for (auto i = 0; i < 3; i++) {
+      // Actual test
+      simdjson::dom::parser parser;
+      simdjson::error_code alloc_error = parser.allocate(p.size());
+      if (alloc_error) {
+        std::cerr << alloc_error << std::endl;
         return EXIT_FAILURE;
+      }
+      std::istringstream ss(std::string(p.data(), p.size()));
+
+      auto start = std::chrono::steady_clock::now();
+      int count = 0;
+      std::string line;
+      int parse_res = simdjson::SUCCESS;
+      while (getline(ss, line)) {
+        // TODO we're likely triggering simdjson's padding reallocation here. Is
+        // that intentional?
+        parser.parse(line);
+        count++;
+      }
+
+      auto end = std::chrono::steady_clock::now();
+
+      std::chrono::duration<double> secs = end - start;
+      double speedinGBs = static_cast<double>(p.size()) /
+                          (static_cast<double>(secs.count()) * 1000000000.0);
+      std::cout << speedinGBs << "\t\t\t\t" << count << std::endl;
+
+      if (parse_res != simdjson::SUCCESS) {
+        std::cerr << "Parsing failed" << std::endl;
+        exit(1);
+      }
     }
-    if (test_baseline) {
-        std::wclog << "Baseline: Getline + normal parse... " << std::endl;
-        std::cout << "Gigabytes/second\t" << "Nb of documents parsed" << std::endl;
-        for (auto i = 0; i < 3; i++) {
-            //Actual test
-            simdjson::dom::parser parser;
-            simdjson::error_code alloc_error = parser.allocate(p.size());
-            if (alloc_error) {
-                std::cerr << alloc_error << std::endl;
-                return EXIT_FAILURE;
-            }
-            std::istringstream ss(std::string(p.data(), p.size()));
+  }
 
-            auto start = std::chrono::steady_clock::now();
-            int count = 0;
-            std::string line;
-            int parse_res = simdjson::SUCCESS;
-            while (getline(ss, line)) {
-                // TODO we're likely triggering simdjson's padding reallocation here. Is that intentional?
-                parser.parse(line);
-                count++;
-            }
+  std::map<size_t, double> batch_size_res;
+  if (test_per_batch) {
+    std::wclog << "parse_many: Speed per batch_size... from " << MIN_BATCH_SIZE
+               << " bytes to " << MAX_BATCH_SIZE << " bytes..." << std::endl;
+    std::cout << "Batch Size\t"
+              << "Gigabytes/second\t"
+              << "Nb of documents parsed" << std::endl;
+    for (size_t i = MIN_BATCH_SIZE; i <= MAX_BATCH_SIZE;
+         i += (MAX_BATCH_SIZE - MIN_BATCH_SIZE) / 100) {
+      batch_size_res.insert(std::pair<size_t, double>(i, 0));
+      int count;
+      for (size_t j = 0; j < 5; j++) {
+        // Actual test
+        simdjson::dom::parser parser;
+        simdjson::error_code error;
 
-            auto end = std::chrono::steady_clock::now();
-
-            std::chrono::duration<double> secs = end - start;
-            double speedinGBs = (p.size()) / (secs.count() * 1000000000.0);
-            std::cout << speedinGBs << "\t\t\t\t" << count << std::endl;
-
-            if (parse_res != simdjson::SUCCESS) {
-                std::cerr << "Parsing failed" << std::endl;
-                exit(1);
-            }
+        auto start = std::chrono::steady_clock::now();
+        count = 0;
+        simdjson::dom::document_stream docs;
+        if ((error = parser.parse_many(p, i).get(docs))) {
+          std::wcerr << "Parsing failed with: " << error << std::endl;
+          exit(1);
         }
+        for (auto result : docs) {
+          error = result.error();
+          if (error) {
+            std::wcerr << "Parsing failed with: " << error << std::endl;
+            exit(1);
+          }
+          count++;
+        }
+        auto end = std::chrono::steady_clock::now();
+
+        std::chrono::duration<double> secs = end - start;
+        double speedinGBs = static_cast<double>(p.size()) /
+                            (static_cast<double>(secs.count()) * 1000000000.0);
+        if (speedinGBs > batch_size_res.at(i))
+          batch_size_res[i] = speedinGBs;
+      }
+      std::cout << i << "\t\t" << std::fixed << std::setprecision(3)
+                << batch_size_res.at(i) << "\t\t\t\t" << count << std::endl;
+    }
+  }
+  size_t optimal_batch_size{};
+  double best_speed{};
+  if (test_per_batch) {
+    std::pair<size_t, double> best_results;
+    best_results =
+        (*min_element(batch_size_res.begin(), batch_size_res.end(), compare));
+    optimal_batch_size = best_results.first;
+    best_speed = best_results.second;
+  } else {
+    optimal_batch_size = MIN_BATCH_SIZE;
+  }
+  std::wclog << "Seemingly optimal batch_size: " << optimal_batch_size << "..."
+             << std::endl;
+  std::wclog << "Best speed: " << best_speed << "..." << std::endl;
+
+  if (test_best_batch) {
+    std::wclog << "Starting speed test... Best of " << NB_ITERATION
+               << " iterations..." << std::endl;
+    std::vector<double> res;
+    for (int i = 0; i < NB_ITERATION; i++) {
+
+      // Actual test
+      simdjson::dom::parser parser;
+      simdjson::error_code error;
+
+      auto start = std::chrono::steady_clock::now();
+      // This includes allocation of the parser
+      simdjson::dom::document_stream docs;
+      if ((error = parser.parse_many(p, optimal_batch_size).get(docs))) {
+        std::wcerr << "Parsing failed with: " << error << std::endl;
+        exit(1);
+      }
+      for (auto result : docs) {
+        error = result.error();
+        if (error) {
+          std::wcerr << "Parsing failed with: " << error << std::endl;
+          exit(1);
+        }
+      }
+      auto end = std::chrono::steady_clock::now();
+
+      std::chrono::duration<double> secs = end - start;
+      res.push_back(secs.count());
     }
 
-    std::map<size_t, double> batch_size_res;
-    if(test_per_batch) {
-        std::wclog << "parse_many: Speed per batch_size... from " << MIN_BATCH_SIZE
-                << " bytes to " << MAX_BATCH_SIZE << " bytes..." << std::endl;
-        std::cout << "Batch Size\t" << "Gigabytes/second\t" << "Nb of documents parsed" << std::endl;
-        for (size_t i = MIN_BATCH_SIZE; i <= MAX_BATCH_SIZE; i += (MAX_BATCH_SIZE - MIN_BATCH_SIZE) / 50) {
-            batch_size_res.insert(std::pair<size_t, double>(i, 0));
-            int count;
-            for (size_t j = 0; j < 5; j++) {
-                //Actual test
-                simdjson::dom::parser parser;
-                simdjson::error_code error;
+    double min_result = *min_element(res.begin(), res.end());
+    double speedinGBs =
+        static_cast<double>(p.size()) / (min_result * 1000000000.0);
 
-                auto start = std::chrono::steady_clock::now();
-                count = 0;
-                for (auto result : parser.parse_many(p, 4000000)) {
-                    error = result.error();
-                    count++;
-                }
-                auto end = std::chrono::steady_clock::now();
+    std::cout << "Min:  " << min_result << " bytes read: " << p.size()
+              << " Gigabytes/second: " << speedinGBs << std::endl;
+  }
+#ifdef SIMDJSON_THREADS_ENABLED
+  // Multithreading probably does not help matters for small files (less than 10
+  // MB).
+  if (p.size() < 10000000) {
+    std::cout << std::endl;
 
-                std::chrono::duration<double> secs = end - start;
-                double speedinGBs = (p.size()) / (secs.count() * 1000000000.0);
-                if (speedinGBs > batch_size_res.at(i))
-                    batch_size_res[i] = speedinGBs;
+    std::cout << "Warning: your file is small and the performance results are "
+                 "probably meaningless"
+              << std::endl;
+    std::cout << "as far as multithreaded performance goes." << std::endl;
 
-                if (error != simdjson::SUCCESS) {
-                    std::wcerr << "Parsing failed with: " << error << std::endl;
-                    exit(1);
-                }
-            }
-            std::cout << i << "\t\t" << std::fixed << std::setprecision(3) << batch_size_res.at(i) << "\t\t\t\t" << count << std::endl;
+    std::cout << std::endl;
 
-        }
-    }
+    std::cout
+        << "Try to concatenate the file with itself to generate a large one."
+        << std::endl;
+    std::cout << "In bash: " << std::endl;
+    std::cout << "for i in {1..1000}; do cat '" << filename
+              << "' >> bar.ndjson; done" << std::endl;
+    std::cout << argv[0] << " bar.ndjson" << std::endl;
+  }
+#endif
 
-    if (test_best_batch) {
-        size_t optimal_batch_size;
-        if (test_per_batch) {
-            optimal_batch_size = (*min_element(batch_size_res.begin(), batch_size_res.end(), compare)).first;
-        } else {
-            optimal_batch_size = MIN_BATCH_SIZE;
-        }
-        std::wclog << "Starting speed test... Best of " << NB_ITERATION << " iterations..." << std::endl;
-        std::wclog << "Seemingly optimal batch_size: " << optimal_batch_size << "..." << std::endl;
-        std::vector<double> res;
-        for (int i = 0; i < NB_ITERATION; i++) {
-
-            // Actual test
-            simdjson::dom::parser parser;
-            simdjson::error_code error;
-
-            auto start = std::chrono::steady_clock::now();
-            // TODO this includes allocation of the parser; is that intentional?
-            for (auto result : parser.parse_many(p, 4000000)) {
-                error = result.error();
-            }
-            auto end = std::chrono::steady_clock::now();
-
-            std::chrono::duration<double> secs = end - start;
-            res.push_back(secs.count());
-
-            if (error != simdjson::SUCCESS) {
-                std::wcerr << "Parsing failed with: " << error << std::endl;
-                exit(1);
-            }
-
-        }
-
-        std::min(res.begin(), res.end());
-
-        double min_result = *min_element(res.begin(), res.end());
-        double speedinGBs = (p.size()) / (min_result * 1000000000.0);
-
-
-        std::cout << "Min:  " << min_result << " bytes read: " << p.size()
-                << " Gigabytes/second: " << speedinGBs << std::endl;
-    }
-
-    return 0;
+  return 0;
 }

benchmark/parseandstatcompetition.cpp

@@ -1,346 +0,0 @@
-#include "simdjson.h"
-#include <unistd.h>
-
-#include "benchmark.h"
-
-SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
-
-// #define RAPIDJSON_SSE2 // bad for performance
-// #define RAPIDJSON_SSE42 // bad for performance
-#include "rapidjson/document.h"
-#include "rapidjson/reader.h"
-#include "rapidjson/stringbuffer.h"
-#include "rapidjson/writer.h"
-
-#include "sajson.h"
-
-SIMDJSON_POP_DISABLE_WARNINGS
-
-using namespace rapidjson;
-using namespace simdjson;
-struct stat_s {
-  size_t number_count;
-  size_t object_count;
-  size_t array_count;
-  size_t null_count;
-  size_t true_count;
-  size_t false_count;
-  bool valid;
-};
-
-typedef struct stat_s stat_t;
-
-bool stat_equal(const stat_t &s1, const stat_t &s2) {
-  return (s1.valid == s2.valid) && (s1.number_count == s2.number_count) &&
-         (s1.object_count == s2.object_count) &&
-         (s1.array_count == s2.array_count) &&
-         (s1.null_count == s2.null_count) && (s1.true_count == s2.true_count) &&
-         (s1.false_count == s2.false_count);
-}
-
-void print_stat(const stat_t &s) {
-  if (!s.valid) {
-    printf("invalid\n");
-    return;
-  }
-  printf("number: %zu object: %zu array: %zu null: %zu true: %zu false: %zu\n",
-         s.number_count, s.object_count, s.array_count, s.null_count,
-         s.true_count, s.false_count);
-}
-
-
-really_inline void simdjson_process_atom(stat_t &s,
-                                         simdjson::dom::element element) {
-  if (element.is<double>()) {
-    s.number_count++;
-  } else if (element.is<bool>()) {
-    if (element.get<bool>()) {
-      s.true_count++;
-    } else {
-      s.false_count++;
-    }
-  } else if (element.is_null()) {
-    s.null_count++;
-  }
-}
-
-void simdjson_recurse(stat_t &s, simdjson::dom::element element) {
-  if (element.is<simdjson::dom::array>()) {
-    s.array_count++;
-    auto [array, array_error] = element.get<simdjson::dom::array>();
-    for (auto child : array) {
-      if (child.is<simdjson::dom::array>() || child.is<simdjson::dom::object>()) {
-        simdjson_recurse(s, child);
-      } else {
-        simdjson_process_atom(s, child);
-      }
-    }
-  } else if (element.is<simdjson::dom::object>()) {
-    s.object_count++;
-    auto [object, object_error] = element.get<simdjson::dom::object>();
-    for (auto [key, value] : object) {
-      if (value.is<simdjson::dom::array>() || value.is<simdjson::dom::object>()) {
-        simdjson_recurse(s, value);
-      } else {
-        simdjson_process_atom(s, value);
-      }
-    }
-  } else {
-    simdjson_process_atom(s, element);
-  }
-}
-
-__attribute__((noinline)) stat_t
-simdjson_compute_stats(const simdjson::padded_string &p) {
-  stat_t s{};
-  simdjson::dom::parser parser;
-  auto [doc, error] = parser.parse(p);
-  if (error) {
-    s.valid = false;
-    return s;
-  }
-  s.valid = true;
-  simdjson_recurse(s, doc);
-  return s;
-}
-
-// see
-// https://github.com/miloyip/nativejson-benchmark/blob/master/src/tests/sajsontest.cpp
-void sajson_traverse(stat_t &stats, const sajson::value &node) {
-  using namespace sajson;
-  switch (node.get_type()) {
-  case TYPE_NULL:
-    stats.null_count++;
-    break;
-  case TYPE_FALSE:
-    stats.false_count++;
-    break;
-  case TYPE_TRUE:
-    stats.true_count++;
-    break;
-  case TYPE_ARRAY: {
-    stats.array_count++;
-    auto length = node.get_length();
-    for (size_t i = 0; i < length; ++i) {
-      sajson_traverse(stats, node.get_array_element(i));
-    }
-    break;
-  }
-  case TYPE_OBJECT: {
-    stats.object_count++;
-    auto length = node.get_length();
-    for (auto i = 0u; i < length; ++i) {
-      sajson_traverse(stats, node.get_object_value(i));
-    }
-    break;
-  }
-  case TYPE_STRING:
-    // skip
-    break;
-
-  case TYPE_DOUBLE:
-  case TYPE_INTEGER:
-    stats.number_count++; // node.get_number_value();
-    break;
-  default:
-    assert(false && "unknown node type");
-  }
-}
-
-__attribute__((noinline)) stat_t
-sasjon_compute_stats(const simdjson::padded_string &p) {
-  stat_t answer;
-  char *buffer = (char *)malloc(p.size());
-  if (buffer == nullptr) {
-    return answer;
-  }
-  memcpy(buffer, p.data(), p.size());
-  auto d = sajson::parse(sajson::dynamic_allocation(),
-                         sajson::mutable_string_view(p.size(), buffer));
-  answer.valid = d.is_valid();
-  if (!answer.valid) {
-    free(buffer);
-    return answer;
-  }
-  answer.number_count = 0;
-  answer.object_count = 0;
-  answer.array_count = 0;
-  answer.null_count = 0;
-  answer.true_count = 0;
-  answer.false_count = 0;
-  sajson_traverse(answer, d.get_root());
-  free(buffer);
-  return answer;
-}
-
-void rapid_traverse(stat_t &stats, const rapidjson::Value &v) {
-  switch (v.GetType()) {
-  case kNullType:
-    stats.null_count++;
-    break;
-  case kFalseType:
-    stats.false_count++;
-    break;
-  case kTrueType:
-    stats.true_count++;
-    break;
-
-  case kObjectType:
-    for (Value::ConstMemberIterator m = v.MemberBegin(); m != v.MemberEnd();
-         ++m) {
-      rapid_traverse(stats, m->value);
-    }
-    stats.object_count++;
-    break;
-  case kArrayType:
-    for (Value::ConstValueIterator i = v.Begin(); i != v.End();
-         ++i) { // v.Size();
-      rapid_traverse(stats, *i);
-    }
-    stats.array_count++;
-    break;
-
-  case kStringType:
-    break;
-
-  case kNumberType:
-    stats.number_count++;
-    break;
-  }
-}
-
-__attribute__((noinline)) stat_t
-rapid_compute_stats(const simdjson::padded_string &p) {
-  stat_t answer;
-  char *buffer = (char *)malloc(p.size() + 1);
-  if (buffer == nullptr) {
-    return answer;
-  }
-  memcpy(buffer, p.data(), p.size());
-  buffer[p.size()] = '\0';
-  rapidjson::Document d;
-  d.ParseInsitu<kParseValidateEncodingFlag>(buffer);
-  answer.valid = !d.HasParseError();
-  if (!answer.valid) {
-    free(buffer);
-    return answer;
-  }
-  answer.number_count = 0;
-  answer.object_count = 0;
-  answer.array_count = 0;
-  answer.null_count = 0;
-  answer.true_count = 0;
-  answer.false_count = 0;
-  rapid_traverse(answer, d);
-  free(buffer);
-  return answer;
-}
-
-__attribute__((noinline)) stat_t
-rapid_accurate_compute_stats(const simdjson::padded_string &p) {
-  stat_t answer;
-  char *buffer = (char *)malloc(p.size() + 1);
-  if (buffer == nullptr) {
-    return answer;
-  }
-  memcpy(buffer, p.data(), p.size());
-  buffer[p.size()] = '\0';
-  rapidjson::Document d;
-  d.ParseInsitu<kParseValidateEncodingFlag | kParseFullPrecisionFlag>(buffer);
-  answer.valid = !d.HasParseError();
-  if (!answer.valid) {
-    free(buffer);
-    return answer;
-  }
-  answer.number_count = 0;
-  answer.object_count = 0;
-  answer.array_count = 0;
-  answer.null_count = 0;
-  answer.true_count = 0;
-  answer.false_count = 0;
-  rapid_traverse(answer, d);
-  free(buffer);
-  return answer;
-}
-int main(int argc, char *argv[]) {
-  bool verbose = false;
-  bool just_data = false;
-
-  int c;
-  while ((c = getopt(argc, argv, "vt")) != -1)
-    switch (c) {
-    case 't':
-      just_data = true;
-      break;
-    case 'v':
-      verbose = true;
-      break;
-    default:
-      abort();
-    }
-  if (optind >= argc) {
-    std::cerr
-        << "Using different parsers, we compute the content statistics of "
-           "JSON documents."
-        << std::endl;
-    std::cerr << "Usage: " << argv[0] << " <jsonfile>" << std::endl;
-    std::cerr << "Or " << argv[0] << " -v <jsonfile>" << std::endl;
-    exit(1);
-  }
-  const char *filename = argv[optind];
-  if (optind + 1 < argc) {
-    std::cerr << "warning: ignoring everything after " << argv[optind + 1]
-              << std::endl;
-  }
-  auto [p, error] = simdjson::padded_string::load(filename);
-  if (error) {
-    std::cerr << "Could not load the file " << filename << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  if (verbose) {
-    std::cout << "Input has ";
-    if (p.size() > 1024 * 1024)
-      std::cout << p.size() / (1024 * 1024) << " MB ";
-    else if (p.size() > 1024)
-      std::cout << p.size() / 1024 << " KB ";
-    else
-      std::cout << p.size() << " B ";
-    std::cout << std::endl;
-  }
-  stat_t s1 = simdjson_compute_stats(p);
-  if (verbose) {
-    printf("simdjson: ");
-    print_stat(s1);
-  }
-  stat_t s2 = rapid_compute_stats(p);
-  if (verbose) {
-    printf("rapid:    ");
-    print_stat(s2);
-  }
-  stat_t s2a = rapid_accurate_compute_stats(p);
-  if (verbose) {
-    printf("rapid full:    ");
-    print_stat(s2a);
-  }
-  stat_t s3 = sasjon_compute_stats(p);
-  if (verbose) {
-    printf("sasjon:   ");
-    print_stat(s3);
-  }
-  assert(stat_equal(s1, s2));
-  assert(stat_equal(s1, s3));
-  int repeat = 50;
-  int volume = p.size();
-  if (just_data) {
-    printf("name cycles_per_byte cycles_per_byte_err gb_per_s gb_per_s_err \n");
-  }
-  BEST_TIME("simdjson            ", simdjson_compute_stats(p).valid, true, ,
-            repeat, volume, !just_data);
-  BEST_TIME("RapidJSON           ", rapid_compute_stats(p).valid, true, ,
-            repeat, volume, !just_data);
-  BEST_TIME("RapidJSON (precise) ", rapid_accurate_compute_stats(p).valid, true, ,
-            repeat, volume, !just_data);
-  BEST_TIME("sasjon              ", sasjon_compute_stats(p).valid, true, ,
-            repeat, volume, !just_data);
-}