simdjson 0.1.0

data/vendor/simdjson/include/simdjson/stringparsing_arm64.h

@@ -0,0 +1,56 @@
+#ifndef SIMDJSON_STRINGPARSING_ARM64_H
+#define SIMDJSON_STRINGPARSING_ARM64_H
+
+#include "simdjson/stringparsing.h"
+#include "simdjson/stringparsing_macros.h"
+
+#ifdef IS_ARM64
+namespace simdjson {
+template <>
+really_inline parse_string_helper
+find_bs_bits_and_quote_bits<Architecture::ARM64>(const uint8_t *src,
+                                                 uint8_t *dst) {
+  // this can read up to 31 bytes beyond the buffer size, but we require
+  // SIMDJSON_PADDING of padding
+  static_assert(2 * sizeof(uint8x16_t) - 1 <= SIMDJSON_PADDING);
+  uint8x16_t v0 = vld1q_u8(src);
+  uint8x16_t v1 = vld1q_u8(src + 16);
+  vst1q_u8(dst, v0);
+  vst1q_u8(dst + 16, v1);
+
+  uint8x16_t bs_mask = vmovq_n_u8('\\');
+  uint8x16_t qt_mask = vmovq_n_u8('"');
+  const uint8x16_t bit_mask = {0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
+                               0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80};
+  uint8x16_t cmp_bs_0 = vceqq_u8(v0, bs_mask);
+  uint8x16_t cmp_bs_1 = vceqq_u8(v1, bs_mask);
+  uint8x16_t cmp_qt_0 = vceqq_u8(v0, qt_mask);
+  uint8x16_t cmp_qt_1 = vceqq_u8(v1, qt_mask);
+
+  cmp_bs_0 = vandq_u8(cmp_bs_0, bit_mask);
+  cmp_bs_1 = vandq_u8(cmp_bs_1, bit_mask);
+  cmp_qt_0 = vandq_u8(cmp_qt_0, bit_mask);
+  cmp_qt_1 = vandq_u8(cmp_qt_1, bit_mask);
+
+  uint8x16_t sum0 = vpaddq_u8(cmp_bs_0, cmp_bs_1);
+  uint8x16_t sum1 = vpaddq_u8(cmp_qt_0, cmp_qt_1);
+  sum0 = vpaddq_u8(sum0, sum1);
+  sum0 = vpaddq_u8(sum0, sum0);
+  return {
+      vgetq_lane_u32(vreinterpretq_u32_u8(sum0), 0), // bs_bits
+      vgetq_lane_u32(vreinterpretq_u32_u8(sum0), 1)  // quote_bits
+  };
+}
+
+template <>
+WARN_UNUSED ALLOW_SAME_PAGE_BUFFER_OVERRUN_QUALIFIER LENIENT_MEM_SANITIZER
+    really_inline bool
+    parse_string<Architecture::ARM64>(UNUSED const uint8_t *buf,
+                                      UNUSED size_t len, ParsedJson &pj,
+                                      UNUSED const uint32_t depth,
+                                      UNUSED uint32_t offset) {
+  PARSE_STRING(Architecture::ARM64, buf, len, pj, depth, offset);
+}
+} // namespace simdjson
+#endif
+#endif

data/vendor/simdjson/include/simdjson/stringparsing_haswell.h

@@ -0,0 +1,43 @@
+#ifndef SIMDJSON_STRINGPARSING_HASWELL_H
+#define SIMDJSON_STRINGPARSING_HASWELL_H
+
+#include "simdjson/stringparsing.h"
+#include "simdjson/stringparsing_macros.h"
+
+#ifdef IS_X86_64
+TARGET_HASWELL
+namespace simdjson {
+template <>
+really_inline parse_string_helper
+find_bs_bits_and_quote_bits<Architecture::HASWELL>(const uint8_t *src,
+                                                   uint8_t *dst) {
+  // this can read up to 31 bytes beyond the buffer size, but we require
+  // SIMDJSON_PADDING of padding
+  static_assert(sizeof(__m256i) - 1 <= SIMDJSON_PADDING);
+  __m256i v = _mm256_loadu_si256(reinterpret_cast<const __m256i *>(src));
+  // store to dest unconditionally - we can overwrite the bits we don't like
+  // later
+  _mm256_storeu_si256(reinterpret_cast<__m256i *>(dst), v);
+  auto quote_mask = _mm256_cmpeq_epi8(v, _mm256_set1_epi8('"'));
+  return {
+      static_cast<uint32_t>(_mm256_movemask_epi8(
+          _mm256_cmpeq_epi8(v, _mm256_set1_epi8('\\')))),     // bs_bits
+      static_cast<uint32_t>(_mm256_movemask_epi8(quote_mask)) // quote_bits
+  };
+}
+
+template <>
+WARN_UNUSED ALLOW_SAME_PAGE_BUFFER_OVERRUN_QUALIFIER LENIENT_MEM_SANITIZER
+    really_inline bool
+    parse_string<Architecture::HASWELL>(UNUSED const uint8_t *buf,
+                                        UNUSED size_t len, ParsedJson &pj,
+                                        UNUSED const uint32_t depth,
+                                        UNUSED uint32_t offset) {
+  PARSE_STRING(Architecture::HASWELL, buf, len, pj, depth, offset);
+}
+
+} // namespace simdjson
+UNTARGET_REGION
+#endif
+
+#endif

data/vendor/simdjson/include/simdjson/stringparsing_macros.h

@@ -0,0 +1,88 @@
+#ifndef SIMDJSON_STRINGPARSING_MACROS_H
+#define SIMDJSON_STRINGPARSING_MACROS_H
+
+// We need to compile that code for multiple architectures. However, target
+// attributes can be used only once by function definition. Huge macro seemed
+// better than huge code duplication.ç
+// bool PARSE_STRING(Architecture T, const uint8_t *buf, size_t len, ParsedJson
+//                  &pj,const uint32_t depth, uint32_t offset)
+#define PARSE_STRING(T, buf, len, pj, depth, offset)                           \
+  {                                                                            \
+    pj.write_tape(pj.current_string_buf_loc - pj.string_buf, '"');             \
+    const uint8_t *src =                                                       \
+        &buf[offset + 1]; /* we know that buf at offset is a " */              \
+    uint8_t *dst = pj.current_string_buf_loc + sizeof(uint32_t);               \
+    const uint8_t *const start_of_string = dst;                                \
+    while (1) {                                                                \
+      parse_string_helper helper = find_bs_bits_and_quote_bits<T>(src, dst);   \
+      if (((helper.bs_bits - 1) & helper.quote_bits) != 0) {                   \
+        /* we encountered quotes first. Move dst to point to quotes and exit   \
+         */                                                                    \
+                                                                               \
+        /* find out where the quote is... */                                   \
+        uint32_t quote_dist = trailing_zeroes(helper.quote_bits);              \
+                                                                               \
+        /* NULL termination is still handy if you expect all your strings to   \
+         * be NULL terminated? */                                              \
+        /* It comes at a small cost */                                         \
+        dst[quote_dist] = 0;                                                   \
+                                                                               \
+        uint32_t str_length = (dst - start_of_string) + quote_dist;            \
+        memcpy(pj.current_string_buf_loc, &str_length, sizeof(uint32_t));      \
+        /*****************************                                         \
+         * Above, check for overflow in case someone has a crazy string        \
+         * (>=4GB?)                 _                                          \
+         * But only add the overflow check when the document itself exceeds    \
+         * 4GB                                                                 \
+         * Currently unneeded because we refuse to parse docs larger or equal  \
+         * to 4GB.                                                             \
+         ****************************/                                         \
+                                                                               \
+        /* we advance the point, accounting for the fact that we have a NULL   \
+         * termination         */                                              \
+        pj.current_string_buf_loc = dst + quote_dist + 1;                      \
+        return true;                                                           \
+      }                                                                        \
+      if (((helper.quote_bits - 1) & helper.bs_bits) != 0) {                   \
+        /* find out where the backspace is */                                  \
+        uint32_t bs_dist = trailing_zeroes(helper.bs_bits);                    \
+        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 false;                                                      \
+          }                                                                    \
+        } 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 false; /* 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. */                                             \
+        if constexpr (T == Architecture::WESTMERE) {                           \
+          src += 16;                                                           \
+          dst += 16;                                                           \
+        } else {                                                               \
+          src += 32;                                                           \
+          dst += 32;                                                           \
+        }                                                                      \
+      }                                                                        \
+    }                                                                          \
+    /* can't be reached */                                                     \
+    return true;                                                               \
+  }
+
+#endif

data/vendor/simdjson/include/simdjson/stringparsing_westmere.h

@@ -0,0 +1,41 @@
+#ifndef SIMDJSON_STRINGPARSING_WESTMERE_H
+#define SIMDJSON_STRINGPARSING_WESTMERE_H
+
+#include "simdjson/stringparsing.h"
+#include "simdjson/stringparsing_macros.h"
+
+#ifdef IS_X86_64
+TARGET_WESTMERE
+namespace simdjson {
+template <>
+really_inline parse_string_helper
+find_bs_bits_and_quote_bits<Architecture::WESTMERE>(const uint8_t *src,
+                                                    uint8_t *dst) {
+  // this can read up to 31 bytes beyond the buffer size, but we require
+  // SIMDJSON_PADDING of padding
+  __m128i v = _mm_loadu_si128(reinterpret_cast<const __m128i *>(src));
+  // store to dest unconditionally - we can overwrite the bits we don't like
+  // later
+  _mm_storeu_si128(reinterpret_cast<__m128i *>(dst), v);
+  auto quote_mask = _mm_cmpeq_epi8(v, _mm_set1_epi8('"'));
+  return {
+      static_cast<uint32_t>(
+          _mm_movemask_epi8(_mm_cmpeq_epi8(v, _mm_set1_epi8('\\')))), // bs_bits
+      static_cast<uint32_t>(_mm_movemask_epi8(quote_mask)) // quote_bits
+  };
+}
+
+template <>
+WARN_UNUSED ALLOW_SAME_PAGE_BUFFER_OVERRUN_QUALIFIER LENIENT_MEM_SANITIZER
+    really_inline bool
+    parse_string<Architecture::WESTMERE>(UNUSED const uint8_t *buf,
+                                         UNUSED size_t len, ParsedJson &pj,
+                                         UNUSED const uint32_t depth,
+                                         UNUSED uint32_t offset) {
+  PARSE_STRING(Architecture::WESTMERE, buf, len, pj, depth, offset);
+}
+} // namespace simdjson
+UNTARGET_REGION
+#endif
+
+#endif

data/vendor/simdjson/jsonexamples/small/jsoniter_scala/README.md

@@ -0,0 +1,4 @@
+Files from https://github.com/plokhotnyuk/jsoniter-scala/tree/master/jsoniter-scala-benchmark/src/main/resources/com/github/plokhotnyuk/jsoniter_scala/benchmark
+
+See issue "Lower performance on small files":
+https://github.com/lemire/simdjson/issues/70

data/vendor/simdjson/scripts/dumpsimplestats.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
+cd $SCRIPTPATH/..
+make jsonstats
+echo 
+for i in $SCRIPTPATH/../jsonexamples/*.json; do
+    [ -f "$i" ] || break
+    echo $i
+    $SCRIPTPATH/../jsonstats $i
+    echo
+done

data/vendor/simdjson/scripts/issue150.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
+cd $SCRIPTPATH/..
+for i in jsonchecker/adversarial/issue150/*.json ; do
+  echo $i;
+  ./allparserscheckfile -m $i;
+  if [ $? -ne 0 ];
+    then echo "potential bug";
+    exit 1
+  fi;
+done
+
+echo "Code is probably ok. All parsers agree."
+exit 0

data/vendor/simdjson/scripts/javascript/README.md

@@ -0,0 +1,3 @@
+- npm install
+- nodejs generatelargejson.js (or node generatelargejson.js)
+

data/vendor/simdjson/scripts/javascript/generatelargejson.js

@@ -0,0 +1,19 @@
+
+var fs = require('fs');
+
+var faker = require('faker');
+
+
+// generate bigDataSet as example
+var bigSet = [];
+var mmax = 500000
+console.log("this may take some time...")
+for(var i = 10; i < mmax; i++){
+  if(i % 1024 == 0) process.stdout.write("\r"+i+" entries ("+Math.round(i * 100.0 /mmax)+" percent)");
+  bigSet.push(faker.helpers.userCard());
+};
+console.log()
+
+fs.writeFile(__dirname + '/large.json',  JSON.stringify(bigSet), function() {
+  console.log("large.json generated successfully!");
+})

data/vendor/simdjson/scripts/minifier.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
+cd $SCRIPTPATH/..
+make minifiercompetition
+echo 
+for i in $SCRIPTPATH/../jsonexamples/*.json; do
+    [ -f "$i" ] || break
+    echo $i
+    $SCRIPTPATH/../minifiercompetition $i
+    echo
+done

data/vendor/simdjson/scripts/parseandstat.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
+cd $SCRIPTPATH/..
+make parseandstatcompetition
+echo "parsing and collecting basic stats on json documents as quickly as possible"
+echo 
+for i in $SCRIPTPATH/../jsonexamples/*.json; do
+    [ -f "$i" ] || break
+    echo $i
+    $SCRIPTPATH/../parseandstatcompetition $i
+    echo
+done
+
+make distinctuseridcompetition
+echo "parsing and finding all user.id"
+echo 
+
+for i in $SCRIPTPATH/../jsonexamples/twitter.json; do
+    [ -f "$i" ] || break
+    echo $i
+    $SCRIPTPATH/../distinctuseridcompetition  jsonexamples/twitter.json
+    echo
+done
+

data/vendor/simdjson/scripts/parser.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
+cd $SCRIPTPATH/..
+make parsingcompetition
+echo 
+for i in $SCRIPTPATH/../jsonexamples/*.json; do
+    [ -f "$i" ] || break
+    echo $i
+    $SCRIPTPATH/../parsingcompetition $i
+    echo
+done

data/vendor/simdjson/scripts/parsingcompdata.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
+cd $SCRIPTPATH/..
+datadirectory=$SCRIPTPATH/data/$(uname -n)
+mkdir -p $datadirectory
+
+os=$(uname)
+
+
+make parsingcompetition allparsingcompetition
+echo "parsing (with competition)"
+echo 
+for i in $SCRIPTPATH/../jsonexamples/*.json; do
+    [ -f "$i" ] || break
+    echo $i
+    shortname=$(basename $SCRIPTPATH/$i.table)
+    corename=$(basename ${shortname%.*})".pdf"
+    $SCRIPTPATH/../parsingcompetition -t $i > $datadirectory/$shortname
+    $SCRIPTPATH/../allparsingcompetition -t $i > $datadirectory/all$shortname
+    echo
+done
+
+echo "see results in "$datadirectory
+
+cd $datadirectory && gnuplot bar.gnuplot 

data/vendor/simdjson/scripts/plotparse.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+[[ "$(command -v gnuplot)" ]] || { echo "gnuplot is not installed" 1>&2 ; exit 1; }
+
+SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
+cd $SCRIPTPATH/..
+plotdirectory=$SCRIPTPATH/plots/$(uname -n)
+mkdir -p $plotdirectory
+
+os=$(uname)
+
+
+if [ "$os" = "Linux" ]; then
+  echo "You are using linux."
+  echo "We are going to just parse using simdjson, and collect perf stats."
+
+  make parse parse_noutf8validation parse_nonumberparsing parse_nostringparsing
+  myfile=$plotdirectory"/parselinuxtable.txt"
+  echo $myfile
+  echo "" > $myfile
+
+  myfilenoutf8validation=$plotdirectory"/parselinuxtable_noutf8validation.txt"
+  echo $myfilenoutf8validation
+  echo "" > $myfilenoutf8validation
+
+  myfilenonumberparsing=$plotdirectory"/parselinuxtable_nonumberparsing.txt"
+  echo $myfilenonumberparsing
+  echo "" > $myfilenonumberparsing
+
+  myfilenostringparsing=$plotdirectory"/parselinuxtable_nostringparsing.txt"
+  echo $myfilenostringparsing
+  echo "" > $myfilenostringparsing
+
+
+  for i in $SCRIPTPATH/../jsonexamples/*.json; do
+    [ -f "$i" ] || break
+    echo $i
+    $SCRIPTPATH/../parse -t "$i" >> "$myfile"
+    $SCRIPTPATH/../parse_noutf8validation -t "$i" >> "$myfilenoutf8validation"
+    $SCRIPTPATH/../parse_nonumberparsing -t "$i" >> "$myfilenonumberparsing"
+    $SCRIPTPATH/../parse_nostringparsing -t "$i" >> "$myfilenostringparsing"
+  done
+  paste $myfile $myfilenoutf8validation $myfilenonumberparsing $myfilenostringparsing > "$myfile.tmp"
+  mv "$myfile.tmp" $myfile
+  rm  $myfilenoutf8validation $myfilenonumberparsing $myfilenostringparsing
+  gnuplot -e "filename='$myfile';name='$plotdirectory/stackedperf.pdf'" $SCRIPTPATH/stackbar.gnuplot
+fi
+
+make parsingcompetition
+echo "parsing (with competition)"
+echo 
+for i in $SCRIPTPATH/../jsonexamples/*.json; do
+    [ -f "$i" ] || break
+    echo $i
+    shortname=$(basename $SCRIPTPATH/$i.table)
+    corename=$(basename ${shortname%.*})".pdf"
+    $SCRIPTPATH/../parsingcompetition -t $i > $plotdirectory/$shortname
+    sort $plotdirectory/$shortname > $plotdirectory/$shortname.table.sorted
+    gnuplot -e "filename='$plotdirectory/$shortname.table.sorted';name='$plotdirectory/$corename'" $SCRIPTPATH/bar.gnuplot
+    rm $plotdirectory/$shortname
+    rm $plotdirectory/$shortname.table.sorted
+    echo
+done
+
+
+make parseandstatcompetition
+echo "parsing and collecting basic stats on json documents as quickly as possible"
+echo 
+for i in $SCRIPTPATH/../jsonexamples/*.json; do
+    [ -f "$i" ] || break
+    echo $i
+    shortname=$(basename $SCRIPTPATH/$i"parseandstat.table")
+    corename=$(basename ${shortname%.*})".pdf"
+    $SCRIPTPATH/../parseandstatcompetition  -t $i> $plotdirectory/$shortname
+    sort $plotdirectory/$shortname > $plotdirectory/$shortname.table.sorted
+    gnuplot -e "filename='$plotdirectory/$shortname.table.sorted';name='$plotdirectory/$corename'" $SCRIPTPATH/bar.gnuplot
+    rm $plotdirectory/$shortname
+    rm $plotdirectory/$shortname.table.sorted
+    echo
+done
+
+make distinctuseridcompetition
+echo "parsing and finding all user.id"
+echo 
+
+for i in $SCRIPTPATH/../jsonexamples/twitter.json; do
+    [ -f "$i" ] || break
+    echo $i
+    shortname=$(basename $SCRIPTPATH/$i"distinctuserid.table")
+    corename=$(basename ${shortname%.*})".pdf"
+    $SCRIPTPATH/../distinctuseridcompetition   -t jsonexamples/twitter.json> $plotdirectory/$shortname
+    sort $plotdirectory/$shortname > $plotdirectory/$shortname.table.sorted
+    gnuplot -e "filename='$plotdirectory/$shortname.table.sorted';name='$plotdirectory/$corename'" $SCRIPTPATH/bar.gnuplot
+    rm $plotdirectory/$shortname
+    rm $plotdirectory/$shortname.table.sorted
+    echo
+done
+
+echo "see results in "$plotdirectory

data/vendor/simdjson/scripts/selectparser.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
+cd $SCRIPTPATH/..
+make parsingcompetition
+echo 
+for i in "$SCRIPTPATH/../jsonexamples/twitter.json" "$SCRIPTPATH/../jsonexamples/update-center.json" "$SCRIPTPATH/../jsonexamples/github_events.json" "$SCRIPTPATH/../jsonexamples/gsoc-2018.json" ; do
+    [ -f "$i" ] || break
+    echo $i
+    $SCRIPTPATH/../parsingcompetition $i
+    echo
+done

data/vendor/simdjson/scripts/setupfortesting/disablehyperthreading.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+# Be careful to not skip the space at the beginning nor the end
+CPUS_TO_SKIP=" $(cat /sys/devices/system/cpu/cpu*/topology/thread_siblings_list | sed 's/[^0-9].*//' | sort | uniq | tr "\r\n" "  ") "
+
+
+for CPU_PATH in /sys/devices/system/cpu/cpu[0-9]*; do
+    CPU="$(echo $CPU_PATH | tr -cd "0-9")"
+    echo "$CPUS_TO_SKIP" | grep " $CPU " > /dev/null
+    if [ $? -ne 0 ]; then
+        echo 0 > $CPU_PATH/online
+    fi
+done
+
+egrep 'siblings|cpu cores' /proc/cpuinfo | head -2

data/vendor/simdjson/scripts/setupfortesting/powerpolicy.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+# sudo /usr/bin/cpupower frequency-set -g performance
+#######
+# taken from http://hbfs.wordpress.com/2013/06/18/fast-path-finding-part-ii/
+# might require sudo apt-get install cpufrequtils
+# invoke with performance or ondemand 
+# type cpufreq-info to check results, you can also verify with cat /proc/cpuinfo
+# enumerate found CPUs
+cpus=$( grep processor /proc/cpuinfo | cut -d: -f 2 )
+
+
+if [ "$1" = "ondemand" ]; then
+  echo "setting up ondemand"
+  policy="ondemand"
+elif [ "$1" = "performance" ]; then
+  echo "setting up for performance"
+  policy="performance"
+elif [ "$1" = "list" ]; then
+  cpufreq-info
+  exit 0
+else
+  echo "usage: powerpolicy.sh ondemand | performance list"
+  exit -1
+fi
+
+echo "chosen policy " $1 
+# set governor for each CPU
+#
+for cpu in ${cpus[@]}
+do
+  cpufreq-set -c $cpu -g $1
+done

data/vendor/simdjson/scripts/setupfortesting/setupfortesting.sh

@@ -0,0 +1,6 @@
+cd "${0%/*}"
+export CXX=g++-7
+export CC=gcc-7
+#./powerpolicy.sh  performance
+./disablehyperthreading.sh 
+./turboboost.sh on

data/vendor/simdjson/scripts/setupfortesting/turboboost.sh

@@ -0,0 +1,51 @@
+#!/bin/sh
+# stolen from https://github.com/DropD/fnc-simplex/blob/master/linux_turboboost.sh
+
+# you might need to run sudo apt-get install msr-tools
+# Toggle Turbo Boost for Ivy Bridge CPUs (should work for all newer Core)
+# Requires a fairly new Linux kernel (let's say 3.0+)
+# Written by Donjan Rodic, released for free use
+
+# check current real frequency with  sudo turbostat -s -i1
+
+sudo modprobe msr
+
+# all_cores FOO
+# perform FOO(i) for each core i
+all_cores() {
+  NPROCS=`cat /proc/cpuinfo | grep "core id" | wc -l`
+  NPROCS=$(($NPROCS - 1))
+  for i in `seq 0 1 $NPROCS`; do
+    $1 $i
+  done
+}
+
+
+# report Turbo Boost state on core $1
+read_tb() {
+  ret=`sudo rdmsr -p"$1" 0x1a0 -f 38:38`
+  [ $ret -eq 0 ] && echo "$1": on || echo "$1": off
+}
+
+# enable Turbo Boost on core $1
+enable_tb() {
+  sudo wrmsr -p"$1" 0x1a0 0x850089
+}
+
+# disable Turbo Boost on core $1
+disable_tb() {
+  sudo wrmsr -p"$1" 0x1a0 0x4000850089
+}
+
+
+if [ "$1" = "on" ]; then
+  all_cores enable_tb
+  all_cores read_tb
+elif [ "$1" = "off" ]; then
+  all_cores disable_tb
+  all_cores read_tb
+elif [ "$1" = "list" ]; then
+  all_cores read_tb
+else
+  echo "usage: turboboost.sh on | off | list"
+fi