This is a version of the avx-512 kernel which uses ternary instructions and lower-level constructions. It is not faster.

Making AVX-512 work by default.

.github/workflows/alpine.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

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

@@ -6,7 +6,7 @@ jobs:
   whitespace:
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
       - name: Remove whitespace and check the diff
         run: |
           set -eu

.github/workflows/fuzzers.yml

@@ -37,14 +37,14 @@ jobs:
         chmod +x llvm.sh
         sudo ./llvm.sh $CLANGVERSION
 
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v1
 
-    - uses: actions/cache@v3
+    - uses: actions/cache@v2
       with:
         path: dependencies/.cache
         key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
 
-    - uses: actions/cache@v3
+    - uses: actions/cache@v2
       id: cache-corpus
       with:
         path: out/

.github/workflows/macos-11.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: macos-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/macos.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: macos-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/msys2-clang.yml

@@ -24,8 +24,8 @@ jobs:
       CMAKE_GENERATOR: Ninja
 
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/msys2.yml

@@ -26,8 +26,8 @@ jobs:
       CMAKE_GENERATOR: Ninja
 
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu18-checkperf.yml

@@ -15,8 +15,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-18.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu18-oldclang.yml

@@ -13,8 +13,8 @@ jobs:
       CC: clang-7
       CXX: clang++-7
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu18-threadsani.yml

@@ -10,8 +10,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-18.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu18.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-18.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu20-checkperf.yml

@@ -15,8 +15,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu20-gcc8.yml

@@ -1,38 +0,0 @@
-name: Ubuntu 20.04 CI (GCC 8)
-
-on: [push, pull_request]
-
-jobs:
-  ubuntu-build:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-20.04
-    env:
-      CXX: g++-8
-      CC: gcc-8
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
-        with:
-          path: dependencies/.cache
-          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-      - name: Install GCC 8
-        run: sudo apt-get install -y g++-8
-      - name: Use cmake
-        run: |
-          mkdir builddebug &&
-          cd builddebug &&
-          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
-          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
-          cd .. &&
-          mkdir build &&
-          cd build &&
-          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
-          cmake --build .   &&
-          ctest -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/ubuntu20-noexcept.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu20-nothread.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu20-sani.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu20-threadsani.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu20.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu22-clang13.yml

@@ -1,25 +0,0 @@
-name: Ubuntu 22.04 CI (CLANG 13)
-
-on: [push, pull_request]
-
-jobs:
-  ubuntu-build:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
-        with:
-          path: dependencies/.cache
-          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-      - name: Install clang++-13
-        run: sudo apt-get install -y clang++-13
-      - name: Use cmake
-        run: |
-          mkdir build &&
-          cd build &&
-          CXX=clang++-13 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
-          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly

.github/workflows/ubuntu22-gcc12.yml

@@ -1,25 +0,0 @@
-name: Ubuntu 22.04 CI (GCC 12)
-
-on: [push, pull_request]
-
-jobs:
-  ubuntu-build:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
-        with:
-          path: dependencies/.cache
-          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-      - name: Install gcc12
-        run: sudo apt-get install -y g++-12
-      - name: Use cmake
-        run: |
-          mkdir build &&
-          cd build &&
-          CXX=g++-12 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
-          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly

.github/workflows/ubuntu22.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

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

@@ -14,7 +14,7 @@ jobs:
            - {arch: ARM64}
      steps:
        - name: checkout
-         uses: actions/checkout@v3
+         uses: actions/checkout@v2
        - name: Use cmake
          run: |
            cmake -A ${{ matrix.arch }} -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -B build  &&

.github/workflows/vs17-ci.yml

@@ -19,7 +19,7 @@ jobs:
           - {gen: Visual Studio 17 2022, arch: x64, shared: OFF}
     steps:
     - name: checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2
     - name: Configure
       run: |
         cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build

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

@@ -16,7 +16,7 @@ jobs:
           - {gen: Visual Studio 17 2022, arch: x64}
     steps:
     - name: checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2
     - name: Configure
       run: |
         cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build

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

@@ -7,8 +7,8 @@ jobs:
     name: windows-vs17
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/cache@v3
+    - uses: actions/checkout@v2
+    - uses: actions/cache@v2
       with:
         path: dependencies/.cache
         key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.vscode/settings.json

@@ -86,16 +86,6 @@
         "vector": "cpp",
         "*.ipp": "cpp",
         "__functional_base_03": "cpp",
-        "filesystem": "cpp",
-        "*.inc": "cpp",
-        "compare": "cpp",
-        "concepts": "cpp",
-        "variant": "cpp",
-        "__bits": "cpp",
-        "csignal": "cpp",
-        "future": "cpp",
-        "queue": "cpp",
-        "shared_mutex": "cpp",
-        "ranges": "cpp"
+        "filesystem": "cpp"
     }
 }

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14)
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 2.1.0
+    VERSION 1.0.2
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -20,8 +20,8 @@ string(
 # ---- Options, variables ----
 
 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "12.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "12" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_VERSION "9.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "9" CACHE STRING "simdjson library soversion")
 
 option(SIMDJSON_ENABLE_THREADS "Link with thread support" ON)
 

CONTRIBUTING.md

@@ -62,13 +62,13 @@ Pull Requests
 
 Pull requests are always invited. However, we ask that you follow these guidelines:
 
-- It is wise to discuss your ideas first as part of an issue before you start coding. If you omit this step and code first, be prepared to have your code receive scrutiny and be dropped.
-- Users should provide a rationale for their changes. Does it improve performance? Does it add a feature? Does it improve maintainability? Does it fix a bug? This must be explicitly stated as part of the pull request. Do not propose changes based on taste or intuition. We do not delegate programming to tools: that some tool suggested a code change is not reason enough to change the code.
+- 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 either fix a failing test, or propose a new test.
+   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 by new tests, in general.
+- New features must be accompanied of new tests, in general.
 - Your code should pass our continuous-integration tests. It is your responsibility to ensure that your proposal pass the tests. We do not merge pull requests that would break our build.
    - An exception to this would be changes to non-code files, such as documentation and assets, or trivial changes to code, such as comments, where it is encouraged to explicitly ask for skipping a CI run using the `[skip ci]` prefix in your Pull Request title **and** in the first line of the most recent commit in a push. Example for such a commit: `[skip ci] Fixed typo in power_of_ten's docs`
    This benefits the project in such a way that the CI pipeline is not burdened by running jobs on changes that don't change any behavior in the code, which reduces wait times for other Pull Requests that do change behavior and require testing.

CONTRIBUTORS

@@ -40,6 +40,6 @@ Pavel Pavlov
 Hao Chen
 Nicolas Boyer
 Kim Walisch and Jatin Bhateja (AVX-512 bitset decoder)
-Fangzheng Zhang and Weiqiang Wan (AVX-512 kernel)
+Eric Zhang (AVX-512 kernel)
 # if you have contributed to the project and your name does not
 # appear in this list, please let us know!

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         = "2.1.0"
+PROJECT_NUMBER         = "1.0.2"
 
 # 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

README.md

@@ -3,7 +3,7 @@
 [![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/2.0.0/index.html)
+[![][license img]][license]  [![Doxygen Documentation](https://img.shields.io/badge/docs-doxygen-green.svg)](https://simdjson.org/api/1.0.0/index.html)
 
 simdjson : Parsing gigabytes of JSON per second
 ===============================================

benchmark/amazon_cellphones/amazon_cellphones.h

@@ -4,12 +4,8 @@
 #include <map>
 #include <string>
 
-
 namespace amazon_cellphones {
 
-const bool UNTHREADED = false;
-const bool THREADED = true;
-
 using namespace json_benchmark;
 
 struct brand {
@@ -63,11 +59,10 @@ struct runner : public file_runner<I> {
     }
 };
 
-template<bool threaded>
 struct simdjson_dom;
 
 template<typename I> simdjson_really_inline static void amazon_cellphones(benchmark::State &state) {
-  run_json_benchmark<runner<I>, runner<simdjson_dom<UNTHREADED>>>(state);
+  run_json_benchmark<runner<I>, runner<simdjson_dom>>(state);
 }
 
 }   // namespace amazon_cellphones

benchmark/amazon_cellphones/simdjson_dom.h

@@ -8,16 +8,12 @@ namespace amazon_cellphones {
 
 using namespace simdjson;
 
-template<bool threaded>
 struct simdjson_dom {
   using StringType = std::string;
 
   dom::parser parser{};
 
   bool run(simdjson::padded_string &json, std::map<StringType, brand> &result) {
-#ifdef SIMDJSON_THREADS_ENABLED
-    parser.threaded = threaded;
-#endif
     auto stream = parser.parse_many(json);
     auto i = stream.begin();
     ++i;  // Skip first line
@@ -41,10 +37,7 @@ struct simdjson_dom {
 
 };
 
-BENCHMARK_TEMPLATE(amazon_cellphones, simdjson_dom<UNTHREADED>)->UseManualTime();
-#ifdef SIMDJSON_THREADS_ENABLED
-BENCHMARK_TEMPLATE(amazon_cellphones, simdjson_dom<THREADED>)->UseManualTime();
-#endif
+BENCHMARK_TEMPLATE(amazon_cellphones, simdjson_dom)->UseManualTime();
 
 } // namespace amazon_cellphones
 

benchmark/amazon_cellphones/simdjson_ondemand.h

@@ -8,16 +8,12 @@ namespace amazon_cellphones {
 
 using namespace simdjson;
 
-template<bool threaded>
 struct simdjson_ondemand {
   using StringType = std::string;
 
   ondemand::parser parser{};
 
   bool run(simdjson::padded_string &json, std::map<StringType, brand> &result) {
-#ifdef SIMDJSON_THREADS_ENABLED
-    parser.threaded = threaded;
-#endif
     ondemand::document_stream stream = parser.iterate_many(json);
     ondemand::document_stream::iterator i = stream.begin();
     ++i;  // Skip first line
@@ -62,10 +58,7 @@ struct simdjson_ondemand {
 
 };
 
-BENCHMARK_TEMPLATE(amazon_cellphones, simdjson_ondemand<UNTHREADED>)->UseManualTime();
-#ifdef SIMDJSON_THREADS_ENABLED
-BENCHMARK_TEMPLATE(amazon_cellphones, simdjson_ondemand<THREADED>)->UseManualTime();
-#endif
+BENCHMARK_TEMPLATE(amazon_cellphones, simdjson_ondemand)->UseManualTime();
 
 } // namespace amazon_cellphones
 

benchmark/bench_ondemand.cpp

@@ -25,11 +25,6 @@ SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
 #include <benchmark/benchmark.h>
 
 SIMDJSON_POP_DISABLE_WARNINGS
-#include "json2msgpack/simdjson_ondemand.h"
-#include "json2msgpack/rapidjson.h"
-#include "json2msgpack/yyjson.h"
-#include "json2msgpack/sajson.h"
-#include "json2msgpack/nlohmann_json.h"
 
 #include "amazon_cellphones/simdjson_dom.h"
 #include "amazon_cellphones/simdjson_ondemand.h"

benchmark/benchfeatures.cpp

@@ -204,13 +204,10 @@ struct feature_benchmarker {
   }
   // Rate of 1-7-structural misses per 8-structural flip
   double struct1_7_miss_rate(BenchmarkStage stage) const {
-#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
-    return 1;
-#else
     if (!has_events()) { return 1; }
     return struct7_miss[stage].best.branch_misses() - struct7[stage].best.branch_misses() / double(struct7_miss.stats->blocks_with_1_structural_flipped);
-#endif
   }
+
   // Extra cost of an 8-15 structural block over a 1-7 structural block
   double struct8_15_cost(BenchmarkStage stage) const {
     return cost_per_block(stage, struct15, struct15.stats->blocks_with_8_structurals, struct7);
@@ -221,12 +218,8 @@ struct feature_benchmarker {
   }
   // Rate of 8-15-structural misses per 8-structural flip
   double struct8_15_miss_rate(BenchmarkStage stage) const {
-#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
-    return 1;
-#else
     if (!has_events()) { return 1; }
     return double(struct15_miss[stage].best.branch_misses() - struct15[stage].best.branch_misses()) / double(struct15_miss.stats->blocks_with_8_structurals_flipped);
-#endif
   }
 
   // Extra cost of a 16+-structural block over an 8-15 structural block (actual varies based on # of structurals!)
@@ -239,15 +232,10 @@ struct feature_benchmarker {
   }
   // Rate of 16-structural misses per 16-structural flip
   double struct16_miss_rate(BenchmarkStage stage) const {
-#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
-    return 1;
-#else
     if (!has_events()) { return 1; }
     return double(struct23_miss[stage].best.branch_misses() - struct23[stage].best.branch_misses()) / double(struct23_miss.stats->blocks_with_16_structurals_flipped);
-#endif
   }
 
-
   // Extra cost of having UTF-8 in a block
   double utf8_cost(BenchmarkStage stage) const {
     return cost_per_block(stage, utf8, utf8.stats->blocks_with_utf8, struct7_full);
@@ -258,13 +246,10 @@ struct feature_benchmarker {
   }
   // Rate of UTF-8 misses per UTF-8 flip
   double utf8_miss_rate(BenchmarkStage stage) const {
-#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
-    return 1;
-#else
     if (!has_events()) { return 1; }
     return double(utf8_miss[stage].best.branch_misses() - utf8[stage].best.branch_misses()) / double(utf8_miss.stats->blocks_with_utf8_flipped);
-#endif
   }
+
   // Extra cost of having escapes in a block
   double escape_cost(BenchmarkStage stage) const {
     return cost_per_block(stage, escape, escape.stats->blocks_with_escapes, struct7_full);
@@ -275,15 +260,10 @@ struct feature_benchmarker {
   }
   // Rate of escape misses per escape flip
   double escape_miss_rate(BenchmarkStage stage) const {
-#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
-    return 1;
-#else
     if (!has_events()) { return 1; }
     return double(escape_miss[stage].best.branch_misses() - escape[stage].best.branch_misses()) / double(escape_miss.stats->blocks_with_escapes_flipped);
-#endif
   }
 
-
   double calc_expected_feature_cost(BenchmarkStage stage, const benchmarker& file) const {
     // Expected base ns/block (empty)
     json_stats& stats = *file.stats;
@@ -320,6 +300,7 @@ struct feature_benchmarker {
   double calc_expected(BenchmarkStage stage, const benchmarker& file) const {
     return calc_expected_feature_cost(stage, file) + calc_expected_miss_cost(stage, file);
   }
+
   void print(const option_struct& options) const {
     printf("\n");
     printf("Features in ns/block (64 bytes):\n");
@@ -378,22 +359,6 @@ struct feature_benchmarker {
   }
 };
 
-#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
-void print_file_effectiveness(BenchmarkStage stage, const char* filename, const benchmarker& results, const feature_benchmarker& features) {
-  double actual = results[stage].best.elapsed_ns() / double(results.stats->blocks);
-  double calc = features.calc_expected(stage, results);
-  double calc_misses = features.calc_expected_misses(stage, results);
-  double calc_miss_cost = features.calc_expected_miss_cost(stage, results);
-  printf("        | %-8s ", benchmark_stage_name(stage));
-  printf("| %-15s ",   filename);
-  printf("|    %8.3g ", features.calc_expected_feature_cost(stage, results));
-  printf("|    %8.3g ", calc_miss_cost);
-  printf("| %8.3g ",  calc);
-  printf("| %8.3g ",  actual);
-  printf("| %+8.3g ", actual - calc);
-  printf("| %13llu ", (long long unsigned)(calc_misses));
-}
-#else
 void print_file_effectiveness(BenchmarkStage stage, const char* filename, const benchmarker& results, const feature_benchmarker& features) {
   double actual = results[stage].best.elapsed_ns() / double(results.stats->blocks);
   double calc = features.calc_expected(stage, results);
@@ -417,7 +382,6 @@ void print_file_effectiveness(BenchmarkStage stage, const char* filename, const
   }
   printf("|\n");
 }
-#endif
 
 int main(int argc, char *argv[]) {
   // Read options

benchmark/benchmarker.h

@@ -2,7 +2,7 @@
 #define __BENCHMARKER_H
 
 #include "event_counter.h"
-#include "simdjson.h"
+#include "simdjson.h" // For SIMDJSON_DISABLE_DEPRECATED_WARNINGS
 
 #include <cassert>
 #include <cctype>
@@ -423,7 +423,7 @@ struct benchmarker {
         stage.instructions() / static_cast<double>(stats->structurals),
         stage.instructions() / static_cast<double>(stage.cycles())
       );
-#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+
       // NOTE: removed cycles/miss because it is a somewhat misleading stat
       printf("%s%-13s: %7.0f branch misses (%6.2f%%) - %.0f cache misses (%6.2f%%) - %.2f cache references\n",
         prefix,
@@ -434,7 +434,6 @@ struct benchmarker {
         percent(stage.cache_misses(), all_stages_without_allocation.cache_misses()),
         stage.cache_references()
       );
-#endif
     }
   }
 

benchmark/distinct_user_id/rapidjson.h

@@ -48,7 +48,7 @@ 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|kParseInsituFlag>(json.data()), result);
+    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag>(json.data()), result);
   }
 };
 BENCHMARK_TEMPLATE(distinct_user_id, rapidjson_insitu)->UseManualTime();

benchmark/distinct_user_id/sajson.h

@@ -9,8 +9,6 @@ namespace distinct_user_id {
 struct sajson {
   size_t ast_buffer_size{0};
   size_t *ast_buffer{nullptr};
-  ~sajson() { free(ast_buffer); }
-
   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"; }

benchmark/event_counter.h

@@ -1,15 +1,6 @@
 #ifndef __EVENT_COUNTER_H
 #define __EVENT_COUNTER_H
 
-#ifndef SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
-#ifdef __aarch64__
-// on ARM, we use just cycles and instructions
-#define SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS 1
-#else
-// elsewhere, we try to use four counters.
-#define SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS 0
-#endif
-#endif
 #include <cassert>
 #include <cctype>
 #ifndef _MSC_VER
@@ -55,12 +46,6 @@ struct event_count {
   event_count(const event_count& other): elapsed(other.elapsed), event_counts(other.event_counts) { }
 
   // The types of counters (so we can read the getter more easily)
-  #if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
-  enum event_counter_types {
-    CPU_CYCLES,
-    INSTRUCTIONS
-  };
-  #else
   enum event_counter_types {
     CPU_CYCLES,
     INSTRUCTIONS,
@@ -68,16 +53,15 @@ struct event_count {
     CACHE_REFERENCES,
     CACHE_MISSES
   };
-  #endif
+
   double elapsed_sec() const { return duration<double>(elapsed).count(); }
   double elapsed_ns() const { return duration<double, std::nano>(elapsed).count(); }
   double cycles() const { return static_cast<double>(event_counts[CPU_CYCLES]); }
   double instructions() const { return static_cast<double>(event_counts[INSTRUCTIONS]); }
-#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
   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]); }
-#endif
+
   event_count& operator=(const event_count& other) {
     this->elapsed = other.elapsed;
     this->event_counts = other.event_counts;
@@ -121,11 +105,9 @@ struct event_aggregate {
   double elapsed_ns() const { return total.elapsed_ns() / iterations; }
   double cycles() const { return total.cycles() / iterations; }
   double instructions() const { return total.instructions() / iterations; }
-#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
   double branch_misses() const { return total.branch_misses() / iterations; }
   double cache_references() const { return total.cache_references() / iterations; }
   double cache_misses() const { return total.cache_misses() / iterations; }
-#endif
 };
 
 struct event_collector {
@@ -135,16 +117,11 @@ struct event_collector {
 #if defined(__linux__)
   LinuxEvents<PERF_TYPE_HARDWARE> linux_events;
   event_collector(bool quiet = false) : linux_events(vector<int>{
-  #if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
-    PERF_COUNT_HW_CPU_CYCLES,
-    PERF_COUNT_HW_INSTRUCTIONS,
-  #else
     PERF_COUNT_HW_CPU_CYCLES,
     PERF_COUNT_HW_INSTRUCTIONS,
     PERF_COUNT_HW_BRANCH_MISSES,
     PERF_COUNT_HW_CACHE_REFERENCES,
     PERF_COUNT_HW_CACHE_MISSES
-  #endif
   }, quiet) {}
   bool has_events() {
     return linux_events.is_working();

benchmark/find_tweet/rapidjson.h

@@ -42,7 +42,7 @@ 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|kParseInsituFlag>(json.data()), find_id, result);
+    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag>(json.data()), find_id, result);
   }
 };
 BENCHMARK_TEMPLATE(find_tweet, rapidjson_insitu)->UseManualTime();

benchmark/find_tweet/sajson.h

@@ -11,8 +11,6 @@ struct sajson {
 
   size_t ast_buffer_size{0};
   size_t *ast_buffer{nullptr};
-  ~sajson() { free(ast_buffer); }
-
   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"; }

benchmark/json2msgpack/json2msgpack.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#include "json_benchmark/file_runner.h"
-
-namespace json2msgpack {
-
-using namespace json_benchmark;
-
-template <typename I> struct runner : public file_runner<I> {
-  std::string_view result;
-  std::unique_ptr<char[]> buffer;
-
-  bool setup(benchmark::State &state) {
-    bool isok = this->load_json(state, TWITTER_JSON);
-    if (isok) {
-      // Let us allocate a sizeable buffer.
-      buffer = std::unique_ptr<char[]>(new char[this->json.size() * 4 + 1024]);
-    }
-    return isok;
-  }
-
-  bool before_run(benchmark::State &state) {
-    if (!file_runner<I>::before_run(state)) {
-      return false;
-    }
-    // Clear the buffer.
-    ::memset(buffer.get(), 0, this->json.size() * 4 + 1024);
-    return true;
-  }
-
-  bool run(benchmark::State &) {
-    return this->implementation.run(this->json, buffer.get(), result);
-  }
-
-  template <typename R>
-  bool diff(benchmark::State &state, runner<R> &reference) {
-    return diff_results(state, result.size(), reference.result.size(), diff_flags::NONE);
-  }
-};
-
-struct simdjson_ondemand;
-
-template <typename I>
-simdjson_really_inline static void json2msgpack(benchmark::State &state) {
-  run_json_benchmark<runner<I>, runner<simdjson_ondemand>>(state);
-}
-
-} // namespace json2msgpack

benchmark/json2msgpack/nlohmann_json.h

@@ -1,117 +0,0 @@
-#pragma once
-#ifdef SIMDJSON_COMPETITION_NLOHMANN_JSON
-
-#include "json2msgpack.h"
-
-namespace json2msgpack {
-
-using namespace nlohmann;
-
-struct nlohmann_json2msgpack {
-  inline std::string_view to_msgpack(const simdjson::padded_string &json,
-                                     uint8_t *buf);
-
-private:
-  inline void write_double(const double d) noexcept;
-  inline void write_byte(const uint8_t b) noexcept;
-  inline void write_uint32(const uint32_t w) noexcept;
-  inline void write_string(const std::string& str);
-  inline void recursive_processor(basic_json<> element);
-
-  uint8_t *buff{};
-};
-
-std::string_view nlohmann_json2msgpack::to_msgpack(const simdjson::padded_string &json,
-                             uint8_t *buf) {
-  buff = buf;
-  auto val = nlohmann::json::parse(json.data(), json.data() + json.size());
-  recursive_processor(val);
-  return std::string_view(reinterpret_cast<char *>(buf), size_t(buff - buf));
-}
-
-void nlohmann_json2msgpack::write_double(const double d) noexcept {
-  *buff++ = 0xcb;
-  ::memcpy(buff, &d, sizeof(d));
-  buff += sizeof(d);
-}
-
-void nlohmann_json2msgpack::write_byte(const uint8_t b) noexcept {
-  *buff = b;
-  buff++;
-}
-
-void nlohmann_json2msgpack::write_uint32(const uint32_t w) noexcept {
-  ::memcpy(buff, &w, sizeof(w));
-  buff += sizeof(w);
-}
-
-void nlohmann_json2msgpack::write_string(const std::string & str) {
-  write_byte(0xdb);
-  write_uint32(uint32_t(str.size()));
-  ::memcpy(buff, str.data(), str.size());
-  buff += str.size();
-}
-
-void nlohmann_json2msgpack::recursive_processor(json element) {
-  switch (element.type()) {
-  case nlohmann::detail::value_t::array: {
-    uint32_t counter = 0;
-    write_byte(0xdd);
-    std::vector<json> array = element.get<std::vector<json>>();
-    write_uint32(uint32_t(array.size()));
-    for (auto child : array) {
-       recursive_processor(child);
-    }
-  } break;
-  case nlohmann::detail::value_t::object: {
-    write_byte(0xdf);
-    std::map<std::string,json> object = element.get<std::map<std::string,json>>();
-    write_uint32(uint32_t(object.size()));
-    for (auto field : object) {
-      write_string(field.first);
-      recursive_processor(field.second);
-    }
-  } break;
-
-  case nlohmann::detail::value_t::number_integer:
-  case nlohmann::detail::value_t::number_unsigned:
-  case nlohmann::detail::value_t::number_float:
-    write_double(double(element));
-    break;
-  case nlohmann::detail::value_t::string:
-    write_string(std::string(element));
-    break;
-  case nlohmann::detail::value_t::boolean:
-    write_byte(0xc2 + bool(element));
-    break;
-  case nlohmann::detail::value_t::null:
-    write_byte(0xc0);
-    break;
-  case nlohmann::detail::value_t::discarded:
-  case nlohmann::detail::value_t::binary:
-  default:
-    printf("unexpected\n");
-    break;
-  }
-}
-
-struct nlohmann_json {
-  using StringType = std::string_view;
-
-  nlohmann_json2msgpack parser{};
-
-  bool run(simdjson::padded_string &json, char *buffer,
-           std::string_view &result) {
-    result = parser.to_msgpack(json, reinterpret_cast<uint8_t *>(buffer));
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(json2msgpack, nlohmann_json)->UseManualTime();
-
-} // namespace json2msgpack
-
-#endif // SIMDJSON_COMPETITION_NLOHMANN_JSON
-
-
-

benchmark/json2msgpack/rapidjson.h

@@ -1,140 +0,0 @@
-
-
-#pragma once
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-
-#include "json2msgpack.h"
-
-namespace json2msgpack {
-
-using namespace rapidjson;
-
-template <int parseflag>
-struct rapidjson2msgpack {
-  inline std::string_view to_msgpack(char *json, uint8_t *buf);
-
-private:
-  inline void write_double(const double d) noexcept;
-  inline void write_byte(const uint8_t b) noexcept;
-  inline void write_uint32(const uint32_t w) noexcept;
-  inline void write_uint32_at(const uint32_t w, uint8_t *p) noexcept;
-  void write_string(const char * s, size_t length) noexcept;
-  inline void recursive_processor(Value &v);
-
-  uint8_t *buff{};
-};
-
-template <int parseflag>
-std::string_view rapidjson2msgpack<parseflag>::to_msgpack(char *json, uint8_t *buf) {
-  buff = buf;
-  Document doc{};
-  if(parseflag & kParseInsituFlag) {
-    doc.ParseInsitu<parseflag>(json);
-  } else {
-    doc.Parse<parseflag>(json);
-  }
-  recursive_processor(doc);
-  return std::string_view(reinterpret_cast<char *>(buf), size_t(buff - buf));
-}
-
-template <int parseflag>
-void rapidjson2msgpack<parseflag>::write_double(const double d) noexcept {
-  *buff++ = 0xcb;
-  ::memcpy(buff, &d, sizeof(d));
-  buff += sizeof(d);
-}
-
-template <int parseflag>
-void rapidjson2msgpack<parseflag>::write_byte(const uint8_t b) noexcept {
-  *buff = b;
-  buff++;
-}
-
-template <int parseflag>
-void rapidjson2msgpack<parseflag>::write_string(const char * c, size_t len) noexcept {
-  write_byte(0xdb);
-  write_uint32(uint32_t(len));
-  ::memcpy(buff, c, len);
-  buff += len;
-}
-
-template <int parseflag>
-void rapidjson2msgpack<parseflag>::write_uint32(const uint32_t w) noexcept {
-  ::memcpy(buff, &w, sizeof(w));
-  buff += sizeof(w);
-}
-
-template <int parseflag>
-void rapidjson2msgpack<parseflag>::write_uint32_at(const uint32_t w, uint8_t *p) noexcept {
-  ::memcpy(p, &w, sizeof(w));
-}
-
-template <int parseflag>
-void rapidjson2msgpack<parseflag>::recursive_processor(Value &v) {
-  switch (v.GetType()) {
-  case kArrayType:
-    write_byte(0xdd);
-    write_uint32(v.Size());
-    for (Value::ValueIterator i = v.Begin(); i != v.End(); ++i) {
-      recursive_processor(*i);
-    }
-    break;
-  case kObjectType:
-    write_byte(0xdf);
-    write_uint32(uint32_t(v.MemberEnd()-v.MemberBegin()));
-    for (Value::MemberIterator m = v.MemberBegin(); m != v.MemberEnd();
-         ++m) {
-      write_string(m->name.GetString(), m->name.GetStringLength());
-      recursive_processor(m->value);
-    }
-    break;
-  case kStringType:
-    write_string(v.GetString(), v.GetStringLength());
-    break;
-  case kNumberType:
-    write_double(v.GetDouble());
-    break;
-  case kFalseType:
-    write_byte(0xc2);
-    break;
-  case kTrueType:
-    write_byte(0xc3);
-    break;
-  case kNullType:
-    write_byte(0xc0);
-    break;
-  }
-}
-
-template <int parseflag>
-struct rapidjson_base {
-  using StringType = std::string_view;
-
-  rapidjson2msgpack<parseflag> parser{};
-
-  bool run(simdjson::padded_string &json, char *buffer,
-           std::string_view &result) {
-    result =
-        parser.to_msgpack(json.data(), reinterpret_cast<uint8_t *>(buffer));
-
-    return true;
-  }
-};
-
-
-using rapidjson_lossless = rapidjson_base<kParseValidateEncodingFlag|kParseFullPrecisionFlag>;
-
-BENCHMARK_TEMPLATE(json2msgpack, rapidjson_lossless)->UseManualTime();
-
-
-using rapidjson = rapidjson_base<kParseValidateEncodingFlag>;
-
-BENCHMARK_TEMPLATE(json2msgpack, rapidjson)->UseManualTime();
-
-using rapidjson_insitu = rapidjson_base<kParseValidateEncodingFlag|kParseInsituFlag>;
-
-BENCHMARK_TEMPLATE(json2msgpack, rapidjson_insitu)->UseManualTime();
-
-} // namespace json2msgpack
-
-#endif // SIMDJSON_COMPETITION_RAPIDJSON

benchmark/json2msgpack/sajson.h

@@ -1,131 +0,0 @@
-#pragma once
-#ifdef SIMDJSON_COMPETITION_SAJSON
-
-#include "json2msgpack.h"
-
-namespace json2msgpack {
-
-using namespace sajson;
-
-
-struct sajson2msgpack {
-  inline std::string_view to_msgpack(char *json, size_t size, uint8_t *buf);
-  virtual ~sajson2msgpack() { free(ast_buffer); }
-
-private:
-  inline void write_double(const double d) noexcept;
-  inline void write_byte(const uint8_t b) noexcept;
-  inline void write_uint32(const uint32_t w) noexcept;
-  inline void write_string(const char * s, size_t length) noexcept;
-  inline void recursive_processor(const sajson::value &v);
-
-  uint8_t *buff{};
-  size_t ast_buffer_size{0};
-  size_t *ast_buffer{nullptr};
-};
-
-
-std::string_view sajson2msgpack::to_msgpack(char *json, size_t size, uint8_t *buf) {
-  buff = buf;
-
-  if (!ast_buffer) {
-    ast_buffer_size = 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(size, json)
-  );
-
-  auto root = doc.get_root();
-  recursive_processor(root);
-  return std::string_view(reinterpret_cast<char *>(buf), size_t(buff - buf));
-}
-
-void sajson2msgpack::write_string(const char * c, size_t len) noexcept {
-  write_byte(0xdb);
-  write_uint32(uint32_t(len));
-  ::memcpy(buff, c, len);
-  buff += len;
-}
-
-void sajson2msgpack::write_double(const double d) noexcept {
-  *buff++ = 0xcb;
-  ::memcpy(buff, &d, sizeof(d));
-  buff += sizeof(d);
-}
-
-void sajson2msgpack::write_byte(const uint8_t b) noexcept {
-  *buff = b;
-  buff++;
-}
-
-void sajson2msgpack::write_uint32(const uint32_t w) noexcept {
-  ::memcpy(buff, &w, sizeof(w));
-  buff += sizeof(w);
-}
-
-void sajson2msgpack::recursive_processor(const sajson::value &node) {
-  using namespace sajson;
-  switch (node.get_type()) {
-  case TYPE_NULL:
-    write_byte(0xc0);
-    break;
-  case TYPE_FALSE:
-    write_byte(0xc2);
-    break;
-  case TYPE_TRUE:
-    write_byte(0xc3);
-    break;
-  case TYPE_ARRAY: {
-    auto length = node.get_length();
-    write_byte(0xdf);
-    write_uint32(uint32_t(length));
-    for (size_t i = 0; i < length; ++i) {
-      recursive_processor(node.get_array_element(i));
-    }
-    break;
-  }
-  case TYPE_OBJECT: {
-    auto length = node.get_length();
-    write_byte(0xdd);
-    write_uint32(uint32_t(length));
-    for (auto i = 0u; i < length; ++i) {
-      auto s = node.get_object_key(i);
-      write_string(s.data(), s.length());
-      recursive_processor(node.get_object_value(i));
-    }
-    break;
-  }
-  case TYPE_STRING:
-    write_string(node.as_cstring(), node.get_string_length());
-    break;
-  case TYPE_DOUBLE:
-  case TYPE_INTEGER:
-    write_double(node.get_number_value());
-    break;
-  default:
-    assert(false && "unknown node type");
-  }
-}
-
-
-struct sajson {
-  using StringType = std::string_view;
-
-  sajson2msgpack parser{};
-
-  bool run(simdjson::padded_string &json, char *buffer,
-           std::string_view &result) {
-    result =
-        parser.to_msgpack(json.data(), json.size(), reinterpret_cast<uint8_t *>(buffer));
-
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(json2msgpack, sajson)->UseManualTime();
-
-} // namespace json2msgpack
-
-#endif // SIMDJSON_COMPETITION_SAJSON

benchmark/json2msgpack/simdjson_ondemand.h

@@ -1,183 +0,0 @@
-#pragma once
-#if SIMDJSON_EXCEPTIONS
-
-#include "json2msgpack.h"
-
-namespace json2msgpack {
-
-using namespace simdjson;
-
-/**
- * @brief The simdjson2msgpack struct is used to quickly convert
- * JSON strings to msgpack views. You must provide a pointer to
- * a large memory region where the msgpack gets written. The
- * buffer should be large enough to store the msgpack output (which
- * can never be 3x larger than the input JSON) with an additional
- * simdjson::SIMDJSON_PADDING bytes.
- *
- * Recommended usage:
- *
- * simdjson2msgpack parser{};
- * simdjson::padded_string json = "[1,2]"_padded; // some JSON
- * uint8_t * buffer = new uint8_t[3*json.size() + simdjson::SIMDJSON_PADDING]; // large buffer
- *
- * std::string_view msgpack = parser.to_msgpack(json, buffer);
- *
- * The result (msgpack) is a string view to a msgpack serialization of the input JSON,
- * it points inside the buffer you provided.
- *
- * You may reuse the simdjson2msgpack instance though you should use
- * one per thread.
- */
-struct simdjson2msgpack {
-  /**
-   * @brief Converts the provided JSON into msgpack.
-   *
-   * @param json JSON input
-   * @param buf temporary buffer (must be large enough, with 32 bytes of
-   * padding)
-   * @return std::string_view msgpack output, writting to the temporary buffer
-   */
-  inline std::string_view to_msgpack(const simdjson::padded_string &json,
-                                     uint8_t *buf);
-
-private:
-  simdjson_really_inline void write_double(const double d) noexcept;
-  simdjson_really_inline void write_byte(const uint8_t b) noexcept;
-  simdjson_really_inline void write_uint32(const uint32_t w) noexcept;
-  simdjson_really_inline uint8_t *skip_uint32() noexcept;
-  simdjson_really_inline void write_uint32_at(const uint32_t w,
-                                              uint8_t *p) noexcept;
-  simdjson_really_inline void
-  write_raw_string(simdjson::ondemand::raw_json_string rjs);
-  inline void recursive_processor(simdjson::ondemand::value element);
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc;
-  uint8_t *buff{};
-};
-
-std::string_view
-simdjson2msgpack::to_msgpack(const simdjson::padded_string &json,
-                             uint8_t *buf) {
-  buff = buf;
-  ondemand::document doc = parser.iterate(json);
-  if (doc.is_scalar()) {
-    // we have a special case where the JSON document is a single document...
-    switch (doc.type()) {
-    case simdjson::ondemand::json_type::number:
-      write_double(doc.get_double());
-      break;
-    case simdjson::ondemand::json_type::string:
-      write_raw_string(doc.get_raw_json_string());
-      break;
-    case simdjson::ondemand::json_type::boolean:
-      write_byte(0xc2 + doc.get_bool());
-      break;
-    case simdjson::ondemand::json_type::null:
-      write_byte(0xc0);
-      break;
-    case simdjson::ondemand::json_type::array:
-    case simdjson::ondemand::json_type::object:
-    default:
-      // impossible
-      break;
-    }
-  } else {
-    simdjson::ondemand::value val = doc;
-    recursive_processor(val);
-  }
-  return std::string_view(reinterpret_cast<char *>(buf), size_t(buff - buf));
-}
-
-void simdjson2msgpack::write_double(const double d) noexcept {
-  *buff++ = 0xcb;
-  ::memcpy(buff, &d, sizeof(d));
-  buff += sizeof(d);
-}
-
-void simdjson2msgpack::write_byte(const uint8_t b) noexcept {
-  *buff = b;
-  buff++;
-}
-
-void simdjson2msgpack::write_uint32(const uint32_t w) noexcept {
-  ::memcpy(buff, &w, sizeof(w));
-  buff += sizeof(w);
-}
-
-uint8_t *simdjson2msgpack::skip_uint32() noexcept {
-  uint8_t *ret = buff;
-  buff += sizeof(uint32_t);
-  return ret;
-}
-
-void simdjson2msgpack::write_uint32_at(const uint32_t w, uint8_t *p) noexcept {
-  ::memcpy(p, &w, sizeof(w));
-}
-
-void simdjson2msgpack::write_raw_string(
-    simdjson::ondemand::raw_json_string in) {
-  write_byte(0xdb);
-  uint8_t *location = skip_uint32();
-  std::string_view v = parser.unescape(in, buff);
-  write_uint32_at(uint32_t(v.size()), location);
-}
-
-void simdjson2msgpack::recursive_processor(simdjson::ondemand::value element) {
-  switch (element.type()) {
-  case simdjson::ondemand::json_type::array: {
-    uint32_t counter = 0;
-    write_byte(0xdd);
-    uint8_t *location = skip_uint32();
-    for (auto child : element.get_array()) {
-      counter++;
-      recursive_processor(child.value());
-    }
-    write_uint32_at(counter, location);
-  } break;
-  case simdjson::ondemand::json_type::object: {
-    uint32_t counter = 0;
-    write_byte(0xdf);
-    uint8_t *location = skip_uint32();
-    for (auto field : element.get_object()) {
-      counter++;
-      write_raw_string(field.key());
-      recursive_processor(field.value());
-    }
-    write_uint32_at(counter, location);
-  } break;
-  case simdjson::ondemand::json_type::number:
-    write_double(element.get_double());
-    break;
-  case simdjson::ondemand::json_type::string:
-    write_raw_string(element.get_raw_json_string());
-    break;
-  case simdjson::ondemand::json_type::boolean:
-    write_byte(0xc2 + element.get_bool());
-    break;
-  case simdjson::ondemand::json_type::null:
-    write_byte(0xc0);
-    break;
-  default:
-    SIMDJSON_UNREACHABLE();
-  }
-}
-
-struct simdjson_ondemand {
-  using StringType = std::string_view;
-
-  simdjson2msgpack parser{};
-
-  bool run(simdjson::padded_string &json, char *buffer,
-           std::string_view &result) {
-    result = parser.to_msgpack(json, reinterpret_cast<uint8_t *>(buffer));
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(json2msgpack, simdjson_ondemand)->UseManualTime();
-
-} // namespace json2msgpack
-
-#endif // SIMDJSON_EXCEPTIONS

benchmark/json2msgpack/yyjson.h

@@ -1,122 +0,0 @@
-#pragma once
-#ifdef SIMDJSON_COMPETITION_YYJSON
-
-#include "json2msgpack.h"
-
-namespace json2msgpack {
-
-struct yyjson2msgpack {
-  inline std::string_view to_msgpack(yyjson_doc *doc, uint8_t *buf);
-
-private:
-  inline void write_double(const double d) noexcept;
-  inline void write_byte(const uint8_t b) noexcept;
-  inline void write_uint32(const uint32_t w) noexcept;
-  inline void write_string(const char *s, size_t length) noexcept;
-  inline void recursive_processor(yyjson_val *obj);
-
-  uint8_t *buff{};
-};
-
-std::string_view yyjson2msgpack::to_msgpack(yyjson_doc *doc, uint8_t *buf) {
-  buff = buf;
-  yyjson_val *root = yyjson_doc_get_root(doc);
-  recursive_processor(root);
-  return std::string_view(reinterpret_cast<char *>(buf), size_t(buff - buf));
-}
-
-void yyjson2msgpack::write_string(const char *c, size_t len) noexcept {
-  write_byte(0xdb);
-  write_uint32(uint32_t(len));
-  ::memcpy(buff, c, len);
-  buff += len;
-}
-
-void yyjson2msgpack::write_double(const double d) noexcept {
-  *buff++ = 0xcb;
-  ::memcpy(buff, &d, sizeof(d));
-  buff += sizeof(d);
-}
-
-void yyjson2msgpack::write_byte(const uint8_t b) noexcept {
-  *buff = b;
-  buff++;
-}
-
-void yyjson2msgpack::write_uint32(const uint32_t w) noexcept {
-  ::memcpy(buff, &w, sizeof(w));
-  buff += sizeof(w);
-}
-
-void yyjson2msgpack::recursive_processor(yyjson_val *obj) {
-  size_t idx, max;
-  yyjson_val *val;
-  yyjson_val *key;
-  switch (yyjson_get_type(obj)) {
-  case YYJSON_TYPE_STR:
-    write_string(yyjson_get_str(obj), yyjson_get_len(obj));
-    break;
-  case YYJSON_TYPE_ARR:
-    write_byte(0xdf);
-    write_uint32(uint32_t(yyjson_arr_size(obj)));
-    yyjson_arr_foreach(obj, idx, max, val) { recursive_processor(val); }
-   break;
-  case YYJSON_TYPE_OBJ:
-    write_byte(0xdd);
-    write_uint32(uint32_t(yyjson_obj_size(obj)));
-    yyjson_obj_foreach(obj, idx, max, key, val) {
-      write_string(yyjson_get_str(key), yyjson_get_len(key));
-      recursive_processor(val);
-    }
-    break;
-  case YYJSON_TYPE_BOOL:
-    write_byte(0xc2 + yyjson_get_bool(obj));
-    break;
-  case YYJSON_TYPE_NULL:
-    write_byte(0xc0);
-    break;
-  case YYJSON_TYPE_NUM:
-    switch (yyjson_get_subtype(obj)) {
-    case YYJSON_SUBTYPE_UINT:
-      write_double(double(yyjson_get_uint(obj)));
-      break;
-    case YYJSON_SUBTYPE_SINT:
-      write_double(double(yyjson_get_sint(obj)));
-      break;
-    case YYJSON_SUBTYPE_REAL:
-      write_double(yyjson_get_real(obj));
-      break;
-    default:
-      SIMDJSON_UNREACHABLE();
-    }
-    break;
-  default:
-    SIMDJSON_UNREACHABLE();
-  }
-}
-
-struct yyjson : yyjson2msgpack {
-  bool run(simdjson::padded_string &json, char *buffer,
-           std::string_view &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
-    result = to_msgpack(doc, reinterpret_cast<uint8_t*>(buffer));
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(json2msgpack, yyjson)->UseManualTime();
-
-struct yyjson_insitu : yyjson2msgpack {
-  bool run(simdjson::padded_string &json, char *buffer,
-           std::string_view &result) {
-    yyjson_doc *doc =
-        yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
-    result = to_msgpack(doc, reinterpret_cast<uint8_t*>(buffer));
-    return true;
-  }
-};
-BENCHMARK_TEMPLATE(json2msgpack, yyjson_insitu)->UseManualTime();
-
-} // namespace json2msgpack
-
-#endif // SIMDJSON_COMPETITION_YYJSON

benchmark/json_benchmark/run_json_benchmark.h

@@ -58,11 +58,10 @@ template<typename B, typename R> static void run_json_benchmark(benchmark::State
   if (collector.has_events()) {
     state.counters["instructions"] = events.instructions();
     state.counters["cycles"]       = events.cycles();
-#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
     state.counters["branch_miss"]  = events.branch_misses();
     state.counters["cache_miss"]   = events.cache_misses();
     state.counters["cache_ref"]    = events.cache_references();
-#endif
+
     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());
@@ -70,11 +69,9 @@ template<typename B, typename R> static void run_json_benchmark(benchmark::State
 
     state.counters["best_instructions"] = events.best.instructions();
     state.counters["best_cycles"]       = events.best.cycles();
-#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
     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();
-#endif
 
     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();
@@ -95,11 +92,9 @@ template<typename B, typename R> static void run_json_benchmark(benchmark::State
   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);
-#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
     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);
-#endif
   }
 
   label << " items=" << setw(10) << bench.items_per_iteration() << setw(0);

benchmark/kostya/nlohmann_json_sax.h

@@ -42,7 +42,7 @@ struct nlohmann_json_sax {
             return true;
         }
         bool number_unsigned(number_unsigned_t val) override {  // Need this event because coordinate value can be equal to 1
-            buffer[k] = double(val);
+            buffer[k] = val;
             if (k == 2) {
                 result.emplace_back(json_benchmark::point{buffer[0],buffer[1],buffer[2]});
                 k = 0;

benchmark/kostya/rapidjson.h

@@ -51,7 +51,7 @@ 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|kParseInsituFlag>(json.data()), result);
+    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag>(json.data()), result);
   }
 };
 BENCHMARK_TEMPLATE(kostya, rapidjson_insitu)->UseManualTime();

benchmark/kostya/sajson.h

@@ -11,7 +11,6 @@ struct sajson {
 
   size_t ast_buffer_size{0};
   size_t *ast_buffer{nullptr};
-  ~sajson() { free(ast_buffer); }
 
   simdjson_really_inline double get_double(const ::sajson::value &obj, std::string_view key) {
     using namespace sajson;

benchmark/large_amazon_cellphones/large_amazon_cellphones.h

@@ -6,9 +6,6 @@
 
 namespace large_amazon_cellphones {
 
-const bool UNTHREADED = false;
-const bool THREADED = true;
-
 static const simdjson::padded_string &get_built_json();
 
 using namespace json_benchmark;
@@ -84,11 +81,11 @@ static const simdjson::padded_string &get_built_json() {
   return json;
 }
 
-template<bool threaded>
+
 struct simdjson_dom;
 
 template<typename I> simdjson_really_inline static void large_amazon_cellphones(benchmark::State &state) {
-  run_json_benchmark<runner<I>, runner<simdjson_dom<UNTHREADED>>>(state);
+  run_json_benchmark<runner<I>, runner<simdjson_dom>>(state);
 }
 
 }   // namespace large_amazon_cellphones

benchmark/large_amazon_cellphones/simdjson_dom.h

@@ -9,16 +9,12 @@ namespace large_amazon_cellphones {
 
 using namespace simdjson;
 
-template<bool threaded>
 struct simdjson_dom {
   using StringType = std::string;
 
   dom::parser parser{};
 
   bool run(simdjson::padded_string &json, std::map<StringType, brand> &result) {
-#ifdef SIMDJSON_THREADS_ENABLED
-    parser.threaded = threaded;
-#endif
     auto stream = parser.parse_many(json);
     auto i = stream.begin();
     ++i;  // Skip first line
@@ -42,10 +38,7 @@ struct simdjson_dom {
 
 };
 
-BENCHMARK_TEMPLATE(large_amazon_cellphones, simdjson_dom<UNTHREADED>)->UseManualTime();
-#ifdef SIMDJSON_THREADS_ENABLED
-BENCHMARK_TEMPLATE(large_amazon_cellphones, simdjson_dom<THREADED>)->UseManualTime();
-#endif
+BENCHMARK_TEMPLATE(large_amazon_cellphones, simdjson_dom)->UseManualTime();
 
 } // namespace large_amazon_cellphones
 

benchmark/large_amazon_cellphones/simdjson_ondemand.h

@@ -8,16 +8,12 @@ namespace large_amazon_cellphones {
 
 using namespace simdjson;
 
-template<bool threaded>
 struct simdjson_ondemand {
   using StringType = std::string;
 
   ondemand::parser parser{};
 
   bool run(simdjson::padded_string &json, std::map<StringType, brand> &result) {
-#ifdef SIMDJSON_THREADS_ENABLED
-    parser.threaded = threaded;
-#endif
     ondemand::document_stream stream = parser.iterate_many(json);
     ondemand::document_stream::iterator i = stream.begin();
     ++i;  // Skip first line
@@ -62,10 +58,7 @@ struct simdjson_ondemand {
 
 };
 
-BENCHMARK_TEMPLATE(large_amazon_cellphones, simdjson_ondemand<UNTHREADED>)->UseManualTime();
-#ifdef SIMDJSON_THREADS_ENABLED
-BENCHMARK_TEMPLATE(large_amazon_cellphones, simdjson_ondemand<THREADED>)->UseManualTime();
-#endif
+BENCHMARK_TEMPLATE(large_amazon_cellphones, simdjson_ondemand)->UseManualTime();
 
 } // namespace amazon_cellphones
 

benchmark/large_random/nlohmann_json_sax.h

@@ -34,7 +34,7 @@ struct nlohmann_json_sax {
             return true;
         }
         bool number_unsigned(number_unsigned_t val) override {
-            buffer[k] = double(val);
+            buffer[k] = val;
             if (k == 2) {
                 result.emplace_back(json_benchmark::point{buffer[0],buffer[1],buffer[2]});
                 k = 0;

benchmark/large_random/rapidjson.h

@@ -48,7 +48,7 @@ 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|kParseInsituFlag>(json.data()), result);
+    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag>(json.data()), result);
   }
 };
 BENCHMARK_TEMPLATE(large_random, rapidjson_insitu)->UseManualTime();

benchmark/large_random/sajson.h

@@ -11,7 +11,6 @@ struct sajson {
 
   size_t ast_buffer_size{0};
   size_t *ast_buffer{nullptr};
-  ~sajson() { free(ast_buffer); }
 
   simdjson_really_inline double get_double(const ::sajson::value &obj, std::string_view key) {
     using namespace sajson;

benchmark/partial_tweets/rapidjson.h

@@ -70,7 +70,7 @@ BENCHMARK_TEMPLATE(partial_tweets, rapidjson)->UseManualTime();
 
 struct rapidjson_insitu : rapidjson_base {
   bool run(simdjson::padded_string &json, std::vector<tweet<std::string_view>> &result) {
-    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag|kParseInsituFlag>(json.data()), result);
+    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag>(json.data()), result);
   }
 };
 BENCHMARK_TEMPLATE(partial_tweets, rapidjson_insitu)->UseManualTime();

benchmark/partial_tweets/sajson.h

@@ -11,8 +11,6 @@ struct sajson {
 
   size_t ast_buffer_size{0};
   size_t *ast_buffer{nullptr};
-  ~sajson() { free(ast_buffer); }
-
   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"; }

benchmark/top_tweet/nlohmann_json_sax.h

@@ -48,7 +48,7 @@ struct nlohmann_json_sax {
         }
         bool number_unsigned(number_unsigned_t val) override {
             if (values & key_rt && !(values & found_rt)) {   // retweet_count
-                rt = int(val);
+                rt = val;
                 values &= ~(key_rt);
                 values |= (found_rt);
                 if (rt <= max_rt && rt >= result.retweet_count) {    // Check if current tweet has more retweet than previous top tweet

benchmark/top_tweet/rapidjson.h

@@ -59,7 +59,7 @@ BENCHMARK_TEMPLATE(top_tweet, rapidjson)->UseManualTime();
 
 struct rapidjson_insitu : rapidjson_base {
   bool run(simdjson::padded_string &json, int64_t max_retweet_count, top_tweet_result<StringType> &result) {
-    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag|kParseInsituFlag>(json.data()), max_retweet_count, result);
+    return rapidjson_base::run(doc.ParseInsitu<kParseValidateEncodingFlag>(json.data()), max_retweet_count, result);
   }
 };
 BENCHMARK_TEMPLATE(top_tweet, rapidjson_insitu)->UseManualTime();

benchmark/top_tweet/sajson.h

@@ -11,7 +11,6 @@ struct sajson {
 
   size_t ast_buffer_size{0};
   size_t *ast_buffer{nullptr};
-  ~sajson() { free(ast_buffer); }
 
   bool run(simdjson::padded_string &json, int32_t max_retweet_count, top_tweet_result<StringType> &result) {
     if (!ast_buffer) {

doc/basics.md

@@ -3,46 +3,38 @@ The Basics
 
 An overview of what you need to know to use simdjson, with examples.
 
-- [The Basics](#the-basics)
-  - [Requirements](#requirements)
-  - [Including simdjson](#including-simdjson)
-  - [Using simdjson with package managers](#using-simdjson-with-package-managers)
-  - [Using simdjson as a CMake dependency](#using-simdjson-as-a-cmake-dependency)
-  - [Versions](#versions)
-  - [The Basics: Loading and Parsing JSON Documents](#the-basics-loading-and-parsing-json-documents)
-  - [Documents are Iterators](#documents-are-iterators)
-    - [Parser, Document and JSON Scope](#parser-document-and-json-scope)
-  - [C++11 Support and string_view](#c11-support-and-string_view)
-  - [Using the Parsed JSON](#using-the-parsed-json)
-    - [Using the Parsed JSON: Additional examples](#using-the-parsed-json-additional-examples)
-  - [Minifying JSON strings without parsing](#minifying-json-strings-without-parsing)
-  - [UTF-8 validation (alone)](#utf-8-validation-alone)
-  - [JSON Pointer](#json-pointer)
-  - [Error Handling](#error-handling)
-    - [Error Handling Examples without Exceptions](#error-handling-examples-without-exceptions)
-    - [Disabling Exceptions](#disabling-exceptions)
-    - [Exceptions](#exceptions)
-    - [Current location in document](#current-location-in-document)
-  - [Rewinding](#rewinding)
-  - [Direct Access to the Raw String](#direct-access-to-the-raw-string)
-  - [Newline-Delimited JSON (ndjson) and JSON lines](#newline-delimited-json-ndjson-and-json-lines)
-  - [Parsing Numbers Inside Strings](#parsing-numbers-inside-strings)
-  - [Dynamic Number Types](#dynamic-number-types)
-  - [Raw Strings](#raw-strings)
-  - [Thread Safety](#thread-safety)
-  - [Standard Compliance](#standard-compliance)
-  - [Backwards Compatibility](#backwards-compatibility)
+* [Requirements](#requirements)
+* [Including simdjson](#including-simdjson)
+* [Using simdjson with package managers](#using-simdjson-with-package-managers)
+* [Using simdjson as a CMake dependency](#using-simdjson-as-a-cmake-dependency)
+* [Versions](#versions)
+* [The Basics: Loading and Parsing JSON Documents](#the-basics-loading-and-parsing-json-documents)
+* [Documents are Iterators](#documents-are-iterators)
+* [C++11 Support and string_view](#c11-support-and-string_view)
+* [Using the Parsed JSON](#using-the-parsed-json)
+* [Minifying JSON strings without parsing](#minifying-json-strings-without-parsing)
+* [UTF-8 validation (alone)](#utf-8-validation-alone)
+* [JSON Pointer](#json-pointer)
+* [Error Handling](#error-handling)
+  * [Error Handling Example without Exceptions](#error-handling-examples-without-exceptions)
+  * [Disabling Exceptions](#disabling-exceptions)
+  * [Exceptions](#exceptions)
+  * [Current location in document](#current-location-in-document)
+* [Rewinding](#rewinding)
+* [Direct Access to the Raw String](#direct-access-to-the-raw-string)
+* [Newline-Delimited JSON (ndjson) and JSON lines](#newline-delimited-json-ndjson-and-json-lines)
+* [Parsing Numbers Inside Strings](#parsing-numbers-inside-strings)
+* [Dynamic Number Types](#dynamic-number-types)
+* [Thread Safety](#thread-safety)
+* [Standard Compliance](#standard-compliance)
 
 
 Requirements
 ------------------
 
-- A recent compiler (LLVM clang 6 or better, GNU GCC 7.4 or better, Xcode 11 or better) on a 64-bit (PPC, ARM or x64 Intel/AMD) POSIX systems such as macOS, freeBSD or Linux. We require that the compiler supports the C++11 standard or better.
+- A recent compiler (LLVM clang6 or better, GNU GCC 7.4 or better, Xcode 11 or better) on a 64-bit (PPC, ARM or x64 Intel/AMD) POSIX systems such as macOS, freeBSD or Linux. We require that the compiler supports the C++11 standard or better.
 - Visual Studio 2017 or better under 64-bit Windows. Users should target a 64-bit build (x64) instead of a 32-bit build (x86). We support the LLVM clang compiler under Visual Studio (clangcl) as well as as the regular Visual Studio compiler. We also support MinGW 64-bit under Windows.
 
-
-Support for AVX-512 require a processor with AVX512-VBMI2 support (Ice Lake or better) under a 64-bit system and a recent compiler (LLVM clang 6 or better, GCC 8 or better, Visual Studio 2019 or better).
-
 Including simdjson
 ------------------
 
@@ -472,7 +464,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   ```
 * **Tree Walking and JSON Element Types:** Sometimes you don't necessarily have a document
   with a known type, and are trying to generically inspect or walk over JSON elements. To do that, you can use iterators and the `type()` method. You can also represent arbitrary JSON values with
-  `ondemand::value` instances: it can represent anything except a scalar document (lone number, string, null or Boolean). You can check for scalar documents with the method `scalar()`. You may also access [raw strings](#raw-strings).
+  `ondemand::value` instances: it can represent anything except a scalar document (lone number, string, null or Boolean). You can check for scalar documents with the method `scalar()`.
   For example, the following is a quick and dirty recursive function that verbosely prints the JSON document as JSON. This example also illustrates lifecycle requirements: the `document` instance holds the iterator. The document must remain in scope while you are accessing instances of `value`, `object` and `array`.
   ```c++
   void recursive_print_json(ondemand::value element) {
@@ -1409,6 +1401,10 @@ You must check the type before accessing the value: it is an error to call `get_
 
 The `get_number()` function is designed with performance in mind. When calling `get_number()`, you scan the number string only once, determining efficiently the type and storing it in an efficient manner.
 
+If you only need to compute `v.get_number().get_number_type()` on
+a `document` or `value` instance, you should call directly the faster method
+`v.get_number_type()` which does not generate an
+intermediate `number` instance.
 
 Consider the following example:
 ```C++
@@ -1421,7 +1417,9 @@ Consider the following example:
       std::cout << "negative: " << val.is_negative() << " ";
       std::cout << "is_integer: " << val.is_integer() << " ";
       ondemand::number num = val.get_number();
-      ondemand::number_type t = num.get_number_type();
+      // direct computation without materializing the number:
+      ondemand::number_type dt = val.get_number_type();
+      if(t != dt) { throw std::runtime_error("bug"); }
       switch(t) {
         case ondemand::number_type::signed_integer:
           std::cout  << "integer: " << int64_t(num) << " ";
@@ -1450,42 +1448,6 @@ It will output:
 9999999999999999999 negative: 0 is_integer: 1 large 64-bit integer: 9999999999999999999 large 64-bit integer: 9999999999999999999
 ```
 
-Raw Strings
------------
-
-It is sometimes useful to have access to a raw (unescaped) string: we make available a
-minimalist `raw_json_string` data type which contains a pointer inside the string in the
-original document, right after the quote. It is accessible via `get_raw_json_string()` on a
-string instance and returned by the `key()` method on an object's field instance. It is always
-optional: replacing `get_raw_json_string()` with `get_string()` and `key()` by
-`unescaped_key()` returns an `string_view` instance of the unescaped string.
-
-You can quickly compare a `raw_json_string` instance with a target string. You may also
-unescape  the `raw_json_string` on your own string buffer: `parser.unescape(mystr, ptr)`
-advances the provided pointer `ptr` and returns a string_view instance on the newly serialized
-string upon success, otherwise it returns an error. When unescaping to your own string buffer,
-you should ensure that you have sufficient memory space: the total size of the strings plus
-`simdjson::SIMDJSON_PADDING` bytes. The following example illustrates how we can unescape
-JSON string to a user-provided buffer:
-
-```C++
-    auto json = R"( {"name": "Jack The Ripper \u0033"} )"_padded;
-    // We create a buffer large enough to store all strings we need:
-    std::unique_ptr<uint8_t[]> buffer(new uint8_t[json.size() + simdjson::SIMDJSON_PADDING]);
-    uint8_t * ptr = buffer.get();
-    ondemand::parser parser;
-    ondemand::document doc = parser.iterate(json);
-    // We store our strings as 'string_view' instances in a vector:
-    std::vector<std::string_view> mystrings;
-    for (auto key_value : doc.get_object()) {
-      std::string_view keysv = parser.unescape(key_value.key(), ptr);// writes 'name'
-      mystrings.push_back(keysv);
-      std::string_view valuesv = parser.unescape(key_value.value().get_raw_json_string(), ptr);
-      // writes 'Jack The Ripper 3', escaping the \u0033
-      mystrings.push_back(valuesv);
-    }
-```
-
 Thread Safety
 -------------
 

doc/implementation-selection.md

@@ -17,7 +17,6 @@ different version of the JSON parser for different CPU architectures, often with
 algorithms to take better advantage of a given CPU!
 
 The current implementations are:
-* icelake: AVX-512F, AVX-512VBMI, etc.
 * haswell: AVX2 (2013 Intel Haswell or later)
 * westmere: SSE4.2 (2010 Westmere or later).
 * arm64: 64-bit ARMv8-A NEON
@@ -29,7 +28,7 @@ compiles *all* the implementations into the executable. On Intel, it will includ
 (haswell, westmere and fallback), on ARM it will include 2 (arm64 and fallback), and on PPC it will include 2 (ppc64 and fallback).
 
 If you know more about where you're going to run and want to save the space, you can disable any of
-these implementations at compile time with `-DSIMDJSON_IMPLEMENTATION_X=0` (where X is ICELAKE, HASWELL,
+these implementations at compile time with `-DSIMDJSON_IMPLEMENTATION_X=0` (where X is HASWELL,
 WESTMERE, ARM64, PPC64 and FALLBACK).
 
 The simdjson library automatically sets header flags for each implementation as it compiles; there

include/simdjson/common_defs.h

@@ -122,9 +122,6 @@ constexpr size_t DEFAULT_MAX_DEPTH = 1024;
 
   #define SIMDJSON_PUSH_DISABLE_WARNINGS _Pragma("GCC diagnostic push")
   // gcc doesn't seem to disable all warnings with all and extra, add warnings here as necessary
-  // We do it separately for clang since it has different warnings.
-  #ifdef __clang__
-  // clang is missing -Wmaybe-uninitialized.
   #define SIMDJSON_PUSH_DISABLE_ALL_WARNINGS SIMDJSON_PUSH_DISABLE_WARNINGS \
     SIMDJSON_DISABLE_GCC_WARNING(-Weffc++) \
     SIMDJSON_DISABLE_GCC_WARNING(-Wall) \
@@ -137,22 +134,6 @@ constexpr size_t DEFAULT_MAX_DEPTH = 1024;
     SIMDJSON_DISABLE_GCC_WARNING(-Wshadow) \
     SIMDJSON_DISABLE_GCC_WARNING(-Wunused-parameter) \
     SIMDJSON_DISABLE_GCC_WARNING(-Wunused-variable)
-  #else // __clang__
-  #define SIMDJSON_PUSH_DISABLE_ALL_WARNINGS SIMDJSON_PUSH_DISABLE_WARNINGS \
-    SIMDJSON_DISABLE_GCC_WARNING(-Weffc++) \
-    SIMDJSON_DISABLE_GCC_WARNING(-Wall) \
-    SIMDJSON_DISABLE_GCC_WARNING(-Wconversion) \
-    SIMDJSON_DISABLE_GCC_WARNING(-Wextra) \
-    SIMDJSON_DISABLE_GCC_WARNING(-Wattributes) \
-    SIMDJSON_DISABLE_GCC_WARNING(-Wimplicit-fallthrough) \
-    SIMDJSON_DISABLE_GCC_WARNING(-Wnon-virtual-dtor) \
-    SIMDJSON_DISABLE_GCC_WARNING(-Wreturn-type) \
-    SIMDJSON_DISABLE_GCC_WARNING(-Wshadow) \
-    SIMDJSON_DISABLE_GCC_WARNING(-Wunused-parameter) \
-    SIMDJSON_DISABLE_GCC_WARNING(-Wunused-variable) \
-    SIMDJSON_DISABLE_GCC_WARNING(-Wmaybe-uninitialized)
-  #endif // __clang__
-
   #define SIMDJSON_PRAGMA(P) _Pragma(#P)
   #define SIMDJSON_DISABLE_GCC_WARNING(WARNING) SIMDJSON_PRAGMA(GCC diagnostic ignored #WARNING)
   #if defined(SIMDJSON_CLANG_VISUAL_STUDIO)

include/simdjson/error.h

@@ -143,6 +143,13 @@ struct simdjson_result_base : protected std::pair<T, error_code> {
    */
   simdjson_really_inline error_code get(T &value) && noexcept;
 
+  /**
+   * Move the value to the provided variable.
+   *
+   * @param value The variable to assign the value to. May not be set if there is an error.
+   */
+  simdjson_really_inline const T &value(error_code &error) const & noexcept;
+
   /**
    * The error.
    */

include/simdjson/generic/dom_parser_implementation.h

@@ -35,7 +35,6 @@ public:
   simdjson_warn_unused error_code stage1(const uint8_t *buf, size_t len, stage1_mode partial) noexcept final;
   simdjson_warn_unused error_code stage2(dom::document &doc) noexcept final;
   simdjson_warn_unused error_code stage2_next(dom::document &doc) noexcept final;
-  simdjson_warn_unused uint8_t *parse_string(const uint8_t *src, uint8_t *dst) const noexcept final;
   inline simdjson_warn_unused error_code set_capacity(size_t capacity) noexcept final;
   inline simdjson_warn_unused error_code set_max_depth(size_t max_depth) noexcept final;
 private:

include/simdjson/generic/numberparsing.h

@@ -1067,11 +1067,6 @@ simdjson_unused simdjson_really_inline simdjson_result<ondemand::number_type> ge
   while(static_cast<uint8_t>(*p - '0') <= 9) { p++; }
   if ( p == src ) { return NUMBER_ERROR; }
   if (jsoncharutils::is_structural_or_whitespace(*p)) {
-    // We have an integer.
-    // If the number is negative and valid, it must be a signed integer.
-    if(negative) { return ondemand::number_type::signed_integer; }
-    // We want values larger or equal to 9223372036854775808 to be unsigned
-    // integers, and the other values to be signed integers.
     int digit_count = int(p - src);
     if(digit_count >= 19) {
       const uint8_t * smaller_big_integer = reinterpret_cast<const uint8_t *>("9223372036854775808");
@@ -1081,7 +1076,6 @@ simdjson_unused simdjson_really_inline simdjson_result<ondemand::number_type> ge
     }
     return ondemand::number_type::signed_integer;
   }
-  // Hopefully, we have 'e' or 'E' or '.'.
   return ondemand::number_type::floating_point_number;
 }
 

include/simdjson/generic/ondemand/array-inl.h

@@ -89,7 +89,6 @@ simdjson_really_inline simdjson_result<std::string_view> array::raw_json() noexc
   return std::string_view(reinterpret_cast<const char*>(starting_point), size_t(final_point - starting_point));
 }
 
-SIMDJSON_PUSH_DISABLE_WARNINGS
 SIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING
 simdjson_really_inline simdjson_result<size_t> array::count_elements() & noexcept {
   size_t count{0};
@@ -102,7 +101,6 @@ simdjson_really_inline simdjson_result<size_t> array::count_elements() & noexcep
   iter.reset_array();
   return count;
 }
-SIMDJSON_POP_DISABLE_WARNINGS
 
 simdjson_really_inline simdjson_result<bool> array::is_empty() & noexcept {
   bool is_not_empty;

include/simdjson/generic/ondemand/document-inl.h

@@ -24,10 +24,6 @@ inline simdjson_result<const char *> document::current_location() noexcept {
   return iter.current_location();
 }
 
-inline int32_t document::current_depth() const noexcept {
-  return iter.depth();
-}
-
 inline bool document::is_alive() noexcept {
   return iter.is_alive();
 }
@@ -475,11 +471,6 @@ simdjson_really_inline simdjson_result<const char *> simdjson_result<SIMDJSON_IM
   return first.current_location();
 }
 
-simdjson_really_inline int32_t simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::current_depth() const noexcept {
-  if (error()) { return error(); }
-  return first.current_depth();
-}
-
 simdjson_really_inline simdjson_result<std::string_view> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::raw_json_token() noexcept {
   if (error()) { return error(); }
   return first.raw_json_token();
@@ -537,7 +528,6 @@ simdjson_really_inline simdjson_result<value> document_reference::find_field_uno
 simdjson_really_inline simdjson_result<json_type> document_reference::type() noexcept { return doc->type(); }
 simdjson_really_inline simdjson_result<bool> document_reference::is_scalar() noexcept { return doc->is_scalar(); }
 simdjson_really_inline simdjson_result<const char *> document_reference::current_location() noexcept { return doc->current_location(); }
-simdjson_really_inline int32_t document_reference::current_depth() const noexcept { return doc->current_depth(); }
 simdjson_really_inline bool document_reference::is_negative() noexcept { return doc->is_negative(); }
 simdjson_really_inline simdjson_result<bool> document_reference::is_integer() noexcept { return doc->is_integer(); }
 simdjson_really_inline simdjson_result<number_type> document_reference::get_number_type() noexcept { return doc->get_number_type(); }

include/simdjson/generic/ondemand/document.h

@@ -399,14 +399,7 @@ public:
    */
   simdjson_really_inline simdjson_result<bool> is_integer() noexcept;
   /**
-   * Determine the number type (integer or floating-point number) as quickly
-   * as possible. This function does not fully validate the input. It is
-   * useful when you only need to classify the numbers, without parsing them.
-   *
-   * If you are planning to retrieve the value or you need full validation,
-   * consider using the get_number() method instead: it will fully parse
-   * and validate the input, and give you access to the type:
-   * get_number().get_number_type().
+   * Determine the number type (integer or floating-point number).
    *
    * get_number_type() is number_type::unsigned_integer if we have
    * an integer greater or equal to 9223372036854775808
@@ -414,7 +407,8 @@ public:
    * integer that is less than 9223372036854775808
    * Otherwise, get_number_type() has value number_type::floating_point_number
    *
-   * This function requires processing the number string, but it is expected
+   * This function req
+   * uires processing the number string, but it is expected
    * to be faster than get_number().get_number_type() because it is does not
    * parse the number value.
    *
@@ -495,17 +489,6 @@ public:
    */
   inline simdjson_result<const char *> current_location() noexcept;
 
-  /**
-   * Returns the current depth in the document if in bounds.
-   *
-   * E.g.,
-   *  0 = finished with document
-   *  1 = document root value (could be [ or {, not yet known)
-   *  2 = , or } inside root array/object
-   *  3 = key or value inside root array/object.
-   */
-  simdjson_really_inline int32_t current_depth() const noexcept;
-
   /**
    * Get the value associated with the given JSON pointer.  We use the RFC 6901
    * https://tools.ietf.org/html/rfc6901 standard.
@@ -626,7 +609,6 @@ public:
   simdjson_really_inline simdjson_result<bool> is_scalar() noexcept;
 
   simdjson_really_inline simdjson_result<const char *> current_location() noexcept;
-  simdjson_really_inline int32_t current_depth() const noexcept;
   simdjson_really_inline bool is_negative() noexcept;
   simdjson_really_inline simdjson_result<bool> is_integer() noexcept;
   simdjson_really_inline simdjson_result<number_type> get_number_type() noexcept;
@@ -693,7 +675,6 @@ public:
   simdjson_really_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::json_type> type() noexcept;
   simdjson_really_inline simdjson_result<bool> is_scalar() noexcept;
   simdjson_really_inline simdjson_result<const char *> current_location() noexcept;
-  simdjson_really_inline int32_t current_depth() const noexcept;
   simdjson_really_inline bool is_negative() noexcept;
   simdjson_really_inline simdjson_result<bool> is_integer() noexcept;
   simdjson_really_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::number_type> get_number_type() noexcept;
@@ -754,7 +735,6 @@ public:
   simdjson_really_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::json_type> type() noexcept;
   simdjson_really_inline simdjson_result<bool> is_scalar() noexcept;
   simdjson_really_inline simdjson_result<const char *> current_location() noexcept;
-  simdjson_really_inline int32_t current_depth() const noexcept;
   simdjson_really_inline bool is_negative() noexcept;
   simdjson_really_inline simdjson_result<bool> is_integer() noexcept;
   simdjson_really_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::number_type> get_number_type() noexcept;

include/simdjson/generic/ondemand/field-inl.h

@@ -23,7 +23,7 @@ simdjson_really_inline simdjson_result<field> field::start(const value_iterator
 
 simdjson_really_inline simdjson_warn_unused simdjson_result<std::string_view> field::unescaped_key() noexcept {
   SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() but Visual Studio won't let us.
-  simdjson_result<std::string_view> answer = first.unescape(second.iter.json_iter());
+  simdjson_result<std::string_view> answer = first.unescape(second.iter.string_buf_loc());
   first.consume();
   return answer;
 }

include/simdjson/generic/ondemand/json_iterator-inl.h

@@ -47,27 +47,6 @@ inline void json_iterator::rewind() noexcept {
   _depth = 1;
 }
 
-inline bool json_iterator::balanced() const noexcept {
-  token_iterator ti(token);
-  int32_t count{0};
-  ti.set_position( root_position() );
-  while(ti.peek() <= peek_last()) {
-    switch (*ti.return_current_and_advance())
-    {
-    case '[': case '{':
-      count++;
-      break;
-    case ']': case '}':
-      count--;
-      break;
-    default:
-      break;
-    }
-  }
-  return count == 0;
-}
-
-
 // GCC 7 warns when the first line of this function is inlined away into oblivion due to the caller
 // relating depth and parent_depth, which is a desired effect. The warning does not show up if the
 // skip_child() function is not marked inline).
@@ -312,10 +291,6 @@ simdjson_really_inline token_position json_iterator::position() const noexcept {
   return token.position();
 }
 
-simdjson_really_inline simdjson_result<std::string_view> json_iterator::unescape(raw_json_string in) noexcept {
-  return parser->unescape(in, _string_buf_loc);
-}
-
 simdjson_really_inline void json_iterator::reenter_child(token_position position, depth_t child_depth) noexcept {
   SIMDJSON_ASSUME(child_depth >= 1 && child_depth < INT32_MAX);
   SIMDJSON_ASSUME(_depth == child_depth - 1);

include/simdjson/generic/ondemand/json_iterator.h

@@ -154,7 +154,7 @@ public:
    * This is not null-terminated; it is a view into the JSON.
    *
    * You may be pointing outside of the input buffer: it is not generally
-   * safe to dereference this pointer.
+   * safe to derefence this pointer.
    */
   simdjson_really_inline const uint8_t *unsafe_pointer() const noexcept;
   /**
@@ -233,14 +233,7 @@ public:
   template<int N> simdjson_warn_unused simdjson_really_inline bool copy_to_buffer(const uint8_t *json, uint32_t max_len, uint8_t (&tmpbuf)[N]) noexcept;
 
   simdjson_really_inline token_position position() const noexcept;
-  /**
-   * Write the raw_json_string to the string buffer and return a string_view.
-   * Each raw_json_string should be unescaped once, or else the string buffer might
-   * overflow.
-   */
-  simdjson_really_inline simdjson_result<std::string_view> unescape(raw_json_string in) noexcept;
   simdjson_really_inline void reenter_child(token_position position, depth_t child_depth) noexcept;
-
 #ifdef SIMDJSON_DEVELOPMENT_CHECKS
   simdjson_really_inline token_position start_position(depth_t depth) const noexcept;
   simdjson_really_inline void set_start_position(depth_t depth, token_position position) noexcept;
@@ -258,13 +251,6 @@ public:
    * as if it had just been created.
    */
   inline void rewind() noexcept;
-  /**
-   * This checks whether the {,},[,] are balanced so that the document
-   * ends with proper zero depth. This requires scanning the whole document
-   * and it may be expensive. It is expected that it will be rarely called.
-   * It does not attempt to match { with } and [ with ].
-   */
-  inline bool balanced() const noexcept;
 protected:
   simdjson_really_inline json_iterator(const uint8_t *buf, ondemand::parser *parser) noexcept;
   /// The last token before the end

include/simdjson/generic/ondemand/logger-inl.h

@@ -85,7 +85,7 @@ inline void log_headers() noexcept {
       printf("# skip says 'this is a structural or value I am skipping'\n");
       printf("# +/-skip says 'this is a start/end array or object I am skipping'\n");
       printf("#\n");
-      printf("# The indentation of the terms (array, string,...) indicates the depth,\n");
+      printf("# The identation of the terms (array, string,...) indicates the depth,\n");
       printf("# in addition to the depth being displayed.\n");
       printf("#\n");
       printf("# Every token in the document has a single depth determined by the tokens before it,\n");

include/simdjson/generic/ondemand/object.h

@@ -118,7 +118,7 @@ public:
    * instance: there is no rewind and no invalidation.
    *
    * You may call at_pointer more than once on an object, but each time the pointer is advanced
-   * to be within the value matched by the key indicated by the JSON pointer query. Thus any preceding
+   * to be within the value matched by the key indicated by the JSON pointer query. Thus any preceeding
    * key (as well as the current key) can no longer be used with following JSON pointer calls.
    *
    * Also note that at_pointer() relies on find_field() which implies that we do not unescape keys when matching.
@@ -168,7 +168,7 @@ public:
   simdjson_really_inline simdjson_result<size_t> count_fields() & noexcept;
   /**
    * Consumes the object and returns a string_view instance corresponding to the
-   * object as represented in JSON. It points inside the original byte array containing
+   * object as represented in JSON. It points inside the original byte array containg
    * the JSON document.
    */
   simdjson_really_inline simdjson_result<std::string_view> raw_json() noexcept;

include/simdjson/generic/ondemand/object_iterator-inl.h

@@ -26,8 +26,6 @@ simdjson_really_inline bool object_iterator::operator!=(const object_iterator &)
   return iter.is_open();
 }
 
-SIMDJSON_PUSH_DISABLE_WARNINGS
-SIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING
 simdjson_really_inline object_iterator &object_iterator::operator++() noexcept {
   // TODO this is a safety rail ... users should exit loops as soon as they receive an error.
   // Nonetheless, let's see if performance is OK with this if statement--the compiler may give it to us for free.
@@ -40,7 +38,6 @@ simdjson_really_inline object_iterator &object_iterator::operator++() noexcept {
   if ((error = iter.has_next_field().get(has_value) )) { return *this; };
   return *this;
 }
-SIMDJSON_POP_DISABLE_WARNINGS
 
 //
 // ### Live States

include/simdjson/generic/ondemand/parser-inl.h

@@ -117,14 +117,6 @@ simdjson_really_inline void parser::set_max_capacity(size_t max_capacity) noexce
   }
 }
 
-simdjson_really_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape(raw_json_string in, uint8_t *&dst) const noexcept {
-  uint8_t *end = implementation->parse_string(in.buf, dst);
-  if (!end) { return STRING_ERROR; }
-  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
-  dst = end;
-  return result;
-}
-
 } // namespace ondemand
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson

include/simdjson/generic/ondemand/parser.h

@@ -252,27 +252,6 @@ public:
   bool threaded{true};
   #endif
 
-  /**
-   * Unescape this JSON string, replacing \\ with \, \n with newline, etc. to a user-provided buffer.
-   * The provided pointer is advanced to the end of the string by reference, and a string_view instance
-   * is returned. You can ensure that your buffer is large enough by allocating a block of memory at least
-   * as large as the input JSON plus SIMDJSON_PADDING and then unescape all strings to this one buffer.
-   *
-   * This unescape function is a low-level function. If you want a more user-friendly approach, you should
-   * avoid raw_json_string instances (e.g., by calling unescaped_key() instead of key() or get_string()
-   * instead of get_raw_json_string()).
-   *
-   * ## IMPORTANT: string_view lifetime
-   *
-   * The string_view is only valid as long as the bytes in dst.
-   *
-   * @param raw_json_string input
-   * @param dst A pointer to a buffer at least large enough to write this string as well as
-   *            an additional SIMDJSON_PADDING bytes.
-   * @return A string_view pointing at the unescaped string in dst
-   * @error STRING_ERROR if escapes are incorrect.
-   */
-  simdjson_really_inline simdjson_result<std::string_view> unescape(raw_json_string in, uint8_t *&dst) const noexcept;
 private:
   /** @private [for benchmarking access] The implementation to use */
   std::unique_ptr<internal::dom_parser_implementation> implementation{};

include/simdjson/generic/ondemand/raw_json_string-inl.h

@@ -6,7 +6,13 @@ namespace ondemand {
 simdjson_really_inline raw_json_string::raw_json_string(const uint8_t * _buf) noexcept : buf{_buf} {}
 
 simdjson_really_inline const char * raw_json_string::raw() const noexcept { return reinterpret_cast<const char *>(buf); }
-
+simdjson_really_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape(uint8_t *&dst) const noexcept {
+  uint8_t *end = stringparsing::parse_string(buf, dst);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
+}
 
 simdjson_really_inline bool raw_json_string::is_free_from_unescaped_quote(std::string_view target) noexcept {
   size_t pos{0};
@@ -144,7 +150,7 @@ simdjson_unused simdjson_really_inline bool operator!=(std::string_view c, const
 
 
 simdjson_really_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape(json_iterator &iter) const noexcept {
-  return iter.unescape(*this);
+  return unescape(iter.string_buf_loc());
 }
 
 
@@ -177,6 +183,10 @@ simdjson_really_inline simdjson_result<const char *> simdjson_result<SIMDJSON_IM
   if (error()) { return error(); }
   return first.raw();
 }
+simdjson_really_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string>::unescape(uint8_t *&dst) const noexcept {
+  if (error()) { return error(); }
+  return first.unescape(dst);
+}
 simdjson_really_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string>::unescape(SIMDJSON_IMPLEMENTATION::ondemand::json_iterator &iter) const noexcept {
   if (error()) { return error(); }
   return first.unescape(iter);

include/simdjson/generic/ondemand/raw_json_string.h

@@ -17,19 +17,12 @@ class json_iterator;
  *
  * This class is deliberately simplistic and has little functionality. You can
  * compare a raw_json_string instance with an unescaped C string, but
- * that is nearly all you can do.
- *
- * The raw_json_string is unescaped. If you wish to write an unescaped version of it to your own
- * buffer, you may do so using the parser.unescape(string, buff) method, using an ondemand::parser
- * instance. Doing so requires you to have a sufficiently large buffer.
- *
- * The raw_json_string instances originate typically from field instance which in turn represent
- * key-value pairs from object instances. From a field instance, you get the raw_json_string
- * instance by calling key(). You can, if you want a more usable string_view instance, call
- * the unescaped_key() method on the field instance. You may also create a raw_json_string from
- * any other string value, with the value.get_raw_json_string() method. Again, you can get
- * a more usable string_view instance by calling get_string().
+ * that is pretty much all you can do.
  *
+ * They originate typically from field instance which in turn represent key-value pairs from
+ * object instances. From a field instance, you get the raw_json_string instance by calling key().
+ * You can, if you want a more usable string_view instance, call the unescaped_key() method
+ * on the field instance.
  */
 class raw_json_string {
 public:
@@ -137,6 +130,20 @@ private:
    */
   simdjson_really_inline simdjson_warn_unused bool alive() const noexcept { return buf != nullptr; }
 
+  /**
+   * Unescape this JSON string, replacing \\ with \, \n with newline, etc.
+   *
+   * ## IMPORTANT: string_view lifetime
+   *
+   * The string_view is only valid as long as the bytes in dst.
+   *
+   * @param dst A pointer to a buffer at least large enough to write this string as well as a \0.
+   *            dst will be updated to the next unused location (just after the \0 written out at
+   *            the end of this string).
+   * @return A string_view pointing at the unescaped string in dst
+   * @error STRING_ERROR if escapes are incorrect.
+   */
+  simdjson_really_inline simdjson_warn_unused simdjson_result<std::string_view> unescape(uint8_t *&dst) const noexcept;
   /**
    * Unescape this JSON string, replacing \\ with \, \n with newline, etc.
    *
@@ -151,7 +158,6 @@ private:
   const uint8_t * buf{};
   friend class object;
   friend class field;
-  friend class parser;
   friend struct simdjson_result<raw_json_string>;
 };
 
@@ -182,6 +188,7 @@ public:
   simdjson_really_inline ~simdjson_result() noexcept = default; ///< @private
 
   simdjson_really_inline simdjson_result<const char *> raw() const noexcept;
+  simdjson_really_inline simdjson_warn_unused simdjson_result<std::string_view> unescape(uint8_t *&dst) const noexcept;
   simdjson_really_inline simdjson_warn_unused simdjson_result<std::string_view> unescape(SIMDJSON_IMPLEMENTATION::ondemand::json_iterator &iter) const noexcept;
 };
 

include/simdjson/generic/ondemand/value-inl.h

@@ -181,10 +181,6 @@ simdjson_really_inline simdjson_result<const char *> value::current_location() n
   return iter.json_iter().current_location();
 }
 
-simdjson_really_inline int32_t value::current_depth() const noexcept{
-  return iter.json_iter().depth();
-}
-
 simdjson_really_inline simdjson_result<value> value::at_pointer(std::string_view json_pointer) noexcept {
   json_type t;
   SIMDJSON_TRY(type().get(t));
@@ -404,11 +400,6 @@ simdjson_really_inline simdjson_result<const char *> simdjson_result<SIMDJSON_IM
   return first.current_location();
 }
 
-simdjson_really_inline int32_t simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::current_depth() const noexcept {
-  if (error()) { return error(); }
-  return first.current_depth();
-}
-
 simdjson_really_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::at_pointer(std::string_view json_pointer) noexcept {
   if (error()) { return error(); }
   return first.at_pointer(json_pointer);

include/simdjson/generic/ondemand/value.h

@@ -369,14 +369,7 @@ public:
    */
   simdjson_really_inline simdjson_result<bool> is_integer() noexcept;
   /**
-   * Determine the number type (integer or floating-point number) as quickly
-   * as possible. This function does not fully validate the input. It is
-   * useful when you only need to classify the numbers, without parsing them.
-   *
-   * If you are planning to retrieve the value or you need full validation,
-   * consider using the get_number() method instead: it will fully parse
-   * and validate the input, and give you access to the type:
-   * get_number().get_number_type().
+   * Determine the number type (integer or floating-point number).
    *
    * get_number_type() is number_type::unsigned_integer if we have
    * an integer greater or equal to 9223372036854775808
@@ -455,17 +448,6 @@ public:
    */
   simdjson_really_inline simdjson_result<const char *> current_location() noexcept;
 
-  /**
-   * Returns the current depth in the document if in bounds.
-   *
-   * E.g.,
-   *  0 = finished with document
-   *  1 = document root value (could be [ or {, not yet known)
-   *  2 = , or } inside root array/object
-   *  3 = key or value inside root array/object.
-   */
-  simdjson_really_inline int32_t current_depth() const noexcept;
-
   /**
    * Get the value associated with the given JSON pointer.  We use the RFC 6901
    * https://tools.ietf.org/html/rfc6901 standard.
@@ -497,7 +479,7 @@ public:
    * to call at_pointer on the same array.
    *
    * You may call at_pointer more than once on an object, but each time the pointer is advanced
-   * to be within the value matched by the key indicated by the JSON pointer query. Thus any preceding
+   * to be within the value matched by the key indicated by the JSON pointer query. Thus any preceeding
    * key (as well as the current key) can no longer be used with following JSON pointer calls.
    *
    * Also note that at_pointer() relies on find_field() which implies that we do not unescape keys when matching
@@ -668,8 +650,7 @@ public:
 
   /** @copydoc simdjson_really_inline simdjson_result<const char *> current_location() noexcept */
   simdjson_really_inline simdjson_result<const char *> current_location() noexcept;
-  /** @copydoc simdjson_really_inline int32_t current_depth() const noexcept */
-  simdjson_really_inline int32_t current_depth() const noexcept;
+
   simdjson_really_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
 };
 

include/simdjson/generic/ondemand/value_iterator-inl.h

@@ -39,22 +39,9 @@ simdjson_warn_unused simdjson_really_inline simdjson_result<bool> value_iterator
   // current document. It only works in the normal mode where we have indexed a single document.
   // Note that adding a check for 'streaming' is not expensive since we only have at most
   // one root element.
-  if ( ! _json_iter->streaming() ) {
-    if (*_json_iter->peek_last() != '}') {
-      _json_iter->abandon();
-      return report_error(INCOMPLETE_ARRAY_OR_OBJECT, "missing } at end");
-    }
-    // If the last character is } *and* the first gibberish character is also '}'
-    // then on-demand could accidentally go over. So we need additional checks.
-    // https://github.com/simdjson/simdjson/issues/1834
-    // Checking that the document is balanced requires a full scan which is potentially
-    // expensive, but it only happens in edge cases where the first padding character is
-    // a closing bracket.
-    if ((*_json_iter->peek(_json_iter->end_position()) == '}') && (!_json_iter->balanced())) {
-      _json_iter->abandon();
-      // The exact error would require more work. It will typically be an unclosed object.
-      return report_error(INCOMPLETE_ARRAY_OR_OBJECT, "the document is unbalanced");
-    }
+  if (! _json_iter->streaming() && (*_json_iter->peek_last() != '}')) {
+    _json_iter->abandon();
+    return report_error(INCOMPLETE_ARRAY_OR_OBJECT, "missing } at end");
   }
   return started_object();
 }
@@ -180,8 +167,6 @@ simdjson_warn_unused simdjson_really_inline simdjson_result<bool> value_iterator
   return false;
 }
 
-SIMDJSON_PUSH_DISABLE_WARNINGS
-SIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING
 simdjson_warn_unused simdjson_really_inline simdjson_result<bool> value_iterator::find_field_unordered_raw(const std::string_view key) noexcept {
   /**
    * When find_field_unordered_raw is called, we can either be pointing at the
@@ -369,7 +354,6 @@ simdjson_warn_unused simdjson_really_inline simdjson_result<bool> value_iterator
   // never reach this point.
   return false;
 }
-SIMDJSON_POP_DISABLE_WARNINGS
 
 simdjson_warn_unused simdjson_really_inline simdjson_result<raw_json_string> value_iterator::field_key() noexcept {
   assert_at_next();
@@ -424,22 +408,9 @@ simdjson_warn_unused simdjson_really_inline simdjson_result<bool> value_iterator
   // current document. It only works in the normal mode where we have indexed a single document.
   // Note that adding a check for 'streaming' is not expensive since we only have at most
   // one root element.
-  if ( ! _json_iter->streaming() ) {
-    if (*_json_iter->peek_last() != ']') {
-      _json_iter->abandon();
-      return report_error(INCOMPLETE_ARRAY_OR_OBJECT, "missing ] at end");
-    }
-    // If the last character is ] *and* the first gibberish character is also ']'
-    // then on-demand could accidentally go over. So we need additional checks.
-    // https://github.com/simdjson/simdjson/issues/1834
-    // Checking that the document is balanced requires a full scan which is potentially
-    // expensive, but it only happens in edge cases where the first padding character is
-    // a closing bracket.
-    if ((*_json_iter->peek(_json_iter->end_position()) == ']') && (!_json_iter->balanced())) {
-      _json_iter->abandon();
-      // The exact error would require more work. It will typically be an unclosed array.
-      return report_error(INCOMPLETE_ARRAY_OR_OBJECT, "the document is unbalanced");
-    }
+  if ( ! _json_iter->streaming() && (*_json_iter->peek_last() != ']')) {
+    _json_iter->abandon();
+    return report_error(INCOMPLETE_ARRAY_OR_OBJECT, "missing ] at end");
   }
   return started_array();
 }
@@ -473,7 +444,7 @@ simdjson_really_inline bool value_iterator::parse_null(const uint8_t *json) cons
 }
 
 simdjson_warn_unused simdjson_really_inline simdjson_result<std::string_view> value_iterator::get_string() noexcept {
-  return get_raw_json_string().unescape(json_iter());
+  return get_raw_json_string().unescape(_json_iter->string_buf_loc());
 }
 simdjson_warn_unused simdjson_really_inline simdjson_result<raw_json_string> value_iterator::get_raw_json_string() noexcept {
   auto json = peek_scalar("string");

include/simdjson/generic/ondemand/value_iterator.h

@@ -76,7 +76,7 @@ public:
   /**
    * Get the depth of this value.
    */
-  simdjson_really_inline int32_t depth() const noexcept;
+  simdjson_really_inline depth_t depth() const noexcept;
 
   /**
    * Get the JSON type of this value.

include/simdjson/generic/stringparsing.h

@@ -0,0 +1,138 @@
+// This file contains the common code every implementation uses
+// It is intended to be included multiple times and compiled multiple times
+
+namespace simdjson {
+namespace SIMDJSON_IMPLEMENTATION {
+namespace {
+/// @private
+namespace stringparsing {
+
+// begin copypasta
+// These chars yield themselves: " \ /
+// b -> backspace, f -> formfeed, n -> newline, r -> cr, t -> horizontal tab
+// u not handled in this table as it's complex
+static const uint8_t escape_map[256] = {
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0, // 0x0.
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0x22, 0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0x2f,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0, // 0x4.
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0x5c, 0, 0,    0, // 0x5.
+    0, 0, 0x08, 0, 0,    0, 0x0c, 0, 0, 0, 0, 0, 0,    0, 0x0a, 0, // 0x6.
+    0, 0, 0x0d, 0, 0x09, 0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0, // 0x7.
+
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+};
+
+// handle a unicode codepoint
+// write appropriate values into dest
+// src will advance 6 bytes or 12 bytes
+// dest will advance a variable amount (return via pointer)
+// return true if the unicode codepoint was valid
+// We work in little-endian then swap at write time
+simdjson_warn_unused
+simdjson_really_inline bool handle_unicode_codepoint(const uint8_t **src_ptr,
+                                            uint8_t **dst_ptr) {
+  // jsoncharutils::hex_to_u32_nocheck fills high 16 bits of the return value with 1s if the
+  // conversion isn't valid; we defer the check for this to inside the
+  // multilingual plane check
+  uint32_t code_point = jsoncharutils::hex_to_u32_nocheck(*src_ptr + 2);
+  *src_ptr += 6;
+  // check for low surrogate for characters outside the Basic
+  // Multilingual Plane.
+  if (code_point >= 0xd800 && code_point < 0xdc00) {
+    if (((*src_ptr)[0] != '\\') || (*src_ptr)[1] != 'u') {
+      return false;
+    }
+    uint32_t code_point_2 = jsoncharutils::hex_to_u32_nocheck(*src_ptr + 2);
+
+    // if the first code point is invalid we will get here, as we will go past
+    // the check for being outside the Basic Multilingual plane. If we don't
+    // find a \u immediately afterwards we fail out anyhow, but if we do,
+    // this check catches both the case of the first code point being invalid
+    // or the second code point being invalid.
+    if ((code_point | code_point_2) >> 16) {
+      return false;
+    }
+
+    code_point =
+        (((code_point - 0xd800) << 10) | (code_point_2 - 0xdc00)) + 0x10000;
+    *src_ptr += 6;
+  }
+  size_t offset = jsoncharutils::codepoint_to_utf8(code_point, *dst_ptr);
+  *dst_ptr += offset;
+  return offset > 0;
+}
+
+/**
+ * Unescape a string from src to dst, stopping at a final unescaped quote. E.g., if src points at 'joe"', then
+ * dst needs to have four free bytes.
+ */
+simdjson_warn_unused simdjson_really_inline uint8_t *parse_string(const uint8_t *src, uint8_t *dst) {
+  while (1) {
+    // Copy the next n bytes, and find the backslash and quote in them.
+    auto bs_quote = backslash_and_quote::copy_and_find(src, dst);
+    // If the next thing is the end quote, copy and return
+    if (bs_quote.has_quote_first()) {
+      // we encountered quotes first. Move dst to point to quotes and exit
+      return dst + bs_quote.quote_index();
+    }
+    if (bs_quote.has_backslash()) {
+      /* find out where the backspace is */
+      auto bs_dist = bs_quote.backslash_index();
+      uint8_t escape_char = src[bs_dist + 1];
+      /* we encountered backslash first. Handle backslash */
+      if (escape_char == 'u') {
+        /* move src/dst up to the start; they will be further adjusted
+           within the unicode codepoint handling code. */
+        src += bs_dist;
+        dst += bs_dist;
+        if (!handle_unicode_codepoint(&src, &dst)) {
+          return nullptr;
+        }
+      } else {
+        /* simple 1:1 conversion. Will eat bs_dist+2 characters in input and
+         * write bs_dist+1 characters to output
+         * note this may reach beyond the part of the buffer we've actually
+         * seen. I think this is ok */
+        uint8_t escape_result = escape_map[escape_char];
+        if (escape_result == 0u) {
+          return nullptr; /* bogus escape value is an error */
+        }
+        dst[bs_dist] = escape_result;
+        src += bs_dist + 2;
+        dst += bs_dist + 1;
+      }
+    } else {
+      /* they are the same. Since they can't co-occur, it means we
+       * encountered neither. */
+      src += backslash_and_quote::BYTES_PROCESSED;
+      dst += backslash_and_quote::BYTES_PROCESSED;
+    }
+  }
+  /* can't be reached */
+  return nullptr;
+}
+
+simdjson_unused simdjson_warn_unused simdjson_really_inline error_code parse_string_to_buffer(const uint8_t *src, uint8_t *&current_string_buf_loc, std::string_view &s) {
+  if (*(src++) != '"') { return STRING_ERROR; }
+  auto end = stringparsing::parse_string(src, current_string_buf_loc);
+  if (!end) { return STRING_ERROR; }
+  s = std::string_view(reinterpret_cast<const char *>(current_string_buf_loc), end-current_string_buf_loc);
+  current_string_buf_loc = end;
+  return SUCCESS;
+}
+
+} // namespace stringparsing
+} // unnamed namespace
+} // namespace SIMDJSON_IMPLEMENTATION
+} // namespace simdjson

include/simdjson/icelake/simd.h

@@ -3,32 +3,6 @@
 
 #include "simdjson/internal/simdprune_tables.h"
 
-
-
-#if defined(__GNUC__) && !defined(__clang__)
-#if __GNUC__ == 8
-#define SIMDJSON_GCC8 1
-#endif //  __GNUC__ == 8
-#endif // defined(__GNUC__) && !defined(__clang__)
-
-#if SIMDJSON_GCC8
-/**
- * GCC 8 fails to provide _mm512_set_epi8. We roll our own.
- */
-inline __m512i _mm512_set_epi8(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4, uint8_t a5, uint8_t a6, uint8_t a7, uint8_t a8, uint8_t a9, uint8_t a10, uint8_t a11, uint8_t a12, uint8_t a13, uint8_t a14, uint8_t a15, uint8_t a16, uint8_t a17, uint8_t a18, uint8_t a19, uint8_t a20, uint8_t a21, uint8_t a22, uint8_t a23, uint8_t a24, uint8_t a25, uint8_t a26, uint8_t a27, uint8_t a28, uint8_t a29, uint8_t a30, uint8_t a31, uint8_t a32, uint8_t a33, uint8_t a34, uint8_t a35, uint8_t a36, uint8_t a37, uint8_t a38, uint8_t a39, uint8_t a40, uint8_t a41, uint8_t a42, uint8_t a43, uint8_t a44, uint8_t a45, uint8_t a46, uint8_t a47, uint8_t a48, uint8_t a49, uint8_t a50, uint8_t a51, uint8_t a52, uint8_t a53, uint8_t a54, uint8_t a55, uint8_t a56, uint8_t a57, uint8_t a58, uint8_t a59, uint8_t a60, uint8_t a61, uint8_t a62, uint8_t a63) {
-  return _mm512_set_epi64(uint64_t(a7) + (uint64_t(a6) << 8) + (uint64_t(a5) << 16) + (uint64_t(a4) << 24) + (uint64_t(a3) << 32) + (uint64_t(a2) << 40) + (uint64_t(a1) << 48) + (uint64_t(a0) << 56),
-                          uint64_t(a15) + (uint64_t(a14) << 8) + (uint64_t(a13) << 16) + (uint64_t(a12) << 24) + (uint64_t(a11) << 32) + (uint64_t(a10) << 40) + (uint64_t(a9) << 48) + (uint64_t(a8) << 56),
-                          uint64_t(a23) + (uint64_t(a22) << 8) + (uint64_t(a21) << 16) + (uint64_t(a20) << 24) + (uint64_t(a19) << 32) + (uint64_t(a18) << 40) + (uint64_t(a17) << 48) + (uint64_t(a16) << 56),
-                          uint64_t(a31) + (uint64_t(a30) << 8) + (uint64_t(a29) << 16) + (uint64_t(a28) << 24) + (uint64_t(a27) << 32) + (uint64_t(a26) << 40) + (uint64_t(a25) << 48) + (uint64_t(a24) << 56),
-                          uint64_t(a39) + (uint64_t(a38) << 8) + (uint64_t(a37) << 16) + (uint64_t(a36) << 24) + (uint64_t(a35) << 32) + (uint64_t(a34) << 40) + (uint64_t(a33) << 48) + (uint64_t(a32) << 56),
-                          uint64_t(a47) + (uint64_t(a46) << 8) + (uint64_t(a45) << 16) + (uint64_t(a44) << 24) + (uint64_t(a43) << 32) + (uint64_t(a42) << 40) + (uint64_t(a41) << 48) + (uint64_t(a40) << 56),
-                          uint64_t(a55) + (uint64_t(a54) << 8) + (uint64_t(a53) << 16) + (uint64_t(a52) << 24) + (uint64_t(a51) << 32) + (uint64_t(a50) << 40) + (uint64_t(a49) << 48) + (uint64_t(a48) << 56),
-                          uint64_t(a63) + (uint64_t(a62) << 8) + (uint64_t(a61) << 16) + (uint64_t(a60) << 24) + (uint64_t(a59) << 32) + (uint64_t(a58) << 40) + (uint64_t(a57) << 48) + (uint64_t(a56) << 56));
-}
-#endif // SIMDJSON_GCC8
-
-
-
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace {
@@ -71,21 +45,13 @@ namespace simd {
     simdjson_really_inline base8() : base<simd8<T>>() {}
     simdjson_really_inline base8(const __m512i _value) : base<simd8<T>>(_value) {}
 
-    friend simdjson_really_inline uint64_t operator==(const simd8<T> lhs, const simd8<T> rhs) {
-      return _mm512_cmpeq_epi8_mask(lhs, rhs);
-    }
+    simdjson_really_inline uint64_t operator==(const simd8<T> other) const { return _mm512_cmpeq_epi8_mask(*this, other); }
 
     static const int SIZE = sizeof(base<T>::value);
 
     template<int N=1>
     simdjson_really_inline simd8<T> prev(const simd8<T> prev_chunk) const {
-#if SIMDJSON_GCC8
-     // workaround for compilers unable to figure out that 16 - N is a constant (GCC 8)
-      constexpr int shift = 16 - N;
-      return _mm512_alignr_epi8(*this, _mm512_permutex2var_epi64(prev_chunk, _mm512_set_epi64(13, 12, 11, 10, 9, 8, 7, 6), *this), shift);
-#else
       return _mm512_alignr_epi8(*this, _mm512_permutex2var_epi64(prev_chunk, _mm512_set_epi64(13, 12, 11, 10, 9, 8, 7, 6), *this), 16 - N);
-#endif
     }
   };
 
@@ -362,6 +328,8 @@ namespace simd {
       const simd8<T> mask = simd8<T>::splat(m);
       return this->chunks[0] <= mask;
     }
+    simdjson_really_inline operator __m512i() const { return __m512i(this->chunks[0]); }
+
   }; // struct simd8x64<T>
 
 } // namespace simd

include/simdjson/implementation.h

@@ -18,6 +18,8 @@ namespace simdjson {
  * @return true if the string is valid UTF-8.
  */
 simdjson_warn_unused bool validate_utf8(const char * buf, size_t len) noexcept;
+
+
 /**
  * Validate the UTF-8 string.
  *

include/simdjson/implementations.h

@@ -21,19 +21,6 @@
 #endif
 #endif
 
-#ifdef _MSC_VER
-#if _MSC_VER >= 1920
-// Visual Studio 2019 and up support VBMI2 under x64 even if the header
-// avx512vbmi2intrin.h is not found.
-#define SIMDJSON_COMPILER_SUPPORTS_VBMI2 1
-#endif
-#endif
-
-// By default, we allow AVX512.
-#ifndef SIMDJSON_AVX512_ALLOWED
-#define SIMDJSON_AVX512_ALLOWED 1
-#endif
-
 // Default Icelake to on if this is x86-64. Even if we're not compiled for it, it could be selected
 // at runtime.
 #ifndef SIMDJSON_IMPLEMENTATION_ICELAKE

include/simdjson/internal/dom_parser_implementation.h

@@ -102,22 +102,6 @@ public:
    */
   simdjson_warn_unused virtual error_code stage2_next(dom::document &doc) noexcept = 0;
 
-  /**
-   * Unescape a valid UTF-8 string from src to dst, stopping at a final unescaped quote. There
-   * must be an unescaped quote terminating the string. It returns the final output
-   * position as pointer. In case of error (e.g., the string has bad escaped codes),
-   * then null_nullptrptr is returned. It is assumed that the output buffer is large
-   * enough. E.g., if src points at 'joe"', then dst needs to have four free bytes +
-   * SIMDJSON_PADDING bytes.
-   *
-   * Overridden by each implementation.
-   *
-   * @param str pointer to the beginning of a valid UTF-8 JSON string, must end with an unescaped quote.
-   * @param dst pointer to a destination buffer, it must point a region in memory of sufficient size.
-   * @return end of the of the written region (exclusive) or nullptr in case of error.
-   */
-  simdjson_warn_unused virtual uint8_t *parse_string(const uint8_t *src, uint8_t *dst) const noexcept = 0;
-
   /**
    * Change the capacity of this parser.
    *
@@ -179,7 +163,6 @@ public:
    */
   simdjson_warn_unused inline error_code allocate(size_t capacity, size_t max_depth) noexcept;
 
-
 protected:
   /**
    * The maximum document length this parser supports.

include/simdjson/simdjson_version.h

@@ -4,22 +4,22 @@
 #define SIMDJSON_SIMDJSON_VERSION_H
 
 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION 2.1.0
+#define SIMDJSON_VERSION 1.0.2
 
 namespace simdjson {
 enum {
   /**
    * The major version (MAJOR.minor.revision) of simdjson being used.
    */
-  SIMDJSON_VERSION_MAJOR = 2,
+  SIMDJSON_VERSION_MAJOR = 1,
   /**
    * The minor version (major.MINOR.revision) of simdjson being used.
    */
-  SIMDJSON_VERSION_MINOR = 1,
+  SIMDJSON_VERSION_MINOR = 0,
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 0
+  SIMDJSON_VERSION_REVISION = 2
 };
 } // namespace simdjson
 

singleheader/amalgamate.py

@@ -9,7 +9,6 @@ import subprocess
 import os
 import re
 import shutil
-import datetime
 
 if sys.version_info < (3, 0):
     sys.stdout.write("Sorry, requires Python 3.x or better\n")
@@ -81,10 +80,8 @@ def dofile(fid, prepath, filename):
     # print(f"// dofile: invoked with prepath={prepath}, filename={filename}",file=fid)
     file = os.path.join(prepath, filename)
     RELFILE = os.path.relpath(file, PROJECTPATH)
-    # Windows use \ as a directory separator, but we do not want that:
-    OSRELFILE = RELFILE.replace('\\','/')
     # Last lines are always ignored. Files should end by an empty lines.
-    print(f"/* begin file {OSRELFILE} */", file=fid)
+    print(f"/* begin file {RELFILE} */", file=fid)
     includepattern = re.compile('^#include "(.*)"')
     redefines_simdjson_implementation = re.compile('^#define\s+SIMDJSON_IMPLEMENTATION\s+(.*)')
     undefines_simdjson_implementation = re.compile('^#undef\s+SIMDJSON_IMPLEMENTATION\s*$')
@@ -116,7 +113,7 @@ def dofile(fid, prepath, filename):
                 else:
                     # copy the line, with SIMDJSON_IMPLEMENTATION replace to what it is currently defined to
                     print(uses_simdjson_implementation.sub(current_implementation+"\\1",line), file=fid)
-    print(f"/* end file {OSRELFILE} */", file=fid)
+    print(f"/* end file {RELFILE} */", file=fid)
 
 
 # Get the generation date from git, so the output is reproducible.
@@ -124,12 +121,8 @@ def dofile(fid, prepath, filename):
 # does not change with locale and timezone at time of generation.
 # Forcing it to be UTC is difficult, because it needs to be portable
 # between gnu date and busybox date.
-try:
-    timestamp = subprocess.run(['git', 'show', '-s', '--format=%ci', 'HEAD'],
+timestamp = subprocess.run(['git', 'show', '-s', '--format=%ci', 'HEAD'],
                            stdout=subprocess.PIPE).stdout.decode('utf-8').strip()
-except:
-    print("git not found, timestamp based on current time")
-    timestamp = str(datetime.datetime.now())
 print(f"timestamp is {timestamp}")
 
 os.makedirs(AMALGAMATE_OUTPUT_PATH, exist_ok=True)

src/arm64/dom_parser_implementation.cpp

@@ -109,7 +109,6 @@ simdjson_really_inline simd8<bool> must_be_2_3_continuation(const simd8<uint8_t>
 // Stage 2
 //
 
-#include "generic/stage2/stringparsing.h"
 #include "generic/stage2/tape_builder.h"
 
 //
@@ -152,10 +151,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::docu
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
 
-simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst) const noexcept {
-  return arm64::stringparsing::parse_string(src, dst);
-}
-
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }

src/fallback/dom_parser_implementation.cpp

@@ -346,7 +346,6 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
 //
 // Stage 2
 //
-#include "generic/stage2/stringparsing.h"
 #include "generic/stage2/tape_builder.h"
 
 namespace simdjson {
@@ -360,10 +359,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::docu
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
 
-simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst) const noexcept {
-  return fallback::stringparsing::parse_string(src, dst);
-}
-
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }

src/generic/stage2/stringparsing.h

@@ -1,133 +0,0 @@
-// This file contains the common code every implementation uses
-// It is intended to be included multiple times and compiled multiple times
-
-namespace simdjson {
-namespace SIMDJSON_IMPLEMENTATION {
-namespace {
-/// @private
-namespace stringparsing {
-
-// begin copypasta
-// These chars yield themselves: " \ /
-// b -> backspace, f -> formfeed, n -> newline, r -> cr, t -> horizontal tab
-// u not handled in this table as it's complex
-static const uint8_t escape_map[256] = {
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0, // 0x0.
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
-    0, 0, 0x22, 0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0x2f,
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
-
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0, // 0x4.
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0x5c, 0, 0,    0, // 0x5.
-    0, 0, 0x08, 0, 0,    0, 0x0c, 0, 0, 0, 0, 0, 0,    0, 0x0a, 0, // 0x6.
-    0, 0, 0x0d, 0, 0x09, 0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0, // 0x7.
-
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
-
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
-    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
-};
-
-// handle a unicode codepoint
-// write appropriate values into dest
-// src will advance 6 bytes or 12 bytes
-// dest will advance a variable amount (return via pointer)
-// return true if the unicode codepoint was valid
-// We work in little-endian then swap at write time
-simdjson_warn_unused
-simdjson_really_inline bool handle_unicode_codepoint(const uint8_t **src_ptr,
-                                            uint8_t **dst_ptr) {
-  // jsoncharutils::hex_to_u32_nocheck fills high 16 bits of the return value with 1s if the
-  // conversion isn't valid; we defer the check for this to inside the
-  // multilingual plane check
-  uint32_t code_point = jsoncharutils::hex_to_u32_nocheck(*src_ptr + 2);
-  *src_ptr += 6;
-  // check for low surrogate for characters outside the Basic
-  // Multilingual Plane.
-  if (code_point >= 0xd800 && code_point < 0xdc00) {
-    if (((*src_ptr)[0] != '\\') || (*src_ptr)[1] != 'u') {
-      return false;
-    }
-    uint32_t code_point_2 = jsoncharutils::hex_to_u32_nocheck(*src_ptr + 2);
-
-    // if the first code point is invalid we will get here, as we will go past
-    // the check for being outside the Basic Multilingual plane. If we don't
-    // find a \u immediately afterwards we fail out anyhow, but if we do,
-    // this check catches both the case of the first code point being invalid
-    // or the second code point being invalid.
-    if ((code_point | code_point_2) >> 16) {
-      return false;
-    }
-
-    code_point =
-        (((code_point - 0xd800) << 10) | (code_point_2 - 0xdc00)) + 0x10000;
-    *src_ptr += 6;
-  }
-  size_t offset = jsoncharutils::codepoint_to_utf8(code_point, *dst_ptr);
-  *dst_ptr += offset;
-  return offset > 0;
-}
-
-/**
- * Unescape a valid UTF-8 string from src to dst, stopping at a final unescaped quote. There
- * must be an unescaped quote terminating the string. It returns the final output
- * position as pointer. In case of error (e.g., the string has bad escaped codes),
- * then null_nullptrptr is returned. It is assumed that the output buffer is large
- * enough. E.g., if src points at 'joe"', then dst needs to have four free bytes +
- * SIMDJSON_PADDING bytes.
- */
-simdjson_warn_unused simdjson_really_inline uint8_t *parse_string(const uint8_t *src, uint8_t *dst) {
-  while (1) {
-    // Copy the next n bytes, and find the backslash and quote in them.
-    auto bs_quote = backslash_and_quote::copy_and_find(src, dst);
-    // If the next thing is the end quote, copy and return
-    if (bs_quote.has_quote_first()) {
-      // we encountered quotes first. Move dst to point to quotes and exit
-      return dst + bs_quote.quote_index();
-    }
-    if (bs_quote.has_backslash()) {
-      /* find out where the backspace is */
-      auto bs_dist = bs_quote.backslash_index();
-      uint8_t escape_char = src[bs_dist + 1];
-      /* we encountered backslash first. Handle backslash */
-      if (escape_char == 'u') {
-        /* move src/dst up to the start; they will be further adjusted
-           within the unicode codepoint handling code. */
-        src += bs_dist;
-        dst += bs_dist;
-        if (!handle_unicode_codepoint(&src, &dst)) {
-          return nullptr;
-        }
-      } else {
-        /* simple 1:1 conversion. Will eat bs_dist+2 characters in input and
-         * write bs_dist+1 characters to output
-         * note this may reach beyond the part of the buffer we've actually
-         * seen. I think this is ok */
-        uint8_t escape_result = escape_map[escape_char];
-        if (escape_result == 0u) {
-          return nullptr; /* bogus escape value is an error */
-        }
-        dst[bs_dist] = escape_result;
-        src += bs_dist + 2;
-        dst += bs_dist + 1;
-      }
-    } else {
-      /* they are the same. Since they can't co-occur, it means we
-       * encountered neither. */
-      src += backslash_and_quote::BYTES_PROCESSED;
-      dst += backslash_and_quote::BYTES_PROCESSED;
-    }
-  }
-  /* can't be reached */
-  return nullptr;
-}
-
-} // namespace stringparsing
-} // unnamed namespace
-} // namespace SIMDJSON_IMPLEMENTATION
-} // namespace simdjson

src/haswell/dom_parser_implementation.cpp

@@ -112,7 +112,6 @@ simdjson_really_inline simd8<bool> must_be_2_3_continuation(const simd8<uint8_t>
 //
 // Stage 2
 //
-#include "generic/stage2/stringparsing.h"
 #include "generic/stage2/tape_builder.h"
 
 //
@@ -153,10 +152,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::docu
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
 
-simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst) const noexcept {
-  return haswell::stringparsing::parse_string(src, dst);
-}
-
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }

src/icelake/dom_parser_implementation.cpp

@@ -102,7 +102,7 @@ simdjson_really_inline simd8<bool> must_be_2_3_continuation(const simd8<uint8_t>
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
 
-#include "generic/stage1/utf8_lookup4_algorithm.h"
+#include "icelake/utf8_lookup4_algorithm.h"
 // defining SIMDJSON_CUSTOM_BIT_INDEXER allows us to provide our own bit_indexer::write
 #define SIMDJSON_CUSTOM_BIT_INDEXER
 #include "generic/stage1/json_structural_indexer.h"
@@ -114,9 +114,6 @@ simdjson_really_inline simd8<bool> must_be_2_3_continuation(const simd8<uint8_t>
  * naked intrinsics.
  * TODO: make this code more elegant.
  */
-// Under GCC 12, the intrinsic _mm512_extracti32x4_epi32 may generate 'maybe uninitialized'.
-// as a workaround, we disable warnings within the following function.
-SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
 namespace simdjson { namespace SIMDJSON_IMPLEMENTATION { namespace { namespace stage1 {
 simdjson_really_inline void bit_indexer::write(uint32_t idx, uint64_t bits) {
     // In some instances, the next branch is expensive because it is mispredicted.
@@ -151,14 +148,12 @@ simdjson_really_inline void bit_indexer::write(uint32_t idx, uint64_t bits) {
     this->tail += count;
 }
 }}}}
-SIMDJSON_POP_DISABLE_WARNINGS
 
 #include "generic/stage1/utf8_validator.h"
 
 //
 // Stage 2
 //
-#include "generic/stage2/stringparsing.h"
 #include "generic/stage2/tape_builder.h"
 
 //
@@ -199,10 +194,6 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::docu
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
 
-simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst) const noexcept {
-  return icelake::stringparsing::parse_string(src, dst);
-}
-
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }