From 7bd4d2b8da8fffe7987ebaccd4d27f0b62c7f54d Mon Sep 17 00:00:00 2001 From: "Harper, Jason M" Date: Thu, 12 Jun 2025 06:25:49 -0700 Subject: [PATCH 1/2] use local avx-turbo Signed-off-by: Harper, Jason M --- tools/Makefile | 8 +- tools/avx-turbo/.github/workflows/build.yml | 39 + tools/avx-turbo/.gitignore | 59 + tools/avx-turbo/.travis.yml | 70 + tools/avx-turbo/LICENSE | 21 + tools/avx-turbo/Makefile | 61 + tools/avx-turbo/README.md | 155 + tools/avx-turbo/args.hxx | 2602 +++ tools/avx-turbo/asm-methods.asm | 224 + tools/avx-turbo/atomic.h | 409 + tools/avx-turbo/avx-turbo.cpp | 890 + tools/avx-turbo/check-uarch.sh | 33 + tools/avx-turbo/config.mk | 16 + tools/avx-turbo/cpu.c | 165 + tools/avx-turbo/cpu.h | 190 + tools/avx-turbo/cpuid.cpp | 123 + tools/avx-turbo/cpuid.hpp | 48 + tools/avx-turbo/exact-int.h | 229 + tools/avx-turbo/msr-access.c | 129 + tools/avx-turbo/msr-access.h | 57 + tools/avx-turbo/nasm-2.13.03/LICENSE | 29 + tools/avx-turbo/nasm-2.13.03/NOTE | 3 + tools/avx-turbo/nasm-2.13.03/nasm | Bin 0 -> 1470376 bytes tools/avx-turbo/nasm-utils-helper.c | 43 + tools/avx-turbo/nasm-utils-inc.asm | 210 + tools/avx-turbo/once.h | 128 + tools/avx-turbo/stats.hpp | 128 + tools/avx-turbo/table.hpp | 177 + tools/avx-turbo/test/catch.hpp | 17959 ++++++++++++++++++ tools/avx-turbo/test/unit-test-main.cpp | 9 + tools/avx-turbo/test/unit-test.cpp | 141 + tools/avx-turbo/tsc-support.cpp | 132 + tools/avx-turbo/tsc-support.hpp | 29 + tools/avx-turbo/util.hpp | 239 + 34 files changed, 24748 insertions(+), 7 deletions(-) create mode 100644 tools/avx-turbo/.github/workflows/build.yml create mode 100644 tools/avx-turbo/.gitignore create mode 100644 tools/avx-turbo/.travis.yml create mode 100644 tools/avx-turbo/LICENSE create mode 100644 tools/avx-turbo/Makefile create mode 100644 tools/avx-turbo/README.md create mode 100644 tools/avx-turbo/args.hxx create mode 100644 tools/avx-turbo/asm-methods.asm create mode 100644 tools/avx-turbo/atomic.h create mode 100644 tools/avx-turbo/avx-turbo.cpp create mode 100755 tools/avx-turbo/check-uarch.sh create mode 100644 tools/avx-turbo/config.mk create mode 100644 tools/avx-turbo/cpu.c create mode 100644 tools/avx-turbo/cpu.h create mode 100644 tools/avx-turbo/cpuid.cpp create mode 100644 tools/avx-turbo/cpuid.hpp create mode 100644 tools/avx-turbo/exact-int.h create mode 100644 tools/avx-turbo/msr-access.c create mode 100644 tools/avx-turbo/msr-access.h create mode 100644 tools/avx-turbo/nasm-2.13.03/LICENSE create mode 100644 tools/avx-turbo/nasm-2.13.03/NOTE create mode 100755 tools/avx-turbo/nasm-2.13.03/nasm create mode 100644 tools/avx-turbo/nasm-utils-helper.c create mode 100644 tools/avx-turbo/nasm-utils-inc.asm create mode 100644 tools/avx-turbo/once.h create mode 100644 tools/avx-turbo/stats.hpp create mode 100644 tools/avx-turbo/table.hpp create mode 100644 tools/avx-turbo/test/catch.hpp create mode 100644 tools/avx-turbo/test/unit-test-main.cpp create mode 100644 tools/avx-turbo/test/unit-test.cpp create mode 100644 tools/avx-turbo/tsc-support.cpp create mode 100644 tools/avx-turbo/tsc-support.hpp create mode 100644 tools/avx-turbo/util.hpp diff --git a/tools/Makefile b/tools/Makefile index f16cd9a4..722b261d 100644 --- a/tools/Makefile +++ b/tools/Makefile @@ -44,14 +44,8 @@ endif tar -xf async-profiler-$(ASYNC_PROFILER_VERSION)-linux-x64.tar.gz && mv async-profiler-$(ASYNC_PROFILER_VERSION)-linux-x64 async-profiler endif -AVX_TURBO_VERSION := "threadcpuid" +# Use a local copy of avx-turbo source until the upstream makes the required changes avx-turbo: -ifeq ("$(wildcard avx-turbo)","") - git clone https://github.com/harp-intel/avx-turbo.git -else - cd avx-turbo && git checkout master && git pull -endif - cd avx-turbo && git checkout $(AVX_TURBO_VERSION) && git pull cd avx-turbo && make # if you change the version, check the sed hacks below diff --git a/tools/avx-turbo/.github/workflows/build.yml b/tools/avx-turbo/.github/workflows/build.yml new file mode 100644 index 00000000..848b4720 --- /dev/null +++ b/tools/avx-turbo/.github/workflows/build.yml @@ -0,0 +1,39 @@ +name: build +on: [push] +jobs: + build: + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-20.04] + cpp_compiler: [g++, g++-7, g++-8, g++-9, clang++, clang++-9] + include: + - c_compiler: gcc + - cpp_compiler: g++-7 + c_compiler: gcc-7 + - cpp_compiler: g++-8 + c_compiler: gcc-8 + - cpp_compiler: g++-9 + c_compiler: gcc-9 + - cpp_compiler: clang++ + c_compiler: clang + - cpp_compiler: clang++-9 + c_compiler: clang-9 + steps: + - name: Install C Compiler + if: ${{ startsWith(matrix.c_compiler, 'gcc-') || startsWith(matrix.c_compiler, 'clang-') }} + run: | + sudo apt-get update + sudo apt-get install -y ${{ matrix.c_compiler }} + - name: Install C++ Compiler + if: ${{ startsWith(matrix.cpp_compiler, 'g++-') || startsWith(matrix.cpp_compiler, 'clang++-') }} + run: | + sudo apt-get update + sudo apt-get install -y ${{ matrix.cpp_compiler }} + - uses: actions/checkout@v2 + - run: lscpu + - run: make -j2 CC=${{ matrix.c_compiler }} CXX=${{ matrix.cpp_compiler }} + - run: ./unit-test + - run: ./avx-turbo --no-pin --max-threads 2 + diff --git a/tools/avx-turbo/.gitignore b/tools/avx-turbo/.gitignore new file mode 100644 index 00000000..d79da866 --- /dev/null +++ b/tools/avx-turbo/.gitignore @@ -0,0 +1,59 @@ +# Prerequisites +*.d + +# Compiled Object files +*.slo +*.lo +*.o +*.obj + +# Precompiled Headers +*.gch +*.pch + +# Compiled Dynamic libraries +*.so +*.dylib +*.dll + +# Fortran module files +*.mod +*.smod + +# Compiled Static libraries +*.lai +*.la +*.a +*.lib + +# Executables +*.exe +*.out +*.app +avx-turbo +unit-test + +# Eclipse CDT artifacts +.cproject +.project +.settings + +# nasm listing file +*.list + +# libpfm4 directory +libpfm-4*/* + +# core files +/core* +/vgcore* + +# perf files +/perf.* + +/tmp/* + +dummy.rebuild + +# local make config file +local.mk diff --git a/tools/avx-turbo/.travis.yml b/tools/avx-turbo/.travis.yml new file mode 100644 index 00000000..fa6dfbbf --- /dev/null +++ b/tools/avx-turbo/.travis.yml @@ -0,0 +1,70 @@ +dist: xenial +language: cpp +sudo: false +branches: + except: + - /^(wip\/)?(appveyor|msvc|mingw|windows)(\-.+)?$/ + +addons: + apt: + sources: &default_sources + - ubuntu-toolchain-r-test + +# the anchors element doesn't do anything but itself except define some anchors to be used later as aliases +anchors: + - &unit_command ./unit-test + - &uarch_command ./uarch-bench --test-tag=~slow + +matrix: + include: + # clang-5.0 is the default installed on travis VMs + - compiler: clang-default + env: TRUE_CC=clang TRUE_CXX=clang++ CXXFLAGS=-stdlib=libc++ + addons: + apt: + sources: + - *default_sources + - llvm-toolchain-trusty-5.0 + packages: + - libc++abi1 + - libc++1 + - compiler: gcc-4.9 + env: TRUE_CC=gcc-4.9 TRUE_CXX=g++-4.9 + addons: + apt: + sources: + - *default_sources + packages: + - gcc-4.9 + - g++-4.9 + - compiler: gcc-6 + env: TRUE_CC=gcc-6 TRUE_CXX=g++-6 + addons: + apt: + sources: + - *default_sources + packages: + - gcc-6 + - g++-6 + - compiler: clang-6.0 + env: TRUE_CC=clang-6.0 TRUE_CXX=clang++-6.0 + addons: + apt: + sources: + - *default_sources + - llvm-toolchain-xenial-6.0 + packages: + - clang-6.0 + - clang++-6.0 + +before_install: +# Travis will set CC and CXX after the env commands specified in the matrix are run, overwriting whatever +# we've specified there, so we need to reset them here. See also https://github.com/travis-ci/travis-ci/issues/6633 . + - CC="${TRUE_CC:-$CC}" + - CXX="${TRUE_CXX:-$CXX}" + + +script: +- set -e && echo "CC is ${CC}, CXX is ${CXX}" && ${CC} --version && ${CXX} --version +- make +- ./avx-turbo --no-pin --max-threads 2 diff --git a/tools/avx-turbo/LICENSE b/tools/avx-turbo/LICENSE new file mode 100644 index 00000000..3b5b9747 --- /dev/null +++ b/tools/avx-turbo/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 travisdowns + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/avx-turbo/Makefile b/tools/avx-turbo/Makefile new file mode 100644 index 00000000..606a785c --- /dev/null +++ b/tools/avx-turbo/Makefile @@ -0,0 +1,61 @@ +include config.mk + +# rebuild when makefile changes +-include dummy.rebuild + +.PHONY: all clean + +ASM_FLAGS ?= -DNASM_ENABLE_DEBUG=$(NASM_DEBUG) -w+all -l x86_methods.list + +ifneq ($(CPU_ARCH),) +ARCH_FLAGS := -march=$(CPU_ARCH) +endif +O_LEVEL ?= -O2 + +COMMON_FLAGS := -MMD -Wall -Wextra -Wundef $(ARCH_FLAGS) -g $(O_LEVEL) +CPPFLAGS := $(COMMON_FLAGS) +CFLAGS := $(COMMON_FLAGS) + +SRC_FILES := $(wildcard *.cpp) $(wildcard *.c) + +OBJECTS := $(SRC_FILES:.cpp=.o) asm-methods.o +OBJECTS := $(OBJECTS:.c=.o) +DEPFILES = $(OBJECTS:.o=.d) +# $(info OBJECTS=$(OBJECTS)) + +VPATH = test + +########### +# Targets # +########### + +all: avx-turbo unit-test + +-include $(DEPFILES) unit-test.d + +clean: + rm -f *.d *.o avx-turbo + +dist-clean: clean $(CLEAN_TARGETS) + +unit-test: unit-test.o unit-test-main.o cpuid.o + $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(LDLIBS) -std=c++11 $^ -o $@ + +avx-turbo: $(OBJECTS) + $(CXX) $(OBJECTS) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(LDLIBS) -std=c++11 -lpthread -o $@ + +%.o : %.c + $(CC) $(CFLAGS) -c -std=c11 -o $@ $< + +%.o : %.cpp + $(CXX) $(CPPFLAGS) $(CXXFLAGS) -c -std=c++11 -o $@ $< + +%.o: %.asm nasm-utils-inc.asm + $(ASM) $(ASM_FLAGS) -f elf64 $< + +LOCAL_MK = $(wildcard local.mk) + +# https://stackoverflow.com/a/3892826/149138 +dummy.rebuild: Makefile config.mk $(LOCAL_MK) + touch $@ + $(MAKE) -s clean diff --git a/tools/avx-turbo/README.md b/tools/avx-turbo/README.md new file mode 100644 index 00000000..425754f5 --- /dev/null +++ b/tools/avx-turbo/README.md @@ -0,0 +1,155 @@ +# avx-turbo + +Test the non-AVX, AVX2 and AVX-512 speeds for various types of CPU intensive loops with varying scalar and SIMD instructions, across different active core counts. + +Currently it is **Linux only** (it does run on WSL and WSL2 on Windows), but the basic testing mechanism could be ported to OSX and Windows as well (help welcome). + +# CI Status + +**Build:** [![Master Branch](https://github.com/travisdowns/avx-turbo/workflows/build/badge.svg)](https://github.com/travisdowns/avx-turbo/actions?query=workflow%3Abuild+branch%3Amaster) + + +# build + + make + +# msr kernel module + +You should load the `msr` kernel module if it is not already loaded. This is as simple as: + + modprobe msr + +Or as complex as (if you want nice messages about what happened): + + lsmod | grep -q msr && echo "MSR already loaded" || { echo "Loading MSR module"; sudo modprobe msr ; } + +# run + +You get the most info running as root (since we can read various MSRs to calculate the frequency directly): + + sudo ./avx-turbo + +You can also run it without root, but you only get the "Mops" reading (but this can be read directly as frequency +for the 1-latency tests). + +## spec-based tests + +The default behavior for ./avx-turbo is to run tests with various thread counts, but with the same test on each thread. For example, the `avx256_fma` test means that the same FMA-using test code will be run on _each_ test thread. + +An alternate approach is availe with so-called _spec-based_ tests. This lets you specificy exactly what each thread in a test will run. The general form of a specification is: `test1/thead-count1[,test2/thread-count2[,...]]`. For example, +if you run `sudo ./avx-turbo --spec avx256_fma/1,scalar_iadd/3` you'll get one copy of `avx256_fma` and three copies of `scalar_iadd` running in parallel. + +This mode is useful to testing that happens when not all cores are doing the same thing. + +# help + +Try: + + ./avx-turbo --help + +for a summary of some options something like this: + +``` + ./avx-turbo {OPTIONS} + + avx-turbo: Determine AVX2 and AVX-512 downclocking behavior + + OPTIONS: + + -h, --help Display this help menu + --force-tsc-calibrate Force manual TSC calibration loop, even + if cpuid TSC Hz is available + --no-pin Don't try to pin threads to CPU - gives + worse results but works around affinity + issues on TravisCI + --verbose Output more info + --no-barrier Don't sync up threads before each test + (no real purpose) + --list List the available tests and their + descriptions + --allow-hyperthreads By default we try to filter down the + available cpus to include only physical + cores, but with this option we'll use + all logical cores meaning you'll run two + tests on cores with hyperthreading + --test=[TEST-ID] Run only the specified test (by ID) + --spec=[SPEC] Run a specific type of test specified by + a specification string + --iters=[ITERS] Run the test loop ITERS times (default + 100000) + --min-threads=[MIN] The minimum number of threads to use + --max-threads=[MAX] The maximum number of threads to use + --warmup-ms=[MILLISECONDS] Warmup milliseconds for each thread + after pinning (default 100) + +``` + +# output + +The output looks like this: + +``` +Running as root : [YES] +CPU supports AVX2 : [YES] +CPU supports AVX-512: [NO ] +cpuid = eax = 2, ebx = 216, ecx = 0, edx = 0 +cpu: family = 6, model = 94, stepping = 3 +tsc_freq = 2592.0 MHz (from cpuid leaf 0x15) +Will test up to 4 CPUs +============================== Threads: 1 ============================== +ID | Description | Mops | A/M-ratio | A/M-MHz | M/tsc-ratio +scalar_iadd | Scalar integer adds | 2594 | 1.00 | 2592 | 1.00 +avx128_iadd | 128-bit integer adds | 2594 | 1.00 | 2592 | 1.00 +avx128_imul | 128-bit integer muls | 519 | 1.00 | 2592 | 1.00 +avx128_fma | 128-bit 64-bit FMAs | 649 | 1.00 | 2592 | 1.00 +avx256_iadd | 256-bit integer adds | 2594 | 1.00 | 2592 | 1.00 +avx256_imul | 256-bit integer muls | 519 | 1.00 | 2592 | 1.00 +avx256_fma | 256-bit serial DP FMAs | 648 | 1.00 | 2592 | 1.00 +avx256_fma_t | 256-bit parallel DP FMAs | 5189 | 1.00 | 2592 | 1.00 +========================================================================= + +============================== Threads: 2 ============================== +ID | Description | Mops | A/M-ratio | A/M-MHz | M/tsc-ratio +scalar_iadd | Scalar integer adds | 2593, 2593 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00 +avx128_iadd | 128-bit integer adds | 2594, 2594 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00 +avx128_imul | 128-bit integer muls | 519, 519 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00 +avx128_fma | 128-bit 64-bit FMAs | 648, 649 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00 +avx256_iadd | 256-bit integer adds | 2594, 2594 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00 +avx256_imul | 256-bit integer muls | 519, 519 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00 +avx256_fma | 256-bit serial DP FMAs | 648, 648 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00 +avx256_fma_t | 256-bit parallel DP FMAs | 5188, 5189 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00 +========================================================================= + +============================== Threads: 3 ============================== +ID | Description | Mops | A/M-ratio | A/M-MHz | M/tsc-ratio +scalar_iadd | Scalar integer adds | 2594, 2594, 2594 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00 +avx128_iadd | 128-bit integer adds | 2594, 2594, 2594 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00 +avx128_imul | 128-bit integer muls | 519, 519, 519 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00 +avx128_fma | 128-bit 64-bit FMAs | 649, 648, 648 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00 +avx256_iadd | 256-bit integer adds | 2594, 2594, 2594 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00 +avx256_imul | 256-bit integer muls | 519, 519, 519 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00 +avx256_fma | 256-bit serial DP FMAs | 649, 648, 649 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00 +avx256_fma_t | 256-bit parallel DP FMAs | 5190, 5189, 5190 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00 +========================================================================= + +============================== Threads: 4 ============================== +ID | Description | Mops | A/M-ratio | A/M-MHz | M/tsc-ratio +scalar_iadd | Scalar integer adds | 2594, 2594, 2594, 2594 | 1.00, 1.00, 1.00, 1.00 | 2592, 2592, 2592, 2592 | 1.00, 1.00, 1.00, 1.00 +avx128_iadd | 128-bit integer adds | 2593, 2594, 2594, 2594 | 1.00, 1.00, 1.00, 1.00 | 2592, 2592, 2592, 2592 | 1.00, 1.00, 1.00, 1.00 +avx128_imul | 128-bit integer muls | 519, 519, 519, 519 | 1.00, 1.00, 1.00, 1.00 | 2592, 2592, 2592, 2592 | 1.00, 1.00, 1.00, 1.00 +avx128_fma | 128-bit 64-bit FMAs | 648, 648, 649, 648 | 1.00, 1.00, 1.00, 1.00 | 2592, 2592, 2592, 2592 | 1.00, 1.00, 1.00, 1.00 +avx256_iadd | 256-bit integer adds | 2594, 2594, 2594, 2594 | 1.00, 1.00, 1.00, 1.00 | 2592, 2592, 2592, 2592 | 1.00, 1.00, 1.00, 1.00 +avx256_imul | 256-bit integer muls | 519, 519, 519, 519 | 1.00, 1.00, 1.00, 1.00 | 2592, 2592, 2592, 2592 | 1.00, 1.00, 1.00, 1.00 +avx256_fma | 256-bit serial DP FMAs | 648, 648, 648, 648 | 1.00, 1.00, 1.00, 1.00 | 2592, 2592, 2592, 2592 | 1.00, 1.00, 1.00, 1.00 +avx256_fma_t | 256-bit parallel DP FMAs | 5189, 5189, 5189, 5189 | 1.00, 1.00, 1.00, 1.00 | 2592, 2592, 2592, 2592 | 1.00, 1.00, 1.00, 1.00 +========================================================================= +``` + +The headings are: + + - `ID` The ID for the test, which you can use with the `--test` argument to only run a specific test (handy when you want to focus on one test to read the frequency externally, e.g., via `perf`). + - `Description` Yes, it's a description. + - `Mops` Million operations per second. Every test runs a loop of the same type of instruction and this is how many millions of those instructions were executed per second. This is handy since this value corresponds exactly to frequency in MHz for tests with serially dependent 1-latency instructions, which here are all the "integer adds" tests. + - `A/M` This is the ratio of the `APERF` and `MPERF` ratios exposed in an MSR. For details, see the [Intel SDM Vol 3](https://software.intel.com/en-us/download/intel-64-and-ia-32-architectures-sdm-combined-volumes-3a-3b-3c-and-3d-system-programming-guide), but basically APERF is a free running counter of actual cycles (i.e., varying with the CPU frequency), while MPERF counts at a constant rate, usually the processor's nominal frequency. A ratio of 1.0 therefore means that the CPU was is running, on average, at the nominal frequency during the test (I had turbo off, that's why you see 1.00 everywhere). Lower than 1 means lower than nominal frequencies (e.g., due to running heavy AVX code). + - `A/M-MHz` This is the measured frequency over the duration of the test, based on the `APERF` and `MPERF` ratio described above, multiplied by the base (TSC) frequency. Note that this only counts "non-halted" periods, so if the CPU was running at 1000 MHz half the time but halted the other half of the time (due to a frequency transition), you'd see 1000 MHz here, not 500 MHz. + - `M/tsc-ratio` This shows the ration of the `MPERF` register to the TSC (time stamp counter) over the duration of the test. These counters count at the same rate, except that `MPERF` only counts "unhalted" cycles, while the TSC counts all cycles, so this ratio gives you an indication of the "lost" cycles due to halt events. A big source of halt events is frequency transitions in the turbo range: on my Skylake client CPU, any time another core starts up, the allowed turbo ratio changes, so the CPU halts for perhaps 20,000 cycles, so with moderate activity I often see ratios of 0.9 which means that 10% of the time my CPU is doing nothing. To get a "true" frequency, you should multiply this ratio by the `A/M-MHz` column, which would be the actual average frequency, counting halted periods as zero. diff --git a/tools/avx-turbo/args.hxx b/tools/avx-turbo/args.hxx new file mode 100644 index 00000000..c3752b43 --- /dev/null +++ b/tools/avx-turbo/args.hxx @@ -0,0 +1,2602 @@ +/* Copyright (c) 2016-2017 Taylor C. Richberger and Pavel + * Belikov + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +/** \file args.hxx + * \brief this single-header lets you use all of the args functionality + * + * The important stuff is done inside the args namespace + */ + +#ifndef ARGS_HXX +#define ARGS_HXX + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef ARGS_TESTNAMESPACE +namespace argstest +{ +#else + +/** \namespace args + * \brief contains all the functionality of the args library + */ +namespace args +{ +#endif + /** Getter to grab the value from the argument type. + * + * If the Get() function of the type returns a reference, so does this, and + * the value will be modifiable. + */ + template + auto get(Option &option_) -> decltype(option_.Get()) + { + return option_.Get(); + } + + /** (INTERNAL) Count UTF-8 glyphs + * + * This is not reliable, and will fail for combinatory glyphs, but it's + * good enough here for now. + * + * \param string The string to count glyphs from + * \return The UTF-8 glyphs in the string + */ + inline std::string::size_type Glyphs(const std::string &string_) + { + std::string::size_type length = 0; + for (const char c: string_) + { + if ((c & 0xc0) != 0x80) + { + ++length; + } + } + return length; + } + + /** (INTERNAL) Wrap a string into a vector of lines + * + * This is quick and hacky, but works well enough. You can specify a + * different width for the first line + * + * \param width The width of the body + * \param the width of the first line, defaults to the width of the body + * \return the vector of lines + */ + inline std::vector Wrap(const std::string &in, const std::string::size_type width, std::string::size_type firstlinewidth = 0) + { + // Preserve existing line breaks + const auto newlineloc = in.find('\n'); + if (newlineloc != in.npos) + { + auto first = Wrap(std::string(in, 0, newlineloc), width); + auto second = Wrap(std::string(in, newlineloc + 1), width); + first.insert( + std::end(first), + std::make_move_iterator(std::begin(second)), + std::make_move_iterator(std::end(second))); + return first; + } + if (firstlinewidth == 0) + { + firstlinewidth = width; + } + auto currentwidth = firstlinewidth; + + std::istringstream stream(in); + std::vector output; + std::ostringstream line; + std::string::size_type linesize = 0; + while (stream) + { + std::string item; + stream >> item; + auto itemsize = Glyphs(item); + if ((linesize + 1 + itemsize) > currentwidth) + { + if (linesize > 0) + { + output.push_back(line.str()); + line.str(std::string()); + linesize = 0; + currentwidth = width; + } + } + if (itemsize > 0) + { + if (linesize) + { + ++linesize; + line << " "; + } + line << item; + linesize += itemsize; + } + } + if (linesize > 0) + { + output.push_back(line.str()); + } + return output; + } + +#ifdef ARGS_NOEXCEPT + /// Error class, for when ARGS_NOEXCEPT is defined + enum class Error + { + None, + Usage, + Parse, + Validation, + Required, + Map, + Extra, + Help + }; +#else + /** Base error class + */ + class Error : public std::runtime_error + { + public: + Error(const std::string &problem) : std::runtime_error(problem) {} + virtual ~Error() {}; + }; + + /** Errors that occur during usage + */ + class UsageError : public Error + { + public: + UsageError(const std::string &problem) : Error(problem) {} + virtual ~UsageError() {}; + }; + + /** Errors that occur during regular parsing + */ + class ParseError : public Error + { + public: + ParseError(const std::string &problem) : Error(problem) {} + virtual ~ParseError() {}; + }; + + /** Errors that are detected from group validation after parsing finishes + */ + class ValidationError : public Error + { + public: + ValidationError(const std::string &problem) : Error(problem) {} + virtual ~ValidationError() {}; + }; + + /** Errors that when a required flag is omitted + */ + class RequiredError : public ValidationError + { + public: + RequiredError(const std::string &problem) : ValidationError(problem) {} + virtual ~RequiredError() {}; + }; + + /** Errors in map lookups + */ + class MapError : public ParseError + { + public: + MapError(const std::string &problem) : ParseError(problem) {} + virtual ~MapError() {}; + }; + + /** Error that occurs when a singular flag is specified multiple times + */ + class ExtraError : public ParseError + { + public: + ExtraError(const std::string &problem) : ParseError(problem) {} + virtual ~ExtraError() {}; + }; + + /** An exception that indicates that the user has requested help + */ + class Help : public Error + { + public: + Help(const std::string &flag) : Error(flag) {} + virtual ~Help() {}; + }; +#endif + + /** A simple unified option type for unified initializer lists for the Matcher class. + */ + struct EitherFlag + { + const bool isShort; + const char shortFlag; + const std::string longFlag; + EitherFlag(const std::string &flag) : isShort(false), shortFlag(), longFlag(flag) {} + EitherFlag(const char *flag) : isShort(false), shortFlag(), longFlag(flag) {} + EitherFlag(const char flag) : isShort(true), shortFlag(flag), longFlag() {} + + /** Get just the long flags from an initializer list of EitherFlags + */ + static std::unordered_set GetLong(std::initializer_list flags) + { + std::unordered_set longFlags; + for (const EitherFlag &flag: flags) + { + if (!flag.isShort) + { + longFlags.insert(flag.longFlag); + } + } + return longFlags; + } + + /** Get just the short flags from an initializer list of EitherFlags + */ + static std::unordered_set GetShort(std::initializer_list flags) + { + std::unordered_set shortFlags; + for (const EitherFlag &flag: flags) + { + if (flag.isShort) + { + shortFlags.insert(flag.shortFlag); + } + } + return shortFlags; + } + }; + + + + /** A class of "matchers", specifying short and flags that can possibly be + * matched. + * + * This is supposed to be constructed and then passed in, not used directly + * from user code. + */ + class Matcher + { + private: + const std::unordered_set shortFlags; + const std::unordered_set longFlags; + + public: + /** Specify short and long flags separately as iterators + * + * ex: `args::Matcher(shortFlags.begin(), shortFlags.end(), longFlags.begin(), longFlags.end())` + */ + template + Matcher(ShortIt shortFlagsStart, ShortIt shortFlagsEnd, LongIt longFlagsStart, LongIt longFlagsEnd) : + shortFlags(shortFlagsStart, shortFlagsEnd), + longFlags(longFlagsStart, longFlagsEnd) + {} + + /** Specify short and long flags separately as iterables + * + * ex: `args::Matcher(shortFlags, longFlags)` + */ + template + Matcher(Short &&shortIn, Long &&longIn) : + shortFlags(std::begin(shortIn), std::end(shortIn)), longFlags(std::begin(longIn), std::end(longIn)) + {} + + /** Specify a mixed single initializer-list of both short and long flags + * + * This is the fancy one. It takes a single initializer list of + * any number of any mixed kinds of flags. Chars are + * automatically interpreted as short flags, and strings are + * automatically interpreted as long flags: + * + * args::Matcher{'a'} + * args::Matcher{"foo"} + * args::Matcher{'h', "help"} + * args::Matcher{"foo", 'f', 'F', "FoO"} + */ + Matcher(std::initializer_list in) : + shortFlags(EitherFlag::GetShort(in)), longFlags(EitherFlag::GetLong(in)) {} + + Matcher(Matcher &&other) : shortFlags(std::move(other.shortFlags)), longFlags(std::move(other.longFlags)) + {} + + ~Matcher() {} + + /** (INTERNAL) Check if there is a match of a short flag + */ + bool Match(const char flag) const + { + return shortFlags.find(flag) != shortFlags.end(); + } + + /** (INTERNAL) Check if there is a match of a long flag + */ + bool Match(const std::string &flag) const + { + return longFlags.find(flag) != longFlags.end(); + } + + /** (INTERNAL) Get all flag strings as a vector, with the prefixes embedded + */ + std::vector GetFlagStrings(const std::string &shortPrefix, const std::string &longPrefix) const + { + std::vector flagStrings; + flagStrings.reserve(shortFlags.size() + longFlags.size()); + for (const char flag: shortFlags) + { + flagStrings.emplace_back(shortPrefix + std::string(1, flag)); + } + for (const std::string &flag: longFlags) + { + flagStrings.emplace_back(longPrefix + flag); + } + return flagStrings; + } + + /** (INTERNAL) Get all flag strings as a vector, with the prefixes and names embedded + */ + std::vector GetFlagStrings(const std::string &shortPrefix, const std::string &longPrefix, const std::string &name, const std::string &shortSeparator, const std::string longSeparator) const + { + const std::string bracedname(std::string("[") + name + "]"); + std::vector flagStrings; + flagStrings.reserve(shortFlags.size() + longFlags.size()); + for (const char flag: shortFlags) + { + flagStrings.emplace_back(shortPrefix + std::string(1, flag) + shortSeparator + bracedname); + } + for (const std::string &flag: longFlags) + { + flagStrings.emplace_back(longPrefix + flag + longSeparator + bracedname); + } + return flagStrings; + } + }; + + enum class Options + { + /** Default options. + */ + None = 0x0, + + /** Flag can't be passed multiple times. + */ + Single = 0x01, + + /** Flag can't be omitted. + */ + Required = 0x02, + + /** Flag is excluded from help output. + */ + Hidden = 0x04, + }; + + inline Options operator | (Options lhs, Options rhs) + { + return static_cast(static_cast(lhs) | static_cast(rhs)); + } + + inline Options operator & (Options lhs, Options rhs) + { + return static_cast(static_cast(lhs) & static_cast(rhs)); + } + + /** Base class for all match types + */ + class Base + { + private: + const Options options; + + protected: + bool matched; + const std::string help; +#ifdef ARGS_NOEXCEPT + /// Only for ARGS_NOEXCEPT + Error error; +#endif + + public: + Base(const std::string &help_, Options options_ = {}) : options(options_), matched(false), help(help_) {} + virtual ~Base() {} + + Options GetOptions() const noexcept + { + return options; + } + + virtual bool Matched() const noexcept + { + return matched; + } + + virtual void Validate(const std::string &, const std::string &) + { + } + + operator bool() const noexcept + { + return Matched(); + } + + virtual std::tuple GetDescription(const std::string &, const std::string &, const std::string &, const std::string &) const + { + std::tuple description; + std::get<1>(description) = help; + return description; + } + + virtual void Reset() noexcept + { + matched = false; +#ifdef ARGS_NOEXCEPT + error = Error::None; +#endif + } + +#ifdef ARGS_NOEXCEPT + /// Only for ARGS_NOEXCEPT + virtual Error GetError() const + { + return error; + } +#endif + }; + + /** Base class for all match types that have a name + */ + class NamedBase : public Base + { + protected: + const std::string name; + bool kickout; + + public: + NamedBase(const std::string &name_, const std::string &help_, Options options_ = {}) : Base(help_, options_), name(name_), kickout(false) {} + virtual ~NamedBase() {} + + virtual std::tuple GetDescription(const std::string &, const std::string &, const std::string &, const std::string &) const override + { + std::tuple description; + std::get<0>(description) = Name(); + std::get<1>(description) = help; + return description; + } + + virtual std::string Name() const + { + return name; + } + + /// Sets a kick-out value for building subparsers + void KickOut(bool kickout_) noexcept + { + this->kickout = kickout_; + } + + /// Gets the kick-out value for building subparsers + bool KickOut() const noexcept + { + return kickout; + } + }; + + struct Nargs + { + const size_t min; + const size_t max; + + Nargs(size_t min_, size_t max_) : min(min_), max(max_) + { +#ifndef ARGS_NOEXCEPT + if (max < min) + { + throw std::invalid_argument("Nargs: max > min"); + } +#endif + } + + Nargs(size_t num_) : min(num_), max(num_) + { + } + }; + + /** Base class for all flag options + */ + class FlagBase : public NamedBase + { + protected: + const Matcher matcher; + + public: + FlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, const bool extraError_ = false) : NamedBase(name_, help_, extraError_ ? Options::Single : Options()), matcher(std::move(matcher_)) {} + + FlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) : NamedBase(name_, help_, options_), matcher(std::move(matcher_)) {} + + virtual ~FlagBase() {} + + virtual FlagBase *Match(const std::string &flag) + { + if (matcher.Match(flag)) + { + if ((GetOptions() & Options::Single) != Options::None && matched) + { +#ifdef ARGS_NOEXCEPT + error = Error::Extra; +#else + std::ostringstream problem; + problem << "Flag '" << flag << "' was passed multiple times, but is only allowed to be passed once"; + throw ExtraError(problem.str()); +#endif + } + matched = true; + return this; + } + return nullptr; + } + + virtual void Validate(const std::string &shortPrefix, const std::string &longPrefix) override + { + if (!Matched() && (GetOptions() & Options::Required) != Options::None) + { +#ifdef ARGS_NOEXCEPT + error = Error::Required; +#else + std::ostringstream problem; + problem << "Flag '" << matcher.GetFlagStrings(shortPrefix, longPrefix).at(0) << "' is required"; + throw RequiredError(problem.str()); +#endif + } + } + + virtual FlagBase *Match(const char flag) + { + if (matcher.Match(flag)) + { + if ((GetOptions() & Options::Single) != Options::None && matched) + { +#ifdef ARGS_NOEXCEPT + error = Error::Extra; +#else + std::ostringstream problem; + problem << "Flag '" << flag << "' was passed multiple times, but is only allowed to be passed once"; + throw ExtraError(problem.str()); +#endif + } + matched = true; + return this; + } + return nullptr; + } + + virtual std::tuple GetDescription(const std::string &shortPrefix, const std::string &longPrefix, const std::string &, const std::string &) const override + { + std::tuple description; + const auto flagStrings = matcher.GetFlagStrings(shortPrefix, longPrefix); + std::ostringstream flagstream; + for (auto it = std::begin(flagStrings); it != std::end(flagStrings); ++it) + { + if (it != std::begin(flagStrings)) + { + flagstream << ", "; + } + flagstream << *it; + } + std::get<0>(description) = flagstream.str(); + std::get<1>(description) = help; + return description; + } + + /** Defines how many values can be consumed by this option. + * + * \return closed interval [min, max] + */ + virtual Nargs NumberOfArguments() const noexcept = 0; + + /** Parse values of this option. + * + * \param value Vector of values. It's size must be in NumberOfArguments() interval. + */ + virtual void ParseValue(const std::vector &value) = 0; + }; + + /** Base class for value-accepting flag options + */ + class ValueFlagBase : public FlagBase + { + public: + ValueFlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, const bool extraError_ = false) : FlagBase(name_, help_, std::move(matcher_), extraError_) {} + ValueFlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) : FlagBase(name_, help_, std::move(matcher_), options_) {} + virtual ~ValueFlagBase() {} + + virtual std::tuple GetDescription(const std::string &shortPrefix, const std::string &longPrefix, const std::string &shortSeparator, const std::string &longSeparator) const override + { + std::tuple description; + const auto flagStrings = matcher.GetFlagStrings(shortPrefix, longPrefix, Name(), shortSeparator, longSeparator); + std::ostringstream flagstream; + for (auto it = std::begin(flagStrings); it != std::end(flagStrings); ++it) + { + if (it != std::begin(flagStrings)) + { + flagstream << ", "; + } + flagstream << *it; + } + std::get<0>(description) = flagstream.str(); + std::get<1>(description) = help; + return description; + } + + virtual Nargs NumberOfArguments() const noexcept override + { + return 1; + } + }; + + /** Base class for positional options + */ + class PositionalBase : public NamedBase + { + protected: + bool ready; + + public: + PositionalBase(const std::string &name_, const std::string &help_, Options options_ = Options::None) : NamedBase(name_, help_, options_), ready(true) {} + virtual ~PositionalBase() {} + + bool Ready() + { + return ready; + } + + virtual void ParseValue(const std::string &value_) = 0; + + virtual void Reset() noexcept override + { + matched = false; + ready = true; +#ifdef ARGS_NOEXCEPT + error = Error::None; +#endif + } + + virtual void Validate(const std::string &, const std::string &) override + { + if ((GetOptions() & Options::Required) != Options::None && !Matched()) + { +#ifdef ARGS_NOEXCEPT + error = Error::Required; +#else + std::ostringstream problem; + problem << "Option '" << Name() << "' is required"; + throw RequiredError(problem.str()); +#endif + } + } + }; + + /** Class for all kinds of validating groups, including ArgumentParser + */ + class Group : public Base + { + private: + std::vector children; + std::function validator; + + public: + /** Default validators + */ + struct Validators + { + static bool Xor(const Group &group) + { + return group.MatchedChildren() == 1; + } + + static bool AtLeastOne(const Group &group) + { + return group.MatchedChildren() >= 1; + } + + static bool AtMostOne(const Group &group) + { + return group.MatchedChildren() <= 1; + } + + static bool All(const Group &group) + { + return group.Children().size() == group.MatchedChildren(); + } + + static bool AllOrNone(const Group &group) + { + return (All(group) || None(group)); + } + + static bool AllChildGroups(const Group &group) + { + return std::find_if(std::begin(group.Children()), std::end(group.Children()), [](const Base* child) -> bool { + return dynamic_cast(child) && !child->Matched(); + }) == std::end(group.Children()); + } + + static bool DontCare(const Group &) + { + return true; + } + + static bool CareTooMuch(const Group &) + { + return false; + } + + static bool None(const Group &group) + { + return group.MatchedChildren() == 0; + } + }; + /// If help is empty, this group will not be printed in help output + Group(const std::string &help_ = std::string(), const std::function &validator_ = Validators::DontCare) : Base(help_), validator(validator_) {} + /// If help is empty, this group will not be printed in help output + Group(Group &group_, const std::string &help_ = std::string(), const std::function &validator_ = Validators::DontCare) : Base(help_), validator(validator_) + { + group_.Add(*this); + } + virtual ~Group() {} + + /** Return the first FlagBase that matches flag, or nullptr + * + * \param flag The flag with prefixes stripped + * \return the first matching FlagBase pointer, or nullptr if there is no match + */ + template + FlagBase *Match(const T &flag) + { + for (Base *child: children) + { + if (FlagBase *flagBase = dynamic_cast(child)) + { + if (FlagBase *match = flagBase->Match(flag)) + { + return match; + } + } else if (Group *group = dynamic_cast(child)) + { + if (FlagBase *match = group->Match(flag)) + { + return match; + } + } + } + return nullptr; + } + + virtual void Validate(const std::string &shortPrefix, const std::string &longPrefix) override + { + for (Base *child: children) + { + child->Validate(shortPrefix, longPrefix); + } + } + + /** Get the next ready positional, or nullptr if there is none + * + * \return the first ready PositionalBase pointer, or nullptr if there is no match + */ + PositionalBase *GetNextPositional() + { + for (Base *child: children) + { + auto next = dynamic_cast(child); + auto group = dynamic_cast(child); + if (group) + { + next = group->GetNextPositional(); + } + if (next && next->Ready()) + { + return next; + } + } + return nullptr; + } + + /** Get whether this has any FlagBase children + * + * \return Whether or not there are any FlagBase children + */ + bool HasFlag() const + { + for (Base *child: children) + { + if (dynamic_cast(child)) + { + return true; + } + if (auto group = dynamic_cast(child)) + { + if (group->HasFlag()) + { + return true; + } + } + } + return false; + } + + /** Append a child to this Group. + */ + void Add(Base &child) + { + children.emplace_back(&child); + } + + /** Get all this group's children + */ + const std::vector &Children() const + { + return children; + } + + /** Count the number of matched children this group has + */ + std::vector::size_type MatchedChildren() const + { + return std::count_if(std::begin(children), std::end(children), [](const Base *child){return child->Matched();}); + } + + /** Whether or not this group matches validation + */ + virtual bool Matched() const noexcept override + { + return validator(*this); + } + + /** Get validation + */ + bool Get() const + { + return Matched(); + } + + /** Get all the child descriptions for help generation + */ + std::vector> GetChildDescriptions(const std::string &shortPrefix, const std::string &longPrefix, const std::string &shortSeparator, const std::string &longSeparator, const unsigned int indent = 0) const + { + std::vector> descriptions; + for (const auto &child: children) + { + if ((child->GetOptions() & Options::Hidden) != Options::None) + { + continue; + } + + if (const auto group = dynamic_cast(child)) + { + // Push that group description on the back if not empty + unsigned char addindent = 0; + if (!group->help.empty()) + { + descriptions.emplace_back(group->help, "", indent); + addindent = 1; + } + auto groupDescriptions = group->GetChildDescriptions(shortPrefix, longPrefix, shortSeparator, longSeparator, indent + addindent); + descriptions.insert( + std::end(descriptions), + std::make_move_iterator(std::begin(groupDescriptions)), + std::make_move_iterator(std::end(groupDescriptions))); + } else if (const auto named = dynamic_cast(child)) + { + const auto description = named->GetDescription(shortPrefix, longPrefix, shortSeparator, longSeparator); + descriptions.emplace_back(std::get<0>(description), std::get<1>(description), indent); + } + } + return descriptions; + } + + /** Get the names of positional parameters + */ + std::vector GetPosNames() const + { + std::vector names; + for (const auto &child: children) + { + if (const Group *group = dynamic_cast(child)) + { + auto groupNames = group->GetPosNames(); + names.insert( + std::end(names), + std::make_move_iterator(std::begin(groupNames)), + std::make_move_iterator(std::end(groupNames))); + } else if (const PositionalBase *pos = dynamic_cast(child)) + { + names.emplace_back(pos->Name()); + } + } + return names; + } + + virtual void Reset() noexcept override + { + for (auto &child: children) + { + child->Reset(); + } +#ifdef ARGS_NOEXCEPT + error = Error::None; +#endif + } + +#ifdef ARGS_NOEXCEPT + /// Only for ARGS_NOEXCEPT + virtual Error GetError() const override + { + if (error != Error::None) + { + return error; + } + + auto it = std::find_if(std::begin(children), std::end(children), [](const Base *child){return child->GetError() != Error::None;}); + if (it == std::end(children)) + { + return Error::None; + } else + { + return (*it)->GetError(); + } + } +#endif + + }; + + /** The main user facing command line argument parser class + */ + class ArgumentParser : public Group + { + private: + std::string prog; + std::string proglinePostfix; + std::string description; + std::string epilog; + + std::string longprefix; + std::string shortprefix; + + std::string longseparator; + + std::string terminator; + + bool allowJoinedShortValue; + bool allowJoinedLongValue; + bool allowSeparateShortValue; + bool allowSeparateLongValue; + + protected: + bool RaiseParseError(const std::string &message) + { +#ifdef ARGS_NOEXCEPT + (void)message; + error = Error::Parse; + return false; +#else + throw ParseError(message); +#endif + } + + enum class OptionType + { + LongFlag, + ShortFlag, + Positional + }; + + OptionType ParseOption(const std::string &s) + { + if (s.find(longprefix) == 0 && s.length() > longprefix.length()) + { + return OptionType::LongFlag; + } + + if (s.find(shortprefix) == 0 && s.length() > shortprefix.length()) + { + return OptionType::ShortFlag; + } + + return OptionType::Positional; + } + + /** (INTERNAL) Parse flag's values + * + * \param arg The string to display in error message as a flag name + * \param[in, out] it The iterator to first value. It will point to the last value + * \param end The end iterator + * \param joinedArg Joined value (e.g. bar in --foo=bar) + * \param canDiscardJoined If true joined value can be parsed as flag not as a value (as in -abcd) + * \param[out] values The vector to store parsed arg's values + */ + template + bool ParseArgsValues(FlagBase &flag, const std::string &arg, It &it, It end, + const bool allowSeparate, const bool allowJoined, + const bool hasJoined, const std::string &joinedArg, + const bool canDiscardJoined, std::vector &values) + { + values.clear(); + + Nargs nargs = flag.NumberOfArguments(); + + if (hasJoined && !allowJoined && nargs.min != 0) + { + return RaiseParseError("Flag '" + arg + "' was passed a joined argument, but these are disallowed"); + } + + if (hasJoined) + { + if (!canDiscardJoined || nargs.max != 0) + { + values.push_back(joinedArg); + } + } else if (!allowSeparate) + { + if (nargs.min != 0) + { + return RaiseParseError("Flag '" + arg + "' was passed a separate argument, but these are disallowed"); + } + } else + { + auto valueIt = it; + ++valueIt; + + while (valueIt != end && + values.size() < nargs.max && + (nargs.min == nargs.max || ParseOption(*valueIt) == OptionType::Positional)) + { + + values.push_back(*valueIt); + ++it; + ++valueIt; + } + } + + if (values.size() > nargs.max) + { + return RaiseParseError("Passed an argument into a non-argument flag: " + arg); + } else if (values.size() < nargs.min) + { + if (nargs.min == 1 && nargs.max == 1) + { + return RaiseParseError("Flag '" + arg + "' requires an argument but received none"); + } else if (nargs.min == 1) + { + return RaiseParseError("Flag '" + arg + "' requires at least one argument but received none"); + } else if (nargs.min != nargs.max) + { + return RaiseParseError("Flag '" + arg + "' requires at least " + std::to_string(nargs.min) + + " arguments but received " + std::to_string(values.size())); + } else + { + return RaiseParseError("Flag '" + arg + "' requires " + std::to_string(nargs.min) + + " arguments but received " + std::to_string(values.size())); + } + } + + return true; + } + + template + bool ParseLong(It &it, It end) + { + const auto &chunk = *it; + const auto argchunk = chunk.substr(longprefix.size()); + // Try to separate it, in case of a separator: + const auto separator = longseparator.empty() ? argchunk.npos : argchunk.find(longseparator); + // If the separator is in the argument, separate it. + const auto arg = (separator != argchunk.npos ? + std::string(argchunk, 0, separator) + : argchunk); + const auto joined = (separator != argchunk.npos ? + argchunk.substr(separator + longseparator.size()) + : std::string()); + + if (auto flag = Match(arg)) + { + std::vector values; + if (!ParseArgsValues(*flag, arg, it, end, allowSeparateLongValue, allowJoinedLongValue, + separator != argchunk.npos, joined, false, values)) + { + return false; + } + + flag->ParseValue(values); + + if (flag->KickOut()) + { + ++it; + return false; + } + } else + { + return RaiseParseError("Flag could not be matched: " + arg); + } + + return true; + } + + template + bool ParseShort(It &it, It end) + { + const auto &chunk = *it; + const auto argchunk = chunk.substr(shortprefix.size()); + for (auto argit = std::begin(argchunk); argit != std::end(argchunk); ++argit) + { + const auto arg = *argit; + + if (auto flag = Match(arg)) + { + const std::string value(argit + 1, std::end(argchunk)); + std::vector values; + if (!ParseArgsValues(*flag, std::string(1, arg), it, end, + allowSeparateShortValue, allowJoinedShortValue, + !value.empty(), value, !value.empty(), values)) + { + return false; + } + + flag->ParseValue(values); + + if (flag->KickOut()) + { + ++it; + return false; + } + + if (!values.empty()) + { + break; + } + } else + { + return RaiseParseError("Flag could not be matched: '" + std::string(1, arg) + "'"); + } + } + + return true; + } + + public: + /** A simple structure of parameters for easy user-modifyable help menus + */ + struct HelpParams + { + /** The width of the help menu + */ + unsigned int width = 80; + /** The indent of the program line + */ + unsigned int progindent = 2; + /** The indent of the program trailing lines for long parameters + */ + unsigned int progtailindent = 4; + /** The indent of the description and epilogs + */ + unsigned int descriptionindent = 4; + /** The indent of the flags + */ + unsigned int flagindent = 6; + /** The indent of the flag descriptions + */ + unsigned int helpindent = 40; + /** The additional indent each group adds + */ + unsigned int eachgroupindent = 2; + + /** The minimum gutter between each flag and its help + */ + unsigned int gutter = 1; + + /** Show the terminator when both options and positional parameters are present + */ + bool showTerminator = true; + + /** Show the {OPTIONS} on the prog line when this is true + */ + bool showProglineOptions = true; + + /** Show the positionals on the prog line when this is true + */ + bool showProglinePositionals = true; + } helpParams; + ArgumentParser(const std::string &description_, const std::string &epilog_ = std::string()) : + Group("", Group::Validators::AllChildGroups), + description(description_), + epilog(epilog_), + longprefix("--"), + shortprefix("-"), + longseparator("="), + terminator("--"), + allowJoinedShortValue(true), + allowJoinedLongValue(true), + allowSeparateShortValue(true), + allowSeparateLongValue(true) {} + + /** The program name for help generation + */ + const std::string &Prog() const + { return prog; } + /** The program name for help generation + */ + void Prog(const std::string &prog_) + { this->prog = prog_; } + + /** The description that appears on the prog line after options + */ + const std::string &ProglinePostfix() const + { return proglinePostfix; } + /** The description that appears on the prog line after options + */ + void ProglinePostfix(const std::string &proglinePostfix_) + { this->proglinePostfix = proglinePostfix_; } + + /** The description that appears above options + */ + const std::string &Description() const + { return description; } + /** The description that appears above options + */ + void Description(const std::string &description_) + { this->description = description_; } + + /** The description that appears below options + */ + const std::string &Epilog() const + { return epilog; } + /** The description that appears below options + */ + void Epilog(const std::string &epilog_) + { this->epilog = epilog_; } + + /** The prefix for long flags + */ + const std::string &LongPrefix() const + { return longprefix; } + /** The prefix for long flags + */ + void LongPrefix(const std::string &longprefix_) + { this->longprefix = longprefix_; } + + /** The prefix for short flags + */ + const std::string &ShortPrefix() const + { return shortprefix; } + /** The prefix for short flags + */ + void ShortPrefix(const std::string &shortprefix_) + { this->shortprefix = shortprefix_; } + + /** The separator for long flags + */ + const std::string &LongSeparator() const + { return longseparator; } + /** The separator for long flags + */ + void LongSeparator(const std::string &longseparator_) + { + if (longseparator_.empty()) + { +#ifdef ARGS_NOEXCEPT + error = Error::Usage; +#else + throw UsageError("longseparator can not be set to empty"); +#endif + } else + { + this->longseparator = longseparator_; + } + } + + /** The terminator that forcibly separates flags from positionals + */ + const std::string &Terminator() const + { return terminator; } + /** The terminator that forcibly separates flags from positionals + */ + void Terminator(const std::string &terminator_) + { this->terminator = terminator_; } + + /** Get the current argument separation parameters. + * + * See SetArgumentSeparations for details on what each one means. + */ + void GetArgumentSeparations( + bool &allowJoinedShortValue_, + bool &allowJoinedLongValue_, + bool &allowSeparateShortValue_, + bool &allowSeparateLongValue_) const + { + allowJoinedShortValue_ = this->allowJoinedShortValue; + allowJoinedLongValue_ = this->allowJoinedLongValue; + allowSeparateShortValue_ = this->allowSeparateShortValue; + allowSeparateLongValue_ = this->allowSeparateLongValue; + } + + /** Change allowed option separation. + * + * \param allowJoinedShortValue Allow a short flag that accepts an argument to be passed its argument immediately next to it (ie. in the same argv field) + * \param allowJoinedLongValue Allow a long flag that accepts an argument to be passed its argument separated by the longseparator (ie. in the same argv field) + * \param allowSeparateShortValue Allow a short flag that accepts an argument to be passed its argument separated by whitespace (ie. in the next argv field) + * \param allowSeparateLongValue Allow a long flag that accepts an argument to be passed its argument separated by whitespace (ie. in the next argv field) + */ + void SetArgumentSeparations( + const bool allowJoinedShortValue_, + const bool allowJoinedLongValue_, + const bool allowSeparateShortValue_, + const bool allowSeparateLongValue_) + { + this->allowJoinedShortValue = allowJoinedShortValue_; + this->allowJoinedLongValue = allowJoinedLongValue_; + this->allowSeparateShortValue = allowSeparateShortValue_; + this->allowSeparateLongValue = allowSeparateLongValue_; + } + + /** Pass the help menu into an ostream + */ + void Help(std::ostream &help_) const + { + bool hasoptions = false; + bool hasarguments = false; + + const auto description_text = Wrap(this->description, helpParams.width - helpParams.descriptionindent); + const auto epilog_text = Wrap(this->epilog, helpParams.width - helpParams.descriptionindent); + std::ostringstream prognameline; + prognameline << prog; + if (HasFlag()) + { + hasoptions = true; + if (helpParams.showProglineOptions) + { + prognameline << " {OPTIONS}"; + } + } + for (const std::string &posname: GetPosNames()) + { + hasarguments = true; + if (helpParams.showProglinePositionals) + { + prognameline << " [" << posname << ']'; + } + } + if (!proglinePostfix.empty()) + { + prognameline << ' ' << proglinePostfix; + } + const auto proglines = Wrap(prognameline.str(), helpParams.width - (helpParams.progindent + 4), helpParams.width - helpParams.progindent); + auto progit = std::begin(proglines); + if (progit != std::end(proglines)) + { + help_ << std::string(helpParams.progindent, ' ') << *progit << '\n'; + ++progit; + } + for (; progit != std::end(proglines); ++progit) + { + help_ << std::string(helpParams.progtailindent, ' ') << *progit << '\n'; + } + + help_ << '\n'; + + for (const auto &line: description_text) + { + help_ << std::string(helpParams.descriptionindent, ' ') << line << "\n"; + } + help_ << "\n"; + help_ << std::string(helpParams.progindent, ' ') << "OPTIONS:\n\n"; + for (const auto &desc: GetChildDescriptions(shortprefix, longprefix, allowJoinedShortValue ? "" : " ", allowJoinedLongValue ? longseparator : " ")) + { + const auto groupindent = std::get<2>(desc) * helpParams.eachgroupindent; + const auto flags = Wrap(std::get<0>(desc), helpParams.width - (helpParams.flagindent + helpParams.helpindent + helpParams.gutter)); + const auto info = Wrap(std::get<1>(desc), helpParams.width - (helpParams.helpindent + groupindent)); + + std::string::size_type flagssize = 0; + for (auto flagsit = std::begin(flags); flagsit != std::end(flags); ++flagsit) + { + if (flagsit != std::begin(flags)) + { + help_ << '\n'; + } + help_ << std::string(groupindent + helpParams.flagindent, ' ') << *flagsit; + flagssize = Glyphs(*flagsit); + } + + auto infoit = std::begin(info); + // groupindent is on both sides of this inequality, and therefore can be removed + if ((helpParams.flagindent + flagssize + helpParams.gutter) > helpParams.helpindent || infoit == std::end(info)) + { + help_ << '\n'; + } else + { + // groupindent is on both sides of the minus sign, and therefore doesn't actually need to be in here + help_ << std::string(helpParams.helpindent - (helpParams.flagindent + flagssize), ' ') << *infoit << '\n'; + ++infoit; + } + for (; infoit != std::end(info); ++infoit) + { + help_ << std::string(groupindent + helpParams.helpindent, ' ') << *infoit << '\n'; + } + } + if (hasoptions && hasarguments && helpParams.showTerminator) + { + for (const auto &item: Wrap(std::string("\"") + terminator + "\" can be used to terminate flag options and force all following arguments to be treated as positional options", helpParams.width - helpParams.flagindent)) + { + help_ << std::string(helpParams.flagindent, ' ') << item << '\n'; + } + } + + help_ << "\n"; + for (const auto &line: epilog_text) + { + help_ << std::string(helpParams.descriptionindent, ' ') << line << "\n"; + } + } + + /** Generate a help menu as a string. + * + * \return the help text as a single string + */ + std::string Help() const + { + std::ostringstream help_; + Help(help_); + return help_.str(); + } + + /** Parse all arguments. + * + * \param begin an iterator to the beginning of the argument list + * \param end an iterator to the past-the-end element of the argument list + * \return the iterator after the last parsed value. Only useful for kick-out + */ + template + It ParseArgs(It begin, It end) + { + // Reset all Matched statuses and errors + Reset(); + bool terminated = false; + + // Check all arg chunks + for (auto it = begin; it != end; ++it) + { + const auto &chunk = *it; + + if (!terminated && chunk == terminator) + { + terminated = true; + } else if (!terminated && ParseOption(chunk) == OptionType::LongFlag) + { + if (!ParseLong(it, end)) + { + return it; + } + } else if (!terminated && ParseOption(chunk) == OptionType::ShortFlag) + { + if (!ParseShort(it, end)) + { + return it; + } + } else + { + auto pos = GetNextPositional(); + if (pos) + { + pos->ParseValue(chunk); + + if (pos->KickOut()) + { + return ++it; + } + } else + { + RaiseParseError("Passed in argument, but no positional arguments were ready to receive it: " + chunk); + return it; + } + } + } + + for (Base *child: Children()) + { + child->Validate(shortprefix, longprefix); + } + + if (!Matched()) + { +#ifdef ARGS_NOEXCEPT + error = Error::Validation; +#else + std::ostringstream problem; + problem << "Group validation failed somewhere!"; + throw ValidationError(problem.str()); +#endif + } + + return end; + } + + /** Parse all arguments. + * + * \param args an iterable of the arguments + * \return the iterator after the last parsed value. Only useful for kick-out + */ + template + auto ParseArgs(const T &args) -> decltype(std::begin(args)) + { + return ParseArgs(std::begin(args), std::end(args)); + } + + /** Convenience function to parse the CLI from argc and argv + * + * Just assigns the program name and vectorizes arguments for passing into ParseArgs() + * + * \return whether or not all arguments were parsed. This works for detecting kick-out, but is generally useless as it can't do anything with it. + */ + bool ParseCLI(const int argc, const char * const * argv) + { + if (prog.empty()) + { + prog.assign(argv[0]); + } + const std::vector args(argv + 1, argv + argc); + return ParseArgs(args) == std::end(args); + } + }; + + inline std::ostream &operator<<(std::ostream &os, const ArgumentParser &parser) + { + parser.Help(os); + return os; + } + + /** Boolean argument matcher + */ + class Flag : public FlagBase + { + public: + Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): FlagBase(name_, help_, std::move(matcher_), options_) + { + group_.Add(*this); + } + + Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const bool extraError_ = false): Flag(group_, name_, help_, std::move(matcher_), extraError_ ? Options::Single : Options::None) + { + } + + virtual ~Flag() {} + + /** Get whether this was matched + */ + bool Get() const + { + return Matched(); + } + + virtual Nargs NumberOfArguments() const noexcept override + { + return 0; + } + + virtual void ParseValue(const std::vector&) override + { + } + }; + + /** Help flag class + * + * Works like a regular flag, but throws an instance of Help when it is matched + */ + class HelpFlag : public Flag + { + public: + HelpFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_): Flag(group_, name_, help_, std::move(matcher_)) {} + + virtual ~HelpFlag() {} + + virtual FlagBase *Match(const std::string &arg) override + { + if (FlagBase::Match(arg)) + { +#ifdef ARGS_NOEXCEPT + error = Error::Help; + return this; +#else + throw Help(arg); +#endif + } + return nullptr; + } + + virtual FlagBase *Match(const char arg) override + { + if (FlagBase::Match(arg)) + { +#ifdef ARGS_NOEXCEPT + error = Error::Help; + return this; +#else + throw Help(std::string(1, arg)); +#endif + } + return nullptr; + } + + /** Get whether this was matched + */ + bool Get() const noexcept + { + return Matched(); + } + }; + + /** A flag class that simply counts the number of times it's matched + */ + class CounterFlag : public Flag + { + private: + const int startcount; + int count; + + public: + CounterFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const int startcount_ = 0): Flag(group_, name_, help_, std::move(matcher_)), startcount(startcount_), count(startcount_) {} + + virtual ~CounterFlag() {} + + virtual FlagBase *Match(const std::string &arg) override + { + auto me = FlagBase::Match(arg); + if (me) + { + ++count; + } + return me; + } + + virtual FlagBase *Match(const char arg) override + { + auto me = FlagBase::Match(arg); + if (me) + { + ++count; + } + return me; + } + + /** Get the count + */ + int &Get() noexcept + { + return count; + } + + virtual void Reset() noexcept override + { + FlagBase::Reset(); + count = startcount; + } + }; + + /** A default Reader class for argument classes + * + * Simply uses a std::istringstream to read into the destination type, and + * raises a ParseError if there are any characters left. + */ + template + struct ValueReader + { + bool operator ()(const std::string &name, const std::string &value, T &destination) + { + std::istringstream ss(value); + ss >> destination; + + if (ss.rdbuf()->in_avail() > 0) + { +#ifdef ARGS_NOEXCEPT + return false; +#else + std::ostringstream problem; + problem << "Argument '" << name << "' received invalid value type '" << value << "'"; + throw ParseError(problem.str()); +#endif + } + return true; + } + }; + + /** std::string specialization for ValueReader + * + * By default, stream extraction into a string splits on white spaces, and + * it is more efficient to ust copy a string into the destination. + */ + template <> + struct ValueReader + { + bool operator()(const std::string &, const std::string &value, std::string &destination) + { + destination.assign(value); + return true; + } + }; + + /** An argument-accepting flag class + * + * \tparam T the type to extract the argument as + * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined) + */ + template < + typename T, + typename Reader = ValueReader> + class ValueFlag : public ValueFlagBase + { + protected: + T value; + + private: + Reader reader; + + public: + + ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), value(defaultValue_) + { + group_.Add(*this); + } + + ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), const bool extraError_ = false): ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, extraError_ ? Options::Single : Options::None) + { + } + + ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): ValueFlag(group_, name_, help_, std::move(matcher_), T(), options_) + { + } + + virtual ~ValueFlag() {} + + virtual void ParseValue(const std::vector &values_) override + { + const std::string &value_ = values_.at(0); + +#ifdef ARGS_NOEXCEPT + if (!reader(name, value_, this->value)) + { + error = Error::Parse; + } +#else + reader(name, value_, this->value); +#endif + } + + /** Get the value + */ + T &Get() noexcept + { + return value; + } + }; + + /** An optional argument-accepting flag class + * + * \tparam T the type to extract the argument as + * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined) + */ + template < + typename T, + typename Reader = ValueReader> + class ImplicitValueFlag : public ValueFlag + { + protected: + + T implicitValue; + T defaultValue; + + public: + + ImplicitValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &implicitValue_, const T &defaultValue_ = T(), Options options_ = {}) + : ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, options_), implicitValue(implicitValue_), defaultValue(defaultValue_) + { + } + + ImplicitValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), Options options_ = {}) + : ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, options_), implicitValue(defaultValue_), defaultValue(defaultValue_) + { + } + + ImplicitValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) + : ValueFlag(group_, name_, help_, std::move(matcher_), {}, options_), implicitValue(), defaultValue() + { + } + + virtual ~ImplicitValueFlag() {} + + virtual Nargs NumberOfArguments() const noexcept override + { + return {0, 1}; + } + + virtual void ParseValue(const std::vector &value_) override + { + if (value_.empty()) + { + this->value = implicitValue; + } else + { + ValueFlag::ParseValue(value_); + } + } + + virtual void Reset() noexcept override + { + this->value = defaultValue; + ValueFlag::Reset(); + } + }; + + /** A variadic arguments accepting flag class + * + * \tparam T the type to extract the argument as + * \tparam List the list type that houses the values + * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined) + */ + template < + typename T, + template class List = std::vector, + typename Reader = ValueReader> + class NargsValueFlag : public FlagBase + { + protected: + + List values; + Nargs nargs; + Reader reader; + + public: + + typedef List Container; + typedef T value_type; + typedef typename Container::allocator_type allocator_type; + typedef typename Container::pointer pointer; + typedef typename Container::const_pointer const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef typename Container::size_type size_type; + typedef typename Container::difference_type difference_type; + typedef typename Container::iterator iterator; + typedef typename Container::const_iterator const_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + NargsValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Nargs nargs_, const List &defaultValues_ = {}, Options options_ = {}) + : FlagBase(name_, help_, std::move(matcher_), options_), values(defaultValues_), nargs(nargs_) + { + group_.Add(*this); + } + + virtual ~NargsValueFlag() {} + + virtual Nargs NumberOfArguments() const noexcept override + { + return nargs; + } + + virtual void ParseValue(const std::vector &values_) override + { + values.clear(); + + for (const std::string &value : values_) + { + T v; +#ifdef ARGS_NOEXCEPT + if (!reader(name, value, v)) + { + error = Error::Parse; + } +#else + reader(name, value, v); +#endif + values.insert(std::end(values), v); + } + } + + List &Get() noexcept + { + return values; + } + + iterator begin() noexcept + { + return values.begin(); + } + + const_iterator begin() const noexcept + { + return values.begin(); + } + + const_iterator cbegin() const noexcept + { + return values.cbegin(); + } + + iterator end() noexcept + { + return values.end(); + } + + const_iterator end() const noexcept + { + return values.end(); + } + + const_iterator cend() const noexcept + { + return values.cend(); + } + }; + + /** An argument-accepting flag class that pushes the found values into a list + * + * \tparam T the type to extract the argument as + * \tparam List the list type that houses the values + * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined) + */ + template < + typename T, + template class List = std::vector, + typename Reader = ValueReader> + class ValueFlagList : public ValueFlagBase + { + private: + using Container = List; + Container values; + Reader reader; + + public: + + typedef T value_type; + typedef typename Container::allocator_type allocator_type; + typedef typename Container::pointer pointer; + typedef typename Container::const_pointer const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef typename Container::size_type size_type; + typedef typename Container::difference_type difference_type; + typedef typename Container::iterator iterator; + typedef typename Container::const_iterator const_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + ValueFlagList(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Container &defaultValues_ = Container()): ValueFlagBase(name_, help_, std::move(matcher_)), values(defaultValues_) + { + group_.Add(*this); + } + + virtual ~ValueFlagList() {} + + virtual void ParseValue(const std::vector &values_) override + { + const std::string &value_ = values_.at(0); + + T v; +#ifdef ARGS_NOEXCEPT + if (!reader(name, value_, v)) + { + error = Error::Parse; + } +#else + reader(name, value_, v); +#endif + values.insert(std::end(values), v); + } + + /** Get the values + */ + Container &Get() noexcept + { + return values; + } + + virtual std::string Name() const override + { + return name + std::string("..."); + } + + virtual void Reset() noexcept override + { + ValueFlagBase::Reset(); + values.clear(); + } + + iterator begin() noexcept + { + return values.begin(); + } + + const_iterator begin() const noexcept + { + return values.begin(); + } + + const_iterator cbegin() const noexcept + { + return values.cbegin(); + } + + iterator end() noexcept + { + return values.end(); + } + + const_iterator end() const noexcept + { + return values.end(); + } + + const_iterator cend() const noexcept + { + return values.cend(); + } + }; + + /** A mapping value flag class + * + * \tparam K the type to extract the argument as + * \tparam T the type to store the result as + * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined) + * \tparam Map The Map type. Should operate like std::map or std::unordered_map + */ + template < + typename K, + typename T, + typename Reader = ValueReader, + template class Map = std::unordered_map> + class MapFlag : public ValueFlagBase + { + private: + const Map map; + T value; + Reader reader; + + public: + + MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map &map_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), map(map_), value(defaultValue_) + { + group_.Add(*this); + } + + MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map &map_, const T &defaultValue_ = T(), const bool extraError_ = false): MapFlag(group_, name_, help_, std::move(matcher_), map_, defaultValue_, extraError_ ? Options::Single : Options::None) + { + } + + MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map &map_, Options options_): MapFlag(group_, name_, help_, std::move(matcher_), map_, T(), options_) + { + } + + virtual ~MapFlag() {} + + virtual void ParseValue(const std::vector &values_) override + { + const std::string &value_ = values_.at(0); + + K key; +#ifdef ARGS_NOEXCEPT + if (!reader(name, value_, key)) + { + error = Error::Parse; + } +#else + reader(name, value_, key); +#endif + auto it = map.find(key); + if (it == std::end(map)) + { +#ifdef ARGS_NOEXCEPT + error = Error::Map; +#else + std::ostringstream problem; + problem << "Could not find key '" << key << "' in map for arg '" << name << "'"; + throw MapError(problem.str()); +#endif + } else + { + this->value = it->second; + } + } + + /** Get the value + */ + T &Get() noexcept + { + return value; + } + }; + + /** A mapping value flag list class + * + * \tparam K the type to extract the argument as + * \tparam T the type to store the result as + * \tparam List the list type that houses the values + * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined) + * \tparam Map The Map type. Should operate like std::map or std::unordered_map + */ + template < + typename K, + typename T, + template class List = std::vector, + typename Reader = ValueReader, + template class Map = std::unordered_map> + class MapFlagList : public ValueFlagBase + { + private: + using Container = List; + const Map map; + Container values; + Reader reader; + + public: + typedef T value_type; + typedef typename Container::allocator_type allocator_type; + typedef typename Container::pointer pointer; + typedef typename Container::const_pointer const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef typename Container::size_type size_type; + typedef typename Container::difference_type difference_type; + typedef typename Container::iterator iterator; + typedef typename Container::const_iterator const_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + MapFlagList(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map &map_, const Container &defaultValues_ = Container()): ValueFlagBase(name_, help_, std::move(matcher_)), map(map_), values(defaultValues_) + { + group_.Add(*this); + } + + virtual ~MapFlagList() {} + + virtual void ParseValue(const std::vector &values_) override + { + const std::string &value = values_.at(0); + + K key; +#ifdef ARGS_NOEXCEPT + if (!reader(name, value, key)) + { + error = Error::Parse; + } +#else + reader(name, value, key); +#endif + auto it = map.find(key); + if (it == std::end(map)) + { +#ifdef ARGS_NOEXCEPT + error = Error::Map; +#else + std::ostringstream problem; + problem << "Could not find key '" << key << "' in map for arg '" << name << "'"; + throw MapError(problem.str()); +#endif + } else + { + this->values.emplace_back(it->second); + } + } + + /** Get the value + */ + Container &Get() noexcept + { + return values; + } + + virtual std::string Name() const override + { + return name + std::string("..."); + } + + virtual void Reset() noexcept override + { + ValueFlagBase::Reset(); + values.clear(); + } + + iterator begin() noexcept + { + return values.begin(); + } + + const_iterator begin() const noexcept + { + return values.begin(); + } + + const_iterator cbegin() const noexcept + { + return values.cbegin(); + } + + iterator end() noexcept + { + return values.end(); + } + + const_iterator end() const noexcept + { + return values.end(); + } + + const_iterator cend() const noexcept + { + return values.cend(); + } + }; + + /** A positional argument class + * + * \tparam T the type to extract the argument as + * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined) + */ + template < + typename T, + typename Reader = ValueReader> + class Positional : public PositionalBase + { + private: + T value; + Reader reader; + public: + Positional(Group &group_, const std::string &name_, const std::string &help_, const T &defaultValue_ = T(), Options options_ = Options::None): PositionalBase(name_, help_, options_), value(defaultValue_) + { + group_.Add(*this); + } + + Positional(Group &group_, const std::string &name_, const std::string &help_, Options options_): Positional(group_, name_, help_, T(), options_) + { + } + + virtual ~Positional() {} + + virtual void ParseValue(const std::string &value_) override + { +#ifdef ARGS_NOEXCEPT + if (!reader(name, value_, this->value)) + { + error = Error::Parse; + } +#else + reader(name, value_, this->value); +#endif + ready = false; + matched = true; + } + + /** Get the value + */ + T &Get() noexcept + { + return value; + } + }; + + /** A positional argument class that pushes the found values into a list + * + * \tparam T the type to extract the argument as + * \tparam List the list type that houses the values + * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined) + */ + template < + typename T, + template class List = std::vector, + typename Reader = ValueReader> + class PositionalList : public PositionalBase + { + private: + using Container = List; + Container values; + Reader reader; + + public: + typedef T value_type; + typedef typename Container::allocator_type allocator_type; + typedef typename Container::pointer pointer; + typedef typename Container::const_pointer const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef typename Container::size_type size_type; + typedef typename Container::difference_type difference_type; + typedef typename Container::iterator iterator; + typedef typename Container::const_iterator const_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + PositionalList(Group &group_, const std::string &name_, const std::string &help_, const Container &defaultValues_ = Container()): PositionalBase(name_, help_), values(defaultValues_) + { + group_.Add(*this); + } + + virtual ~PositionalList() {} + + virtual void ParseValue(const std::string &value_) override + { + T v; +#ifdef ARGS_NOEXCEPT + if (!reader(name, value_, v)) + { + error = Error::Parse; + } +#else + reader(name, value_, v); +#endif + values.insert(std::end(values), v); + matched = true; + } + + virtual std::string Name() const override + { + return name + std::string("..."); + } + + /** Get the values + */ + Container &Get() noexcept + { + return values; + } + + virtual void Reset() noexcept override + { + PositionalBase::Reset(); + values.clear(); + } + + iterator begin() noexcept + { + return values.begin(); + } + + const_iterator begin() const noexcept + { + return values.begin(); + } + + const_iterator cbegin() const noexcept + { + return values.cbegin(); + } + + iterator end() noexcept + { + return values.end(); + } + + const_iterator end() const noexcept + { + return values.end(); + } + + const_iterator cend() const noexcept + { + return values.cend(); + } + }; + + /** A positional argument mapping class + * + * \tparam K the type to extract the argument as + * \tparam T the type to store the result as + * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined) + * \tparam Map The Map type. Should operate like std::map or std::unordered_map + */ + template < + typename K, + typename T, + typename Reader = ValueReader, + template class Map = std::unordered_map> + class MapPositional : public PositionalBase + { + private: + const Map map; + T value; + Reader reader; + + public: + + MapPositional(Group &group_, const std::string &name_, const std::string &help_, const Map &map_, const T &defaultValue_ = T()): PositionalBase(name_, help_), map(map_), value(defaultValue_) + { + group_.Add(*this); + } + + virtual ~MapPositional() {} + + virtual void ParseValue(const std::string &value_) override + { + K key; +#ifdef ARGS_NOEXCEPT + if (!reader(name, value_, key)) + { + error = Error::Parse; + } +#else + reader(name, value_, key); +#endif + auto it = map.find(key); + if (it == std::end(map)) + { +#ifdef ARGS_NOEXCEPT + error = Error::Map; +#else + std::ostringstream problem; + problem << "Could not find key '" << key << "' in map for arg '" << name << "'"; + throw MapError(problem.str()); +#endif + } else + { + this->value = it->second; + ready = false; + matched = true; + } + } + + /** Get the value + */ + T &Get() noexcept + { + return value; + } + }; + + /** A positional argument mapping list class + * + * \tparam K the type to extract the argument as + * \tparam T the type to store the result as + * \tparam List the list type that houses the values + * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined) + * \tparam Map The Map type. Should operate like std::map or std::unordered_map + */ + template < + typename K, + typename T, + template class List = std::vector, + typename Reader = ValueReader, + template class Map = std::unordered_map> + class MapPositionalList : public PositionalBase + { + private: + using Container = List; + + const Map map; + Container values; + Reader reader; + + public: + typedef T value_type; + typedef typename Container::allocator_type allocator_type; + typedef typename Container::pointer pointer; + typedef typename Container::const_pointer const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef typename Container::size_type size_type; + typedef typename Container::difference_type difference_type; + typedef typename Container::iterator iterator; + typedef typename Container::const_iterator const_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + MapPositionalList(Group &group_, const std::string &name_, const std::string &help_, const Map &map_, const Container &defaultValues_ = Container()): PositionalBase(name_, help_), map(map_), values(defaultValues_) + { + group_.Add(*this); + } + + virtual ~MapPositionalList() {} + + virtual void ParseValue(const std::string &value_) override + { + K key; +#ifdef ARGS_NOEXCEPT + if (!reader(name, value_, key)) + { + error = Error::Parse; + } +#else + reader(name, value_, key); +#endif + auto it = map.find(key); + if (it == std::end(map)) + { +#ifdef ARGS_NOEXCEPT + error = Error::Map; +#else + std::ostringstream problem; + problem << "Could not find key '" << key << "' in map for arg '" << name << "'"; + throw MapError(problem.str()); +#endif + } else + { + this->values.emplace_back(it->second); + matched = true; + } + } + + /** Get the value + */ + Container &Get() noexcept + { + return values; + } + + virtual std::string Name() const override + { + return name + std::string("..."); + } + + virtual void Reset() noexcept override + { + PositionalBase::Reset(); + values.clear(); + } + + iterator begin() noexcept + { + return values.begin(); + } + + const_iterator begin() const noexcept + { + return values.begin(); + } + + const_iterator cbegin() const noexcept + { + return values.cbegin(); + } + + iterator end() noexcept + { + return values.end(); + } + + const_iterator end() const noexcept + { + return values.end(); + } + + const_iterator cend() const noexcept + { + return values.cend(); + } + }; +} + +#endif diff --git a/tools/avx-turbo/asm-methods.asm b/tools/avx-turbo/asm-methods.asm new file mode 100644 index 00000000..9e55a8d6 --- /dev/null +++ b/tools/avx-turbo/asm-methods.asm @@ -0,0 +1,224 @@ +BITS 64 +default rel + +%if (__NASM_MAJOR__ < 2) || (__NASM_MINOR__ < 11) +%deftok ver __NASM_VER__ +%error Your nasm version (ver) is too old, you need at least 2.11 to compile this +%endif + +%include "nasm-utils-inc.asm" + +nasm_util_assert_boilerplate +thunk_boilerplate + +; aligns and declares the global label for the bench with the given name +; also potentally checks the ABI compliance (if enabled) +%macro define_func 1 +abi_checked_function %1 +%endmacro + +; define a test func that unrolls the loop by 100 +; with the given body instruction +; %1 - function name +; %2 - init instruction (e.g., xor out the variable you'll add to) +; %3 - loop body instruction +; %4 - repeat count, defaults to 100 - values other than 100 mean the Mops value will be wrong +%macro test_func 3-4 100 +define_func %1 +%2 +.top: +times %4 %3 +sub rdi, 100 +jnz .top +ret +%endmacro + +; pause +test_func pause_only, {}, {pause}, 1 + +; vpermw latency +test_func avx512_vpermw, {vpcmpeqd ymm0, ymm0, ymm0}, {vpermw zmm0, zmm0, zmm0} + +; vpermb latency +test_func avx512_vpermd, {vpcmpeqd ymm0, ymm0, ymm0}, {vpermd zmm0, zmm0, zmm0} + +; imul latency +test_func avx128_imul, {vpcmpeqd xmm0, xmm0, xmm0}, {vpmuldq xmm0, xmm0, xmm0} +test_func avx256_imul, {vpcmpeqd ymm0, ymm0, ymm0}, {vpmuldq ymm0, ymm0, ymm0} +test_func avx512_imul, {vpcmpeqd ymm0, ymm0, ymm0}, {vpmuldq zmm0, zmm0, zmm0} + +; imul throughput +test_func avx128_imul_t, {vpcmpeqd xmm0, xmm0, xmm0}, {vpmuldq xmm0, xmm1, xmm1} +test_func avx256_imul_t, {vpcmpeqd ymm0, ymm0, ymm0}, {vpmuldq ymm0, ymm1, ymm1} +test_func avx512_imul_t, {vpcmpeqd ymm0, ymm0, ymm0}, {vpmuldq zmm0, zmm1, zmm1} + +; iadd latency +test_func scalar_iadd, {xor eax, eax}, {add rax, rax} + +test_func avx128_iadd, {vpcmpeqd xmm0, xmm0, xmm0}, {vpaddq xmm0, xmm0, xmm0} +test_func avx256_iadd, {vpcmpeqd ymm0, ymm0, ymm0}, {vpaddq ymm0, ymm0, ymm0} +test_func avx512_iadd, {vpcmpeqd ymm0, ymm0, ymm0}, {vpaddq zmm0, zmm0, zmm0} + +; iadd latency with zmm16 +test_func avx128_iadd16, {vpternlogd xmm16, xmm16, xmm16, 0xff}, {vpaddq xmm16, xmm16, xmm16} +test_func avx256_iadd16, {vpternlogd ymm16, ymm16, ymm16, 0xff}, {vpaddq ymm16, ymm16, ymm16} +test_func avx512_iadd16, {vpternlogd zmm16, zmm16, zmm16, 0xff}, {vpaddq zmm16, zmm16, zmm16} + +; iadd throughput +test_func avx128_iadd_t, {vpcmpeqd xmm1, xmm0, xmm0}, {vpaddq xmm0, xmm1, xmm1} +test_func avx256_iadd_t, {vpcmpeqd ymm1, ymm0, ymm0}, {vpaddq ymm0, ymm1, ymm1} + +; zeroing xor +test_func avx128_xor_zero, {}, {vpxor xmm0, xmm0, xmm0} +test_func avx256_xor_zero, {}, {vpxor ymm0, ymm0, ymm0} +test_func avx512_xor_zero, {}, {vpxord zmm0, zmm0, zmm0} + +; vpsrlvd latency +test_func avx128_vshift, {vpcmpeqd xmm1, xmm0, xmm0}, {vpsrlvd xmm0, xmm0, xmm0} +test_func avx256_vshift, {vpcmpeqd xmm1, xmm0, xmm0}, {vpsrlvd ymm0, ymm0, ymm0} +test_func avx512_vshift, {vpcmpeqd xmm1, xmm0, xmm0}, {vpsrlvd zmm0, zmm0, zmm0} + +; vpsrlvd throughput +test_func avx128_vshift_t,{vpcmpeqd xmm1, xmm0, xmm0}, {vpsrlvd xmm0, xmm1, xmm1} +test_func avx256_vshift_t,{vpcmpeqd xmm1, xmm0, xmm0}, {vpsrlvd ymm0, ymm1, ymm1} +test_func avx512_vshift_t,{vpcmpeqd xmm1, xmm0, xmm0}, {vpsrlvd zmm0, zmm1, zmm1} + +; vplzcntd latency +test_func avx128_vlzcnt, {vpcmpeqd xmm1, xmm0, xmm0}, {vplzcntd xmm0, xmm0} +test_func avx256_vlzcnt, {vpcmpeqd xmm1, xmm0, xmm0}, {vplzcntd ymm0, ymm0} +test_func avx512_vlzcnt, {vpcmpeqd xmm1, xmm0, xmm0}, {vplzcntd zmm0, zmm0} + +; vplzcntd throughput +test_func avx128_vlzcnt_t,{vpcmpeqd xmm1, xmm0, xmm0}, {vplzcntd xmm0, xmm1} +test_func avx256_vlzcnt_t,{vpcmpeqd xmm1, xmm0, xmm0}, {vplzcntd ymm0, ymm1} +test_func avx512_vlzcnt_t,{vpcmpeqd xmm1, xmm0, xmm0}, {vplzcntd zmm0, zmm1} + +; FMA +test_func avx128_fma , {vpxor xmm0, xmm0, xmm0}, {vfmadd132pd xmm0, xmm0, xmm0} +test_func avx256_fma , {vpxor xmm0, xmm0, xmm0}, {vfmadd132pd ymm0, ymm0, ymm0} +test_func avx512_fma , {vpxor xmm0, xmm0, xmm0}, {vfmadd132pd zmm0, zmm0, zmm0} + +; this is like test_func, but it uses 10 parallel chains of instructions, +; unrolled 10 times, so (probably) max throughput at least if latency * throughput +; product for the instruction <= 10 +; %1 - function name +; %2 - init instruction (e.g., xor out the variable you'll add to) +; %3 - register base like xmm, ymm, zmm +; %4 - loop body instruction only (no operands) +; %5 - init value for xmm0-9, used as first (dest) arg as in vfmadd132pd xmm0..9, xmm10, xmm11 +; %6 - init value for xmm10, used as second arg as in vfmadd132pd reg, xmm10, xmm11 +; %7 - init value for xmm11, used as third arg as in vfmadd132pd reg, xmm10, xmm11 +%macro test_func_tput 7 +define_func %1 + +; init reg 0-9 +%assign r 0 +%rep 10 +%2 %3 %+ r, %5 +%assign r (r+1) +%endrep + +; init reg10, reg11 +%2 %3 %+ 10, %6 +%2 %3 %+ 11, %7 + +.top: +%rep 10 +%assign r 0 +%rep 10 +%4 %3 %+ r, %3 %+ 10, %3 %+ 11 +%assign r (r+1) +%endrep +%endrep +sub rdi, 100 +jnz .top +ret +%endmacro + +test_func_tput avx128_fma_t , vmovddup, xmm, vfmadd132pd, [zero_dp], [one_dp], [half_dp] +test_func_tput avx256_fma_t , vbroadcastsd, ymm, vfmadd132pd, [zero_dp], [one_dp], [half_dp] +test_func_tput avx512_fma_t , vbroadcastsd, zmm, vfmadd132pd, [zero_dp], [one_dp], [half_dp] +test_func_tput avx512_vpermw_t ,vbroadcastsd, zmm, vpermw, [zero_dp], [one_dp], [half_dp] +test_func_tput avx512_vpermd_t ,vbroadcastsd, zmm, vpermd, [zero_dp], [one_dp], [half_dp] + +; this is like test_func except that the 100x unrolled loop instruction is +; always a serial scalar add, while the passed instruction to test is only +; executed once per loop (so at a ratio of 1:100 for the scalar adds). This +; test the effect of an "occasional" AVX instruction. +; %1 - function name +; %2 - init instruction (e.g., xor out the variable you'll add to) +; %3 - loop body instruction +%macro test_func_sparse 4 +define_func %1 +%2 +%4 +xor eax, eax +.top: +%3 +times 100 add eax, eax +sub rdi, 100 +jnz .top +ret +%endmacro + +test_func_sparse avx128_mov_sparse, {vbroadcastsd ymm0, [one_dp]}, {vmovdqa xmm0, xmm0}, {} +test_func_sparse avx256_mov_sparse, {vbroadcastsd ymm0, [one_dp]}, {vmovdqa ymm0, ymm0}, {} +test_func_sparse avx512_mov_sparse, {vbroadcastsd zmm0, [one_dp]}, {vmovdqa32 zmm0, zmm0}, {} +test_func_sparse avx128_merge_sparse, {vbroadcastsd ymm0, [one_dp]}, {vmovdqa32 xmm0{k1}, xmm0}, {kmovw k1, [kmask]} +test_func_sparse avx256_merge_sparse, {vbroadcastsd ymm0, [one_dp]}, {vmovdqa32 ymm0{k1}, ymm0}, {kmovw k1, [kmask]} +test_func_sparse avx512_merge_sparse, {vbroadcastsd zmm0, [one_dp]}, {vmovdqa32 zmm0{k1}, zmm0}, {kmovw k1, [kmask]} + +test_func_sparse avx128_fma_sparse, {vbroadcastsd ymm0, [zero_dp]}, {vfmadd132pd xmm0, xmm0, xmm0 }, {} +test_func_sparse avx256_fma_sparse, {vbroadcastsd ymm0, [zero_dp]}, {vfmadd132pd ymm0, ymm0, ymm0 }, {} +test_func_sparse avx512_fma_sparse, {vbroadcastsd zmm0, [zero_dp]}, {vfmadd132pd zmm0, zmm0, zmm0 }, {} + +; %1 function name suffix +; %2 dirty instruction +%macro define_ucomis 2 +define_func ucomis_%1 +;vpxor xmm15, xmm15, xmm15 +;vzeroupper +%2 +movdqu xmm0, [one_dp] +movdqu xmm2, [one_dp] +movdqu xmm1, [zero_dp] +align 64 +.top: +%rep 100 +addsd xmm0, xmm2 +ucomisd xmm1, xmm0 +ja .never +%endrep +sub rdi, 100 +jnz .top +ret +.never: +ud2 +%endmacro + +define_ucomis clean, {vzeroupper} +define_ucomis dirty, {} + + +define_func dirty_it +vzeroupper +vpxord zmm15, zmm14, zmm15 +ret + +define_func dirty_it16 +vzeroupper +vpxord zmm16, zmm14, zmm15 +ret + +GLOBAL zeroupper_asm:function +zeroupper_asm: +vzeroupper +ret + +zero_dp: dq 0.0 +half_dp: dq 0.5 +one_dp: dq 1.0 +kmask: dq 0x5555555555555555 + + + diff --git a/tools/avx-turbo/atomic.h b/tools/avx-turbo/atomic.h new file mode 100644 index 00000000..ea5704f0 --- /dev/null +++ b/tools/avx-turbo/atomic.h @@ -0,0 +1,409 @@ +/* Atomic operations (v1) + * Portable Snippets - https://gitub.com/nemequ/portable-snippets + * Created by Evan Nemerson + * + * To the extent possible under law, the authors have waived all + * copyright and related or neighboring rights to this code. For + * details, see the Creative Commons Zero 1.0 Universal license at + * https://creativecommons.org/publicdomain/zero/1.0/ + * + * This is a small abstraction layer for some common atomic operations + * (load, store, add, subtract, and compare & swap) implemented using + * various compiler-specific builtins. + * + * There are four types, 32-bit and 64-bit integers which are both + * atomic and non-atomic. The atomic versions should be used for the + * atomic variable, the non-atomic variables should be used to store + * values read from or written to an atomic variable. For example, a + * basic CAS loop: + * + * void square_dest(psnip_atomic_int64* value) { + * psnip_int64_t expected; + * do { + * expected = psnip_atomic_int64_load(&value); + * } while (!psnip_atomic_int64_compare_exchange(&value, &expected, expected * expected)); + * } + * + * Most things are implemented with the preprocessor, but if they were + * functions the prototypes (the 64-bit versions, just s/64/32/ for + * the 32-bit versions) would loo like: + * + * psnip_int64_t psnip_atomic_int64_load( + * psnip_atomic_int64* object); + * void psnip_atomic_int64_store( + * psnip_atomic_int64* object, + * psnip_int64_t desired); + * _Bool psnip_atomic_int64_compare_exchange( + * psnip_atomic_int64* object, + * psnip_int64_t* expected, + * psnip_int64_t desired); + * psnip_int64_t psnip_atomic_int64_add( + * psnip_atomic_int64* object, + * psnip_int64_t operand); + * psnip_int64_t psnip_atomic_int64_sub( + * psnip_atomic_int64* object, + * psnip_int64_t operand); + */ + +#if !defined(PSNIP_ATOMIC_H) +#define PSNIP_ATOMIC_H + +#if !defined(psnip_int64_t) || !defined(psnip_int32_t) +# include "exact-int.h" +#endif + +#if !defined(PSNIP_ATOMIC_STATIC_INLINE) +# if defined(__GNUC__) +# define PSNIP_ATOMIC__COMPILER_ATTRIBUTES __attribute__((__unused__)) +# else +# define PSNIP_ATOMIC__COMPILER_ATTRIBUTES +# endif + +# if defined(HEDLEY_INLINE) +# define PSNIP_ATOMIC__INLINE HEDLEY_INLINE +# elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +# define PSNIP_ATOMIC__INLINE inline +# elif defined(__GNUC_STDC_INLINE__) +# define PSNIP_ATOMIC__INLINE __inline__ +# elif defined(_MSC_VER) && _MSC_VER >= 1200 +# define PSNIP_ATOMIC__INLINE __inline +# else +# define PSNIP_ATOMIC__INLINE +# endif + +# define PSNIP_ATOMIC__FUNCTION PSNIP_ATOMIC__COMPILER_ATTRIBUTES static PSNIP_ATOMIC__INLINE +#endif + +#if defined(__has_feature) +# define PSNIP_ATOMIC_HAS_FEATURE(feature) __has_feature(feature) +#else +# define PSNIP_ATOMIC_HAS_FEATURE(feature) 0 +#endif + +#define PSNIP_ATOMIC_IMPL_NONE 0 +#define PSNIP_ATOMIC_IMPL_GCC 1 +#define PSNIP_ATOMIC_IMPL_GCC_SYNC 2 +#define PSNIP_ATOMIC_IMPL_CLANG 3 +#define PSNIP_ATOMIC_IMPL_MS 4 +#define PSNIP_ATOMIC_IMPL_OPENMP 5 +#define PSNIP_ATOMIC_IMPL_C11 11 + +#if defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) +# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_GCC +#elif !defined(__INTEL_COMPILER) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_ATOMICS__) +/* GCC 4.7 and 4.8 sets __STDC_VERSION__ to C11 (if compiling in C11 + * mode) and didn't have stdatomic.h, but failed to set + * __STDC_NO_ATOMICS__. Verions prior to 4.7 didn't set + * __STDC_VERSION__ to C11. */ +# if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 9) +# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_GCC +# else +# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_C11 +# endif +#elif defined(_MSC_VER) +# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_MS +#elif defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) +# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_GCC +#elif PSNIP_ATOMIC_HAS_FEATURE(c_atomic) +# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_CLANG +#elif defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) +# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_GCC_SYNC +#elif (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x5140)) || (defined(__SUNPRO_CC) && (__SUNPRO_CC >= 0x5140)) +# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_GCC +#elif defined(_OPENMP) +# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_OPENMP +#else +# define PSNIP_ATOMIC_NOT_FOUND +# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_NONE +# warning No atomic implementation found +#endif + +#if !defined(PSNIP_ATOMIC_NOT_FOUND) + +#if PSNIP_ATOMIC_IMPL == PSNIP_ATOMIC_IMPL_C11 + +#include +typedef atomic_int_fast64_t psnip_atomic_int64; +typedef atomic_int_fast32_t psnip_atomic_int32; + +#define PSNIP_ATOMIC_VAR_INIT(value) ATOMIC_VAR_INIT(value) + +#define psnip_atomic_int64_load(object) \ + atomic_load(object) +#define psnip_atomic_int64_store(object, desired) \ + atomic_store(object, desired) +#define psnip_atomic_int64_compare_exchange(object, expected, desired) \ + atomic_compare_exchange_strong(object, expected, desired) +#define psnip_atomic_int64_add(object, operand) \ + atomic_fetch_add(object, operand) +#define psnip_atomic_int64_sub(object, operand) \ + atomic_fetch_sub(object, operand) +#define psnip_atomic_fence() \ + atomic_thread_fence(memory_order_seq_cst) + +#define PSNIP_ATOMIC_IS_TG + +#elif PSNIP_ATOMIC_IMPL == PSNIP_ATOMIC_IMPL_CLANG + +#include +typedef _Atomic psnip_int64_t psnip_atomic_int64; +typedef _Atomic psnip_int32_t psnip_atomic_int32; + +#define psnip_atomic_int64_load(object) \ + __c11_atomic_load(object, __ATOMIC_SEQ_CST) +#define psnip_atomic_int64_store(object, desired) \ + __c11_atomic_store(object, desired, __ATOMIC_SEQ_CST) +#define psnip_atomic_int64_compare_exchange(object, expected, desired) \ + __c11_atomic_compare_exchange_strong(object, expected, desired, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) +#define psnip_atomic_int64_add(object, operand) \ + __c11_atomic_fetch_add(object, operand, __ATOMIC_SEQ_CST) +#define psnip_atomic_int64_sub(object, operand) \ + __c11_atomic_fetch_sub(object, operand, __ATOMIC_SEQ_CST) +#define psnip_atomic_fence() \ + __c11_atomic_thread_fence(__ATOMIC_SEQ_CST) + +#define PSNIP_ATOMIC_IS_TG + +#elif PSNIP_ATOMIC_IMPL == PSNIP_ATOMIC_IMPL_GCC + +#include +#if !defined(__INTEL_COMPILER) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)) && !defined(_OPENMP) +typedef _Atomic psnip_int64_t psnip_atomic_int64; +typedef _Atomic psnip_int32_t psnip_atomic_int32; +#else +typedef psnip_int64_t psnip_atomic_int64; +typedef psnip_int32_t psnip_atomic_int32; +#endif + +#define psnip_atomic_int64_load(object) \ + __atomic_load_n(object, __ATOMIC_SEQ_CST) +#define psnip_atomic_int64_store(object, desired) \ + __atomic_store_n(object, desired, __ATOMIC_SEQ_CST) +#define psnip_atomic_int64_compare_exchange(object, expected, desired) \ + __atomic_compare_exchange_n(object, expected, desired, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) +#define psnip_atomic_int64_add(object, operand) \ + __atomic_add_fetch(object, operand, __ATOMIC_SEQ_CST) +#define psnip_atomic_int64_sub(object, operand) \ + __atomic_sub_fetch(object, operand, __ATOMIC_SEQ_CST) +#define psnip_atomic_fence() \ + __atomic_thread_fence(__ATOMIC_SEQ_CST) + +#define PSNIP_ATOMIC_IS_TG + +#elif PSNIP_ATOMIC_IMPL == PSNIP_ATOMIC_IMPL_GCC_SYNC + +#include +typedef psnip_int64_t psnip_atomic_int64; +typedef psnip_int32_t psnip_atomic_int32; + +PSNIP_ATOMIC__FUNCTION +psnip_int64_t +psnip_atomic_int64_load(psnip_atomic_int64* object) { + __sync_synchronize(); + return (psnip_int64_t) *object; +} + +PSNIP_ATOMIC__FUNCTION +void +psnip_atomic_int64_store(psnip_atomic_int64* object, psnip_int64_t desired) { + *object = desired; + __sync_synchronize(); +} + +#define psnip_atomic_int64_compare_exchange(object, expected, desired) \ + __sync_bool_compare_and_swap(object, *(expected), desired) +#define psnip_atomic_int64_add(object, operand) \ + __sync_fetch_and_add(object, operand) +#define psnip_atomic_int64_sub(object, operand) \ + __sync_fetch_and_sub(object, operand) + +PSNIP_ATOMIC__FUNCTION +psnip_int32_t +psnip_atomic_int32_load(psnip_atomic_int32* object) { + __sync_synchronize(); + return (psnip_int32_t) *object; +} + +PSNIP_ATOMIC__FUNCTION +void +psnip_atomic_int32_store(psnip_atomic_int32* object, psnip_int32_t desired) { + *object = desired; + __sync_synchronize(); +} + +#define psnip_atomic_int32_compare_exchange(object, expected, desired) \ + __sync_bool_compare_and_swap(object, *(expected), desired) +#define psnip_atomic_int32_add(object, operand) \ + __sync_fetch_and_add(object, operand) +#define psnip_atomic_int32_sub(object, operand) \ + __sync_fetch_and_sub(object, operand) + +#define psnip_atomic_fence() \ + __sync_synchronize() + +#elif PSNIP_ATOMIC_IMPL == PSNIP_ATOMIC_IMPL_MS + +#include + +typedef long long volatile psnip_atomic_int64; +typedef long volatile psnip_atomic_int32; + +#define psnip_atomic_int32_load(object) \ + __pragma(warning(push)) \ + __pragma(warning(disable:28112)) \ + (*(object)) \ + __pragma(warning(pop)) +#define psnip_atomic_int32_store(object, desired) \ + InterlockedExchange(object, desired) +#define psnip_atomic_int32_compare_exchange(object, expected, desired) \ + InterlockedCompareExchange(object, desired, *(expected)) +#define psnip_atomic_int32_add(object, operand) \ + InterlockedExchangeAdd(object, operand) +#define psnip_atomic_int32_sub(object, operand) \ + InterlockedExchangeAdd(object, -(operand)) + +#define psnip_atomic_int64_load(object) \ + __pragma(warning(push)) \ + __pragma(warning(disable:28112)) \ + (*(object)) \ + __pragma(warning(pop)) +#define psnip_atomic_int64_store(object, desired) \ + InterlockedExchange64(object, desired) +#define psnip_atomic_int64_compare_exchange(object, expected, desired) \ + InterlockedCompareExchange64(object, desired, *(expected)) +#define psnip_atomic_int64_add(object, operand) \ + InterlockedExchangeAdd64(object, operand) +#define psnip_atomic_int64_sub(object, operand) \ + InterlockedExchangeAdd64(object, -(operand)) + +#define psnip_atomic_fence() \ + MemoryBarrier() + +#elif PSNIP_ATOMIC_IMPL == PSNIP_ATOMIC_IMPL_OPENMP + +#include +typedef psnip_int64_t psnip_atomic_int64; +typedef psnip_int32_t psnip_atomic_int32; + +PSNIP_ATOMIC__FUNCTION +psnip_int64_t +psnip_atomic_int64_load(psnip_atomic_int64* object) { + psnip_int64_t ret; +#pragma omp critical(psnip_atomic) + ret = *object; + return ret; +} + +PSNIP_ATOMIC__FUNCTION +void +psnip_atomic_int64_store(psnip_atomic_int64* object, psnip_int64_t desired) { +#pragma omp critical(psnip_atomic) + *object = desired; +} + +PSNIP_ATOMIC__FUNCTION +int +psnip_atomic_int64_compare_exchange_(psnip_atomic_int64* object, psnip_int64_t* expected, psnip_int64_t desired) { + int ret; +#pragma omp critical(psnip_atomic) + ret = (*object == *expected) ? ((*object = desired), 1) : 0; + return ret; +} + +#define psnip_atomic_int64_compare_exchange(object, expected, desired) \ + psnip_atomic_int64_compare_exchange_(object, expected, desired) + +PSNIP_ATOMIC__FUNCTION +psnip_int64_t +psnip_atomic_int64_add(psnip_atomic_int64* object, psnip_int64_t operand) { + int ret; +#pragma omp critical(psnip_atomic) + *object = (ret = *object) + operand; + return ret; +} + +PSNIP_ATOMIC__FUNCTION +psnip_int64_t +psnip_atomic_int64_sub(psnip_atomic_int64* object, psnip_int64_t operand) { + int ret; +#pragma omp critical(psnip_atomic) + *object = (ret = *object) - operand; + return ret; +} +PSNIP_ATOMIC__FUNCTION +psnip_int32_t +psnip_atomic_int32_load(psnip_atomic_int32* object) { + psnip_int32_t ret; +#pragma omp critical(psnip_atomic) + ret = *object; + return ret; +} + +PSNIP_ATOMIC__FUNCTION +void +psnip_atomic_int32_store(psnip_atomic_int32* object, psnip_int32_t desired) { +#pragma omp critical(psnip_atomic) + *object = desired; +} + +PSNIP_ATOMIC__FUNCTION +int +psnip_atomic_int32_compare_exchange_(psnip_atomic_int32* object, psnip_int32_t* expected, psnip_int32_t desired) { + int ret = 1; +#pragma omp critical(psnip_atomic) + ret = (*object == *expected) ? ((*object = desired), 1) : 0; + return ret; +} + +#define psnip_atomic_int32_compare_exchange(object, expected, desired) \ + psnip_atomic_int32_compare_exchange_(object, expected, desired) + +PSNIP_ATOMIC__FUNCTION +psnip_int32_t +psnip_atomic_int32_add(psnip_atomic_int32* object, psnip_int32_t operand) { + int ret; +#pragma omp critical(psnip_atomic) + *object = (ret = *object) + operand; + return ret; +} + +PSNIP_ATOMIC__FUNCTION +psnip_int32_t +psnip_atomic_int32_sub(psnip_atomic_int32* object, psnip_int32_t operand) { + int ret; +#pragma omp critical(psnip_atomic) + *object = (ret = *object) - operand; + return ret; +} + +PSNIP_ATOMIC__FUNCTION +void +psnip_atomic_fence() { +#pragma omp critical(psnip_atomic) + { } +} + + +#endif + +#if !defined(PSNIP_ATOMIC_VAR_INIT) +# define PSNIP_ATOMIC_VAR_INIT(value) (value) +#endif + +/* Most compilers have type-generic atomic implementations. */ +#if defined(PSNIP_ATOMIC_IS_TG) +#define psnip_atomic_int32_load(object) \ + psnip_atomic_int64_load(object) +#define psnip_atomic_int32_store(object, desired) \ + psnip_atomic_int64_store(object, desired) +#define psnip_atomic_int32_compare_exchange(object, expected, desired) \ + psnip_atomic_int64_compare_exchange(object, expected, desired) +#define psnip_atomic_int32_add(object, operand) \ + psnip_atomic_int64_add(object, operand) +#define psnip_atomic_int32_sub(object, operand) \ + psnip_atomic_int64_sub(object, operand) +#endif /* defined(PSNIP_ATOMIC_IS_TG) */ + +#endif /* !defined(PSNIP_ATOMIC_NOT_FOUND) */ + +#endif /* defined(PSNIP_ATOMIC_H) */ diff --git a/tools/avx-turbo/avx-turbo.cpp b/tools/avx-turbo/avx-turbo.cpp new file mode 100644 index 00000000..ed7523e9 --- /dev/null +++ b/tools/avx-turbo/avx-turbo.cpp @@ -0,0 +1,890 @@ +/* + * avx-turbo.cpp + */ + +#include "args.hxx" +#include "cpu.h" +#include "cpuid.hpp" +#include "msr-access.h" +#include "stats.hpp" +#include "tsc-support.hpp" +#include "table.hpp" +#include "util.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + + +#define MSR_IA32_MPERF 0x000000e7 +#define MSR_IA32_APERF 0x000000e8 + +using std::uint64_t; +using namespace std::chrono; + +using namespace Stats; + +typedef void (cal_f)(uint64_t iters); + +enum ISA { + BASE = 1 << 0, + AVX2 = 1 << 1, + AVX512F = 1 << 2, // note: does not imply VL, so xmm and ymm may not be available + AVX512VL = 1 << 3, // note: does not imply F, although i don't know any CPU with VL but not F + AVX512CD = 1 << 4, + AVX512BW = 1 << 5, +}; + +struct test_func { + // function pointer to the test function + cal_f* func; + const char* id; + const char* description; + ISA isa; +}; + + +#define FUNCS_X(x) \ + x(pause_only , "pause instruction" , BASE) \ + x(ucomis_clean , "scalar ucomis (w/ vzeroupper)" , AVX2) \ + x(ucomis_dirty , "scalar ucomis (no vzeroupper)" , AVX2) \ + \ + /* iadd */ \ + x(scalar_iadd , "Scalar integer adds" , BASE) \ + x(avx128_iadd , "128-bit integer serial adds" , AVX2 ) \ + x(avx256_iadd , "256-bit integer serial adds" , AVX2 ) \ + x(avx512_iadd , "512-bit integer serial adds" , AVX512F) \ + \ + x(avx128_iadd16 , "128-bit integer serial adds zmm16", AVX512VL) \ + x(avx256_iadd16 , "256-bit integer serial adds zmm16", AVX512VL) \ + x(avx512_iadd16 , "512-bit integer serial adds zmm16", AVX512F) \ + \ + /* iadd throughput */ \ + x(avx128_iadd_t , "128-bit integer parallel adds" , AVX2 ) \ + x(avx256_iadd_t , "256-bit integer parallel adds" , AVX2 ) \ + \ + /* zeroing xor */ \ + x(avx128_xor_zero , "128-bit zeroing xor" , AVX2 ) \ + x(avx256_xor_zero , "256-bit zeroing xor" , AVX2 ) \ + x(avx512_xor_zero , "512-bit zeroing xord" , AVX512F) \ + \ + /* reg-reg mov */ \ + x(avx128_mov_sparse , "128-bit reg-reg mov" , AVX2) \ + x(avx256_mov_sparse , "256-bit reg-reg mov" , AVX2 ) \ + x(avx512_mov_sparse , "512-bit reg-reg mov" , AVX512F) \ + \ + /* merge */ \ + x(avx128_merge_sparse , "128-bit reg-reg merge mov" , AVX512VL) \ + x(avx256_merge_sparse , "256-bit reg-reg merge mov" , AVX512VL) \ + x(avx512_merge_sparse , "512-bit reg-reg merge mov" , AVX512F) \ + \ + /* variable shift latency */ \ + x(avx128_vshift , "128-bit variable shift (vpsrlvd)", AVX2 ) \ + x(avx256_vshift , "256-bit variable shift (vpsrlvd)", AVX2 ) \ + x(avx512_vshift , "512-bit variable shift (vpsrlvd)", AVX512F) \ + /* variable shift throughput */ \ + x(avx128_vshift_t , "128-bit variable shift (vpsrlvd)", AVX2 ) \ + x(avx256_vshift_t , "256-bit variable shift (vpsrlvd)", AVX2 ) \ + x(avx512_vshift_t , "512-bit variable shift (vpsrlvd)", AVX512F) \ + \ + /* vplzcntd latency */ \ + x(avx128_vlzcnt , "128-bit lzcnt (vplzcntd)", AVX512CD | AVX512VL) \ + x(avx256_vlzcnt , "256-bit lzcnt (vplzcntd)", AVX512CD | AVX512VL) \ + x(avx512_vlzcnt , "512-bit lzcnt (vplzcntd)", AVX512CD) \ + /* vplzcntd throughput */ \ + x(avx128_vlzcnt_t , "128-bit lzcnt (vplzcntd)", AVX512CD | AVX512VL) \ + x(avx256_vlzcnt_t , "256-bit lzcnt (vplzcntd)", AVX512CD | AVX512VL) \ + x(avx512_vlzcnt_t , "512-bit lzcnt (vplzcntd)", AVX512CD) \ + \ + x(avx128_imul , "128-bit integer muls (vpmuldq)" , AVX2 ) \ + x(avx256_imul , "256-bit integer muls (vpmuldq)" , AVX2 ) \ + x(avx512_imul , "512-bit integer muls (vpmuldq)" , AVX512F) \ + \ + /* fma */ \ + x(avx128_fma_sparse , "128-bit 64-bit sparse FMAs" , AVX2 ) \ + x(avx256_fma_sparse , "256-bit 64-bit sparse FMAs" , AVX2 ) \ + x(avx512_fma_sparse , "512-bit 64-bit sparse FMAs" , AVX512F) \ + x(avx128_fma , "128-bit serial DP FMAs" , AVX2 ) \ + x(avx256_fma , "256-bit serial DP FMAs" , AVX2 ) \ + x(avx512_fma , "512-bit serial DP FMAs" , AVX512F) \ + x(avx128_fma_t , "128-bit parallel DP FMAs" , AVX2 ) \ + x(avx256_fma_t , "256-bit parallel DP FMAs" , AVX2 ) \ + x(avx512_fma_t , "512-bit parallel DP FMAs" , AVX512F) \ + \ + x(avx512_vpermw , "512-bit serial WORD permute" , AVX512BW) \ + x(avx512_vpermw_t , "512-bit parallel WORD permute" , AVX512BW) \ + x(avx512_vpermd , "512-bit serial DWORD permute" , AVX512F) \ + x(avx512_vpermd_t , "512-bit parallel DWORD permute" , AVX512F) \ + + +#define DECLARE(f,...) cal_f f; + +extern "C" { +// functions declared in asm-methods.asm +FUNCS_X(DECLARE); + + +// misc helpers +void zeroupper_asm(); + +static bool zeroupper_allowed; + +void zeroupper() { + if (zeroupper_allowed) zeroupper_asm(); +} + +} + +#define MAKE_STRUCT(f, d, i) { f, #f, d, (ISA)(i) }, +const test_func ALL_FUNCS[] = { +FUNCS_X(MAKE_STRUCT) +}; + +void pin_to_cpu(int cpu) { + cpu_set_t cpuset; + CPU_ZERO(&cpuset); + CPU_SET(cpu, &cpuset); + if (sched_setaffinity(0, sizeof(cpuset), &cpuset) == -1) { + error(EXIT_FAILURE, errno, "could not pin to CPU %d", cpu); + } +} + +/** args */ +args::ArgumentParser parser{"avx-turbo: Determine AVX2 and AVX-512 downclocking behavior"}; +args::HelpFlag help{parser, "help", "Display this help menu", {'h', "help"}}; +args::Flag arg_force_tsc_cal{parser, "force-tsc-calibrate", + "Force manual TSC calibration loop, even if cpuid TSC Hz is available", {"force-tsc-calibrate"}}; +args::Flag arg_no_pin{parser, "no-pin", + "Don't try to pin threads to CPU - gives worse results but works around affinity issues on TravisCI", {"no-pin"}}; +args::Flag arg_verbose{parser, "verbose", "Output more info", {"verbose"}}; +args::Flag arg_nobarrier{parser, "no-barrier", "Don't sync up threads before each test (debugging only)", {"no-barrier"}}; +args::Flag arg_list{parser, "list", "List the available tests and their descriptions", {"list"}}; +args::Flag arg_hyperthreads{parser, "allow-hyperthreads", "By default we try to filter down the available cpus to include only physical cores, but " + "with this option we'll use all logical cores meaning you'll run two tests on cores with hyperthreading", {"allow-hyperthreads"}}; +args::Flag arg_dirty{parser, "dirty-upper", "AVX-512 only: the 512-bit zmm15 register is dirtied befor each test", + {"dirty-upper"}}; +args::Flag arg_dirty16{parser, "dirty-upper", "AVX-512 only: the 512-bit zmm16 register is dirtied befor each test", + {"dirty-upper16"}}; +args::ValueFlag arg_focus{parser, "TEST-ID", "Run only the specified test (by ID)", {"test"}}; +args::ValueFlag arg_spec{parser, "SPEC", "Run a specific type of test specified by a specification string", {"spec"}}; +args::ValueFlag arg_iters{parser, "ITERS", "Run the test loop ITERS times (default 100000)", {"iters"}, 100000}; +args::ValueFlag arg_min_threads{parser, "MIN", "The minimum number of threads to use", {"min-threads"}, 1}; +args::ValueFlag arg_max_threads{parser, "MAX", "The maximum number of threads to use", {"max-threads"}}; +args::ValueFlag arg_num_cpus{parser, "CPUS", "Override number of available CPUs", {"num-cpus"}}; +args::ValueFlag arg_warm_ms{parser, "MILLISECONDS", "Warmup milliseconds for each thread after pinning (default 100)", {"warmup-ms"}, 100}; +args::ValueFlag arg_cpuids{parser, "CPUIDS", "Pin threads to comma-separated list of CPU IDs (default sequential ids)", {"cpuids"}}; + +bool verbose; + +template +struct StdClock { + using now_t = decltype(CHRONO_CLOCK::now()); + using delta_t = typename CHRONO_CLOCK::duration; + + static now_t now() { + return CHRONO_CLOCK::now(); + } + + /* accept the result of subtraction of durations and convert to nanos */ + static uint64_t to_nanos(typename CHRONO_CLOCK::duration d) { + return duration_cast(d).count(); + } +}; + +struct RdtscClock { + using now_t = uint64_t; + using delta_t = uint64_t; + + static now_t now() { + _mm_lfence(); + now_t ret = rdtsc(); + _mm_lfence(); + return ret; + } + + /* accept the result of subtraction of durations and convert to nanos */ + static uint64_t to_nanos(now_t diff) { + static double tsc_to_nanos = 1000000000.0 / tsc_freq(); + return diff * tsc_to_nanos; + } + + static uint64_t tsc_freq() { + static uint64_t freq = get_tsc_freq(arg_force_tsc_cal); + return freq; + } + +}; + +/** + * We pass an outer_clock to run_test which times outside the iteration of the innermost loop (i.e., + * it times around the loop that runs TRIES times), start should reset the state unless you want to + * time warmup iterations. + */ +struct outer_timer { + virtual void start() = 0; + virtual void stop() = 0; + virtual ~outer_timer() {} +}; + +struct dummy_outer : outer_timer { + static dummy_outer dummy; + virtual void start() override {}; + virtual void stop() override {}; +}; +dummy_outer dummy_outer::dummy{}; + +/** lets you determine the actual frequency over any interval using the free-running APERF and MPERF counters */ +struct aperf_ghz : outer_timer { + uint64_t mperf_value, aperf_value, tsc_value; + enum { + STARTED, STOPPED + } state; + + aperf_ghz() : mperf_value(0), aperf_value(0), tsc_value(0), state(STOPPED) {} + + static uint64_t mperf() { + return read(MSR_IA32_MPERF); + } + + static uint64_t aperf() { + return read(MSR_IA32_APERF); + } + + static uint64_t read(uint32_t msr) { + uint64_t value = -1; + int res = read_msr_cur_cpu(msr, &value); + assert(res == 0); + return value; + } + + /** + * Return true iff APERF and MPERF MSR reads appear to work + */ + static bool is_supported() { + uint64_t dummy; + return read_msr(1, MSR_IA32_MPERF, &dummy) == 0 + && read_msr(1, MSR_IA32_APERF, &dummy) == 0; + } + + virtual void start() override { + assert(state == STOPPED); + state = STARTED; + mperf_value = mperf(); + aperf_value = aperf(); + tsc_value = rdtsc(); +// printf("started timer m: %lu\n", mperf_value); +// printf("started timer a: %lu\n", aperf_value); + }; + + virtual void stop() override { + assert(state == STARTED); + mperf_value = mperf() - mperf_value; + aperf_value = aperf() - aperf_value; + tsc_value = rdtsc() - tsc_value; + state = STOPPED; +// printf("stopped timer m: %lu (delta)\n", mperf_value); +// printf("stopped timer a: %lu (delta)\n", aperf_value); + }; + + /** aperf / mperf ratio */ + double am_ratio() { + assert(state == STOPPED); + assert(mperf_value != 0 && aperf_value != 0); +// printf("timer ratio m: %lu (delta)\n", mperf_value); +// printf("timer ratio a: %lu (delta)\n", aperf_value); + return (double)aperf_value / mperf_value; + } + + /** mperf / tsc ratio, i.e., the % of the time the core was unhalted */ + double mt_ratio() { + assert(state == STOPPED); + assert(mperf_value != 0 && tsc_value != 0); +// printf("timer ratio m: %lu (delta)\n", mperf_value); +// printf("timer ratio a: %lu (delta)\n", aperf_value); + return (double)mperf_value / tsc_value; + } + + +}; + +/* + * The result of the run_test method, with only the stuff + * that can be calculated from within that method. + */ +struct inner_result { + /* calculated Mops value */ + double mops; + uint64_t ostart_ts, oend_ts; + uint64_t istart_ts, iend_ts; // start and end timestamps for the "critical" benchmark portion +}; + +/* + * Calculate the frequency of the CPU based on timing a tight loop that we expect to + * take one iteration per cycle. + * + * ITERS is the base number of iterations to use: the calibration routine is actually + * run twice, once with ITERS iterations and once with 2*ITERS, and a delta is used to + * remove measurement overhead. + */ +struct hot_barrier { + size_t break_count; + std::atomic current; + hot_barrier(size_t count) : break_count(count), current{0} {} + + /* increment the arrived count of the barrier (do this once per thread generally) */ + void increment() { + current++; + } + + /* return true if all the threads have arrived, never blocks */ + bool is_broken() { + return current.load() == break_count; + } + + /* increment and hot spin on the waiter count until it hits the break point, returns the spin count in case you care */ + long wait() { + increment(); + long count = 0; + while (!is_broken()) { + count++; + } + return count; + } +}; + +// dirties zmm15 upper bits +extern "C" void dirty_it(); +// dirties zmm15 upper bits +extern "C" void dirty_it16(); + +template +inner_result run_test(cal_f* func, size_t iters, outer_timer& outer, hot_barrier *barrier) { + assert(iters % 100 == 0); + + std::array results; + + inner_result result; + + if (arg_dirty) { + dirty_it(); + } + + if (arg_dirty16) { + dirty_it16(); + } + + result.ostart_ts = RdtscClock::now(); + for (size_t w = 0; w < WARMUP + 1; w++) { + result.istart_ts = RdtscClock::now(); + outer.start(); + for (size_t r = 0; r < TRIES; r++) { + auto t0 = CLOCK::now(); + func(iters); + auto t1 = CLOCK::now(); + func(iters * 2); + auto t2 = CLOCK::now(); + results[r] = (t2 - t1) - (t1 - t0); + } + outer.stop(); + result.iend_ts = RdtscClock::now(); + } + + for (barrier->increment(); !barrier->is_broken();) { + func(iters); + } + result.oend_ts = RdtscClock::now(); + + std::array nanos = {}; + std::transform(results.begin(), results.end(), nanos.begin(), CLOCK::to_nanos); + DescriptiveStats stats = get_stats(nanos.begin(), nanos.end()); + + result.mops = ((double)iters / stats.getMedian()); + return result; +} + +ISA get_isas() { + int ret = BASE; + ret |= psnip_cpu_feature_check(PSNIP_CPU_FEATURE_X86_AVX2 ) ? AVX2 : 0; + ret |= psnip_cpu_feature_check(PSNIP_CPU_FEATURE_X86_AVX512F ) ? AVX512F : 0; + ret |= psnip_cpu_feature_check(PSNIP_CPU_FEATURE_X86_AVX512VL) ? AVX512VL : 0; + ret |= psnip_cpu_feature_check(PSNIP_CPU_FEATURE_X86_AVX512CD) ? AVX512CD : 0; + ret |= psnip_cpu_feature_check(PSNIP_CPU_FEATURE_X86_AVX512BW) ? AVX512BW : 0; + return (ISA)ret; +} + +bool should_run(const test_func& t, ISA isas_supported) { + return (t.isa & isas_supported) == t.isa; +} + +/* + * A test_spec contains the information needed to run one test. It is composed of + * a list of test_funcs, which should be run in parallel on separate threads. + */ +struct test_spec { + std::string name; + std::string description; + std::vector thread_funcs; + + test_spec(std::string name, std::string description) : name{name}, description{description} {} + + /** how many threads/funcs in this test */ + size_t count() const { return thread_funcs.size(); } + + std::string to_string() const { + std::string ret; + for (auto& t : thread_funcs) { + ret += t.id; + ret += ','; + } + return ret; + } +}; + + +/* find the test that exactly matches the given ID or return nullptr if not found */ +const test_func *find_one_test(const std::string& id) { + for (const auto& t : ALL_FUNCS) { + if (id == t.id) { + return &t; + } + } + return nullptr; +} + +/** + * If the user didn't specify any particular test spec, just create for every thread count + * value T and runnable func, a spec with T copies of func. + */ +std::vector make_default_tests(ISA isas_supported, std::vector cpus) { + std::vector ret; + + size_t maxcpus; + if (arg_max_threads) { + auto max = arg_max_threads.Get(); + if (max > (int)cpus.size()) { + printf("WARNING: can't run the requested number of threads (%d) because there are only %d available logical CPUs.\n", + max, (int)cpus.size()); + maxcpus = (int)cpus.size(); + } else { + maxcpus = max; + } + } else { + maxcpus = cpus.size(); + } + + printf("Will test up to %lu CPUs\n", maxcpus); + + auto try_add = [&ret](const test_func& t, size_t thread_count) { + test_spec spec(t.id, t.description); + spec.thread_funcs.resize(thread_count, t); // fill with thread_count copies of t + ret.push_back(std::move(spec)); + }; + + std::vector funcs; // the selected test functions + if (arg_focus) { + for (auto& focus : split(arg_focus.Get(), ",")) { + auto t = find_one_test(focus); + if (!t) { + printf("WARNING: Can't find specified test: %s\n", focus.c_str()); + } else { + funcs.push_back(*t); + } + } + } else { + funcs.insert(funcs.begin(), std::begin(ALL_FUNCS), std::end(ALL_FUNCS)); + } + + for (size_t thread_count = arg_min_threads.Get(); thread_count <= maxcpus; thread_count++) { + for (const auto& t : funcs) { + if (should_run(t, isas_supported)) { + try_add(t, thread_count); + } + } + } + + return ret; +} + + +std::vector make_from_spec(ISA, std::vector cpus) { + std::string str = arg_spec.Get(); + if (verbose) printf("Making tests from spec string: %s\n", str.c_str()); + + test_spec spec{str, ""}; + for (auto& elem : split(str,",")) { + if (verbose) printf("Elem: %s\n", elem.c_str()); + std::vector halves = split(elem,"/"); + assert(halves.size() > 0); + if (halves.size() > 2) { + throw std::runtime_error(std::string("bad spec syntax in element: '" + elem + "'")); + } + int count = (halves.size() == 1 ? 1 : std::atoi(halves[1].c_str())); + const test_func* test = find_one_test(halves[0]); + if (!test) { + throw std::runtime_error("couldn't find test: '" + halves[0] + "'"); + } + + spec.thread_funcs.insert(spec.thread_funcs.end(), count, *test); + } + + if (spec.count() > cpus.size()) { + printf("ERROR: this spec requires %d CPUs but only %d are available.\n", (int)spec.count(), (int)cpus.size()); + exit(EXIT_FAILURE); + } + + return {spec}; +} + +std::vector filter_tests(ISA isas_supported, std::vector cpus) { + if (!arg_spec) { + return make_default_tests(isas_supported, cpus); + } else { + return make_from_spec(isas_supported, cpus); + } +} + +struct result { + static constexpr double nan = std::numeric_limits::quiet_NaN(); + inner_result inner; + + uint64_t start_ts; // start timestamp + uint64_t end_ts; // end timestamp + + /* optional stuff associated with outer_timer */ + double aperf_am = nan; + double aperf_mt = nan; +}; + +struct result_holder { + const test_spec* spec; + std::vector results; // will have spec.count() elements + + result_holder(const test_spec* spec) : spec(spec) {} + + /** calculate the overlap ratio based on the start/end timestamps */ + double get_overlap1() const { + std::vector> ranges = transformv(results, [](const result& r){ return std::make_pair(r.start_ts, r.end_ts);} ); + return conc_ratio(ranges.begin(), ranges.end()); + } + + /** calculate the overlap ratio based on the start/end timestamps */ + double get_overlap2() const { + std::vector> ranges = transformv(results, [](const result& r){ return std::make_pair(r.inner.istart_ts, r.inner.iend_ts);} ); + return conc_ratio(ranges.begin(), ranges.end()); + } + + /** calculate the inner overlap ratio based on the start/end timestamps */ + double get_overlap3() const { + auto orange = transformv(results, [](const result& r){ return std::make_pair(r.inner.ostart_ts, r.inner.oend_ts);} ); + auto irange = transformv(results, [](const result& r){ return std::make_pair(r.inner.istart_ts, r.inner.iend_ts);} ); + return nconc_ratio(orange.begin(), orange.end(), irange.begin(), irange.end()); + } +}; + +struct warmup { + uint64_t millis; + warmup(uint64_t millis) : millis{millis} {} + + long warm() { + int64_t start = (int64_t)RdtscClock::now(); + long iters = 0; + while (RdtscClock::to_nanos(RdtscClock::now() - start) < 1000000u * millis) { + iters++; + } + return iters; + } +}; + +struct test_thread { + size_t id; + size_t cpu_id; + hot_barrier* start_barrier; + hot_barrier* stop_barrier; + + /* output */ + result res; + + /* input */ + const test_func* test; + size_t iters; + bool use_aperf; + + std::thread thread; + + test_thread(size_t id, size_t cpu_id, hot_barrier& start_barrier, hot_barrier& stop_barrier, const test_func *test, size_t iters, bool use_aperf) : + id{id}, cpu_id{cpu_id}, start_barrier{&start_barrier}, stop_barrier{&stop_barrier}, test{test}, + iters{iters}, use_aperf{use_aperf}, thread{std::ref(*this)} + { + // if (verbose) printf("Constructed test in thread %lu, this = %p\n", id, this); + } + + test_thread(const test_thread&) = delete; + test_thread(test_thread&&) = delete; + void operator=(const test_thread&) = delete; + + void operator()() { + // if (verbose) printf("Running test in thread %lu, this = %p\n", id, this); + if (!arg_no_pin) { + pin_to_cpu(cpu_id); + } + aperf_ghz aperf_timer; + outer_timer& outer = use_aperf ? static_cast(aperf_timer) : dummy_outer::dummy; + warmup w{arg_warm_ms.Get()}; + long warms = w.warm(); + if (verbose) printf("[%2lu] Warmup iters %lu\n", id, warms); + if (!arg_nobarrier) { + long count = start_barrier->wait(); + if (verbose) printf("[%2lu] Thread loop count: %ld\n", id, count); + } + res.start_ts = RdtscClock::now(); + res.inner = run_test(test->func, iters, outer, stop_barrier); + res.end_ts = RdtscClock::now(); + res.aperf_am = use_aperf ? aperf_timer.am_ratio() : 0.0; + res.aperf_mt = use_aperf ? aperf_timer.mt_ratio() : 0.0; + } +}; + +template +std::string result_string(const std::vector& results, const char* format, E e) { + std::string s; + for (const auto& result : results) { + if (!s.empty()) s += ", "; + s += table::string_format(format, e(result)); + } + return s; +} + +void report_results(const std::vector& results_list, bool use_aperf) { + // report + table::Table table; + table.setColColumnSeparator(" | "); + + auto& header = table.newRow(); + + using table::ColInfo; + + auto adder = [&header, &table](const char* s, ColInfo::Justification just = ColInfo::LEFT) { + header.add(s); + table.colInfo(header.size() - 1).justify = just; + }; + + adder("Cores"); + adder("ID"); + adder("Description"); + // adder("OVRLP1", ColInfo::RIGHT); + // adder("OVRLP2", ColInfo::RIGHT); + adder("OVRLP3", ColInfo::RIGHT); + adder("Mops", ColInfo::RIGHT); + + if (use_aperf) { + adder("A/M-ratio", ColInfo::RIGHT); + adder("A/M-MHz", ColInfo::RIGHT); + adder("M/tsc-ratio", ColInfo::RIGHT); + } + + for (const result_holder& holder : results_list) { + auto spec = holder.spec; + auto &row = table.newRow() + .add(spec->count()) + .add(spec->name) + .add(spec->description) + // .addf("%5.3f", holder.get_overlap1()) + // .addf("%5.3f", holder.get_overlap2()) + .addf("%5.3f", holder.get_overlap3()); + + auto& results = holder.results; + row.add(result_string(results, "%5.0f", [](const result& r){ return r.inner.mops * 1000; })); + if (use_aperf) { + row.add(result_string(results, "%4.2f", [](const result& r){ return r.aperf_am; })); + row.add(result_string(results, "%.0f", [](const result& r){ return r.aperf_am / 1000000.0 * RdtscClock::tsc_freq(); })); + row.add(result_string(results, "%4.2f", [](const result& r){ return r.aperf_mt; })); + } + } + + printf("%s\n", table.str().c_str()); +} + +void list_tests() { + table::Table table; + table.newRow().add("ID").add("Description"); + for (auto& t : ALL_FUNCS) { + table.newRow().add(t.id).add(t.description); + } + printf("Available tests:\n\n%s\n", table.str().c_str()); +} + +std::vector get_cpus() { + if (arg_num_cpus) { + auto cpu_num = arg_num_cpus.Get(); + std::vector ret; + for (int cpu = 0; cpu < cpu_num; ++cpu) { + ret.push_back(cpu); + } + return ret; + } + cpu_set_t cpu_set; + if (sched_getaffinity(0, sizeof(cpu_set), &cpu_set)) { + err(EXIT_FAILURE, "failed while getting cpu affinity"); + } + std::vector ret; + for (int cpu = 0; cpu < CPU_SETSIZE; cpu++) { + if (CPU_ISSET(cpu, &cpu_set)) { + ret.push_back(cpu); + } + } + return ret; +} + +/* try to filter the CPU list to return only physical CPUs */ +std::vector filter_cpus(std::vector cpus) { + int shift = get_smt_shift(); + if (shift == -1) { + printf("Can't use cpuid leaf 0xb to filter out hyperthreads, CPU too old or AMD\n"); + return cpus; + } + cpu_set_t original_set; + if (sched_getaffinity(0, sizeof(original_set), &original_set)) { + err(EXIT_FAILURE, "failed while getting cpu affinity"); + } + std::vector filtered_cpus; + std::set coreid_set; + for (int cpu : cpus) { + cpu_set_t cpuset; + CPU_ZERO(&cpuset); + CPU_SET(cpu, &cpuset); + if (sched_setaffinity(0, sizeof(cpu_set_t), &cpuset)) { + err(EXIT_FAILURE, "failed to sched_setaffinity in filter_cpus"); + } + cpuid_result leafb = cpuid(0xb); + uint32_t apicid = leafb.edx, coreid = apicid >> shift; + if (verbose) printf("cpu %d has x2apic ID %u, coreid %u\n", cpu, apicid, coreid); + if (coreid_set.insert(coreid).second) { + filtered_cpus.push_back(cpu); + } + } + // restore original affinity + sched_setaffinity(0, sizeof(cpu_set_t), &original_set); + return filtered_cpus; +} + +int main(int argc, char** argv) { + + try { + parser.ParseCLI(argc, argv); + if (arg_iters.Get() % 100 != 0) { + printf("ITERS must be a multiple of 100\n"); + exit(EXIT_FAILURE); + } + } catch (args::Help& help) { + printf("%s\n", parser.Help().c_str()); + exit(EXIT_SUCCESS); + } catch (const args::ParseError& e) { + printf("ERROR while parsing arguments: %s\n", e.what()); + printf("\nUsage:\n%s\n", parser.Help().c_str()); + exit(EXIT_FAILURE); + } + + if (arg_list) { + list_tests(); + exit(EXIT_SUCCESS); + } + + verbose = arg_verbose; + bool is_root = (geteuid() == 0); + bool use_aperf = aperf_ghz::is_supported(); + printf("CPUID highest leaf : [%2xh]\n", cpuid_highest_leaf()); + printf("Running as root : [%s]\n", is_root ? "YES" : "NO "); + printf("MSR reads supported : [%s]\n", use_aperf ? "YES" : "NO "); + printf("CPU pinning enabled : [%s]\n", !arg_no_pin ? "YES" : "NO "); + + ISA isas_supported = get_isas(); + zeroupper_allowed = isas_supported & AVX2; + printf("CPU supports zeroupper: [%s]\n", zeroupper_allowed ? "YES" : "NO "); + printf("CPU supports AVX2 : [%s]\n", isas_supported & AVX2 ? "YES" : "NO "); + printf("CPU supports AVX-512F : [%s]\n", isas_supported & AVX512F ? "YES" : "NO "); + printf("CPU supports AVX-512VL: [%s]\n", isas_supported & AVX512VL ? "YES" : "NO "); + printf("CPU supports AVX-512BW: [%s]\n", isas_supported & AVX512BW ? "YES" : "NO "); + printf("CPU supports AVX-512CD: [%s]\n", isas_supported & AVX512CD ? "YES" : "NO "); + printf("tsc_freq = %.1f MHz (%s)\n", RdtscClock::tsc_freq() / 1000000.0, get_tsc_cal_info(arg_force_tsc_cal)); + std::vector cpus = get_cpus(); + printf("CPU brand string: %s\n", get_brand_string().c_str()); + printf("%lu available CPUs: [%s]\n", cpus.size(), join(cpus, ", ").c_str()); + if (!arg_hyperthreads) { + cpus = filter_cpus(cpus); + printf("%lu physical cores: [%s]\n", cpus.size(), join(cpus, ", ").c_str()); + } + + if (arg_dirty && !(isas_supported & AVX512VL)) { + printf("ERROR: --dirty-upper only supported on AVX-512 hardware\n"); + exit(EXIT_FAILURE); + } + + auto iters = arg_iters.Get(); + zeroupper(); + auto specs = filter_tests(isas_supported, cpus); + + // parse comma separate list of cpu_ids into an array + std::vector cpu_ids; + if (arg_cpuids) { + for (auto& id : split(arg_cpuids.Get(), ",")) { + cpu_ids.push_back(std::atoi(id.c_str())); + } + } else { + for (int i = 0; i < (int)cpus.size(); i++) { + cpu_ids.push_back(i); + } + } + + size_t last_thread_count = -1u; + std::vector results_list; + for (auto& spec : specs) { + // if we changed the number of threads, spit out the accumulated output + if (last_thread_count != -1u && last_thread_count != spec.count()) { + // time to print results + report_results(results_list, use_aperf); + results_list.clear(); + } + last_thread_count = spec.count(); + + assert(!spec.thread_funcs.empty()); + if (verbose) printf("Running test spec: %s\n", spec.to_string().c_str()); + + // run + std::deque threads; + hot_barrier start{spec.count()}, stop{spec.count()}; + for (auto& test : spec.thread_funcs) { + threads.emplace_back(threads.size(), cpu_ids[threads.size()], start, stop, &test, iters, use_aperf); + } + + results_list.emplace_back(&spec); + for (auto& t : threads) { + t.thread.join(); + results_list.back().results.push_back(t.res); + } + } + + report_results(results_list, use_aperf); + + return EXIT_SUCCESS; +} + + + + diff --git a/tools/avx-turbo/check-uarch.sh b/tools/avx-turbo/check-uarch.sh new file mode 100755 index 00000000..6c6246c9 --- /dev/null +++ b/tools/avx-turbo/check-uarch.sh @@ -0,0 +1,33 @@ +#!/bin/bash +set -e + +# runs Intel SDE to check that ./avx-turbo works for every arch +all_arch=( \ + p4p \ + mrm \ + pnr \ + nhm \ + wsm \ + snb \ + ivb \ + hsw \ + bdw \ + slt \ + slm \ + glm \ + tnt \ + skl \ + clx \ + skx \ + cnl \ + icl \ + icx \ + knl \ + knm \ + future \ +) + +for arch in "${all_arch[@]}"; do + echo "Testing arch=$arch with SDE" + sde64 -${arch} -- ./avx-turbo --max-threads=1 +done \ No newline at end of file diff --git a/tools/avx-turbo/config.mk b/tools/avx-turbo/config.mk new file mode 100644 index 00000000..dbd04092 --- /dev/null +++ b/tools/avx-turbo/config.mk @@ -0,0 +1,16 @@ +-include local.mk + +# set DEBUG to 1 to enable various debugging checks +DEBUG ?= 0 + +# The assembler to use. Defaults to nasm, but can also be set to yasm which has better +# debug info handling. +ASM ?= ./nasm-2.13.03/nasm + +ifeq ($(DEBUG),1) +O_LEVEL ?= -O0 +NASM_DEBUG ?= 1 +else +O_LEVEL ?= -O2 +NASM_DEBUG ?= 0 +endif diff --git a/tools/avx-turbo/cpu.c b/tools/avx-turbo/cpu.c new file mode 100644 index 00000000..a42940ed --- /dev/null +++ b/tools/avx-turbo/cpu.c @@ -0,0 +1,165 @@ +/* CPU Information (v1) + * Portable Snippets - https://gitub.com/nemequ/portable-snippets + * Created by Evan Nemerson + * + * To the extent possible under law, the authors have waived all + * copyright and related or neighboring rights to this code. For + * details, see the Creative Commons Zero 1.0 Universal license at + * https://creativecommons.org/publicdomain/zero/1.0/ + */ + +#include "cpu.h" + +#include "once.h" + +#include + +#if defined(_WIN32) +# include +# define PSNIP_CPU__IMPL_WIN32 +#elif defined(unix) || defined(__unix__) || defined(__unix) +# include +# if defined(_SC_NPROCESSORS_ONLN) || defined(_SC_NPROC_ONLN) +# define PSNIP_CPU__IMPL_SYSCONF +# else +# include +# endif +#endif + +#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64) +# if defined(_MSC_VER) +static void psnip_cpu_getid(int func, int* data) { + __cpuid(data, func); +} +# else +static void psnip_cpu_getid(int func, int* data) { + __asm__ ("cpuid" + : "=a" (data[0]), "=b" (data[1]), "=c" (data[2]), "=d" (data[3]) + : "0" (func), "2" (0)); +} +# endif +#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM64) +# if (defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 16))) +# define PSNIP_CPU__IMPL_GETAUXVAL +# include +# endif +#endif + +static psnip_once psnip_cpu_once = PSNIP_ONCE_INIT; + +#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64) +static unsigned int psnip_cpuinfo[8 * 4] = { 0, }; +#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64) +static unsigned long psnip_cpuinfo[2] = { 0, }; +#endif + +static void psnip_cpu_init(void) { +#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64) + int i; + for (i = 0 ; i < 8 ; i++) { + psnip_cpu_getid(i, (int*) &(psnip_cpuinfo[i * 4])); + } +#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64) + psnip_cpuinfo[0] = getauxval (AT_HWCAP); + psnip_cpuinfo[1] = getauxval (AT_HWCAP2); +#endif +} + +int +psnip_cpu_feature_check (enum PSnipCPUFeature feature) { +#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64) + unsigned int i, r, b; +#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64) + unsigned long b, i; +#endif + +#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64) + if ((feature & PSNIP_CPU_FEATURE_CPU_MASK) != PSNIP_CPU_FEATURE_X86) + return 0; +#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64) + if ((feature & PSNIP_CPU_FEATURE_CPU_MASK) != PSNIP_CPU_FEATURE_ARM) + return 0; +#else + return 0; +#endif + + feature &= (enum PSnipCPUFeature) ~PSNIP_CPU_FEATURE_CPU_MASK; +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4152) +#endif + psnip_once_call (&psnip_cpu_once, psnip_cpu_init); +#if defined(_MSC_VER) +#pragma warning(pop) +#endif + +#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64) + i = (feature >> 16) & 0xff; + r = (feature >> 8) & 0xff; + b = (feature ) & 0xff; + + if (i > 7 || r > 3 || b > 31) + return 0; + + return (psnip_cpuinfo[(i * 4) + r] >> b) & 1; +#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64) + b = 1 << ((feature & 0xff) - 1); + i = psnip_cpuinfo[(feature >> 0x08) & 0xff]; + return (psnip_cpuinfo[(feature >> 0x08) & 0xff] & b) == b; +#endif +} + +int +psnip_cpu_feature_check_many (enum PSnipCPUFeature* feature) { + int n; + + for (n = 0 ; feature[n] != PSNIP_CPU_FEATURE_NONE ; n++) + if (!psnip_cpu_feature_check(feature[n])) + return 0; + + return 1; +} + +int +psnip_cpu_count (void) { + static int count = 0; + int c; + +#if defined(_WIN32) + DWORD_PTR lpProcessAffinityMask; + DWORD_PTR lpSystemAffinityMask; + int i; +#elif defined(PSNIP_CPU__IMPL_SYSCONF) && defined(HW_NCPU) + int mib[2]; + size_t len; +#endif + + if (count != 0) + return count; + +#if defined(_WIN32) + if (!GetProcessAffinityMask(GetCurrentProcess(), &lpProcessAffinityMask, &lpSystemAffinityMask)) { + c = -1; + } else { + c = 0; + for (i = 0 ; lpProcessAffinityMask != 0 ; lpProcessAffinityMask >>= 1) + c += lpProcessAffinityMask & 1; + } +#elif defined(_SC_NPROCESSORS_ONLN) + c = sysconf (_SC_NPROCESSORS_ONLN); +#elif defined(_SC_NPROC_ONLN) + c = sysconf (_SC_NPROC_ONLN); +#elif defined(_hpux) + c = mpctl(MPC_GETNUMSPUS, NULL, NULL); +#elif defined(HW_NCPU) + c = 0; + mib[0] = CTL_HW; + mib[1] = HW_NCPU; + len = sizeof(c); + sysctl (mib, 2, &c, &len, NULL, 0); +#endif + + count = (c > 0) ? c : -1; + + return count; +} diff --git a/tools/avx-turbo/cpu.h b/tools/avx-turbo/cpu.h new file mode 100644 index 00000000..160109b2 --- /dev/null +++ b/tools/avx-turbo/cpu.h @@ -0,0 +1,190 @@ +/* CPU Information (v1) + * Portable Snippets - https://gitub.com/nemequ/portable-snippets + * Created by Evan Nemerson + * + * To the extent possible under law, the authors have waived all + * copyright and related or neighboring rights to this code. For + * details, see the Creative Commons Zero 1.0 Universal license at + * https://creativecommons.org/publicdomain/zero/1.0/ + */ + +#if !defined(PSNIP_CPU__H) +#define PSNIP_CPU__H + +#if defined(__x86_64__) || defined(_M_AMD64) || defined(_M_X64) +# define PSNIP_CPU_ARCH_X86_64 +#elif defined(__i686__) || defined(__i586__) || defined(__i486__) || defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(_X86_) || defined(__THW_INTEL__) +# define PSNIP_CPU_ARCH_X86 +#elif defined(__arm__) || defined(_M_ARM) +# define PSNIP_CPU_ARCH_ARM +#elif defined(__aarch64__) +# define PSNIP_CPU_ARCH_ARM64 +#endif + +#if defined(__cplusplus) +extern "C" { +#endif + +enum PSnipCPUFeature { + PSNIP_CPU_FEATURE_NONE = 0, + + PSNIP_CPU_FEATURE_CPU_MASK = 0x1f000000, + PSNIP_CPU_FEATURE_X86 = 0x01000000, + PSNIP_CPU_FEATURE_ARM = 0x04000000, + + /* x86 CPU features are constructed as: + * + * (PSNIP_CPU_FEATURE_X86 | (eax << 16) | (ret_reg << 8) | (bit_position) + * + * For example, SSE3 is determined by the fist bit in the ECX + * register for a CPUID call with EAX=1, so we get: + * + * PSNIP_CPU_FEATURE_X86 | (1 << 16) | (2 << 8) | (0) = 0x01010200 + * + * We should have information for inputs of EAX=0-7 w/ ECX=0. + */ + PSNIP_CPU_FEATURE_X86_FPU = 0x01010300, + PSNIP_CPU_FEATURE_X86_VME = 0x01010301, + PSNIP_CPU_FEATURE_X86_DE = 0x01010302, + PSNIP_CPU_FEATURE_X86_PSE = 0x01010303, + PSNIP_CPU_FEATURE_X86_TSC = 0x01010304, + PSNIP_CPU_FEATURE_X86_MSR = 0x01010305, + PSNIP_CPU_FEATURE_X86_PAE = 0x01010306, + PSNIP_CPU_FEATURE_X86_MCE = 0x01010307, + PSNIP_CPU_FEATURE_X86_CX8 = 0x01010308, + PSNIP_CPU_FEATURE_X86_APIC = 0x01010309, + PSNIP_CPU_FEATURE_X86_SEP = 0x0101030b, + PSNIP_CPU_FEATURE_X86_MTRR = 0x0101030c, + PSNIP_CPU_FEATURE_X86_PGE = 0x0101030d, + PSNIP_CPU_FEATURE_X86_MCA = 0x0101030e, + PSNIP_CPU_FEATURE_X86_CMOV = 0x0101030f, + PSNIP_CPU_FEATURE_X86_PAT = 0x01010310, + PSNIP_CPU_FEATURE_X86_PSE_36 = 0x01010311, + PSNIP_CPU_FEATURE_X86_PSN = 0x01010312, + PSNIP_CPU_FEATURE_X86_CLFSH = 0x01010313, + PSNIP_CPU_FEATURE_X86_DS = 0x01010314, + PSNIP_CPU_FEATURE_X86_ACPI = 0x01010316, + PSNIP_CPU_FEATURE_X86_MMX = 0x01010317, + PSNIP_CPU_FEATURE_X86_FXSR = 0x01010318, + PSNIP_CPU_FEATURE_X86_SSE = 0x01010319, + PSNIP_CPU_FEATURE_X86_SSE2 = 0x0101031a, + PSNIP_CPU_FEATURE_X86_SS = 0x0101031b, + PSNIP_CPU_FEATURE_X86_HTT = 0x0101031c, + PSNIP_CPU_FEATURE_X86_TM = 0x0101031d, + PSNIP_CPU_FEATURE_X86_IA64 = 0x0101031e, + PSNIP_CPU_FEATURE_X86_PBE = 0x0101031f, + + PSNIP_CPU_FEATURE_X86_SSE3 = 0x01010200, + PSNIP_CPU_FEATURE_X86_PCLMULQDQ = 0x01010201, + PSNIP_CPU_FEATURE_X86_DTES64 = 0x01010202, + PSNIP_CPU_FEATURE_X86_MONITOR = 0x01010203, + PSNIP_CPU_FEATURE_X86_DS_CPL = 0x01010204, + PSNIP_CPU_FEATURE_X86_VMX = 0x01010205, + PSNIP_CPU_FEATURE_X86_SMX = 0x01010206, + PSNIP_CPU_FEATURE_X86_EST = 0x01010207, + PSNIP_CPU_FEATURE_X86_TM2 = 0x01010208, + PSNIP_CPU_FEATURE_X86_SSSE3 = 0x01010209, + PSNIP_CPU_FEATURE_X86_CNXT_ID = 0x0101020a, + PSNIP_CPU_FEATURE_X86_SDBG = 0x0101020b, + PSNIP_CPU_FEATURE_X86_FMA = 0x0101020c, + PSNIP_CPU_FEATURE_X86_CX16 = 0x0101020d, + PSNIP_CPU_FEATURE_X86_XTPR = 0x0101020e, + PSNIP_CPU_FEATURE_X86_PDCM = 0x0101020f, + PSNIP_CPU_FEATURE_X86_PCID = 0x01010211, + PSNIP_CPU_FEATURE_X86_DCA = 0x01010212, + PSNIP_CPU_FEATURE_X86_SSE4_1 = 0x01010213, + PSNIP_CPU_FEATURE_X86_SSE4_2 = 0x01010214, + PSNIP_CPU_FEATURE_X86_X2APIC = 0x01010215, + PSNIP_CPU_FEATURE_X86_MOVBE = 0x01010216, + PSNIP_CPU_FEATURE_X86_POPCNT = 0x01010217, + PSNIP_CPU_FEATURE_X86_TSC_DEADLINE = 0x01010218, + PSNIP_CPU_FEATURE_X86_AES = 0x01010219, + PSNIP_CPU_FEATURE_X86_XSAVE = 0x0101021a, + PSNIP_CPU_FEATURE_X86_OSXSAVE = 0x0101021b, + PSNIP_CPU_FEATURE_X86_AVX = 0x0101021c, + PSNIP_CPU_FEATURE_X86_F16C = 0x0101021d, + PSNIP_CPU_FEATURE_X86_RDRND = 0x0101021e, + PSNIP_CPU_FEATURE_X86_HYPERVISOR = 0x0101021f, + + PSNIP_CPU_FEATURE_X86_FSGSBASE = 0x01070100, + PSNIP_CPU_FEATURE_X86_TSC_ADJ = 0x01070101, + PSNIP_CPU_FEATURE_X86_SGX = 0x01070102, + PSNIP_CPU_FEATURE_X86_BMI1 = 0x01070103, + PSNIP_CPU_FEATURE_X86_HLE = 0x01070104, + PSNIP_CPU_FEATURE_X86_AVX2 = 0x01070105, + PSNIP_CPU_FEATURE_X86_SMEP = 0x01070107, + PSNIP_CPU_FEATURE_X86_BMI2 = 0x01070108, + PSNIP_CPU_FEATURE_X86_ERMS = 0x01070109, + PSNIP_CPU_FEATURE_X86_INVPCID = 0x0107010a, + PSNIP_CPU_FEATURE_X86_RTM = 0x0107010b, + PSNIP_CPU_FEATURE_X86_PQM = 0x0107010c, + PSNIP_CPU_FEATURE_X86_MPX = 0x0107010e, + PSNIP_CPU_FEATURE_X86_PQE = 0x0107010f, + PSNIP_CPU_FEATURE_X86_AVX512F = 0x01070110, + PSNIP_CPU_FEATURE_X86_AVX512DQ = 0x01070111, + PSNIP_CPU_FEATURE_X86_RDSEED = 0x01070112, + PSNIP_CPU_FEATURE_X86_ADX = 0x01070113, + PSNIP_CPU_FEATURE_X86_SMAP = 0x01070114, + PSNIP_CPU_FEATURE_X86_AVX512IFMA = 0x01070115, + PSNIP_CPU_FEATURE_X86_PCOMMIT = 0x01070116, + PSNIP_CPU_FEATURE_X86_CLFLUSHOPT = 0x01070117, + PSNIP_CPU_FEATURE_X86_CLWB = 0x01070118, + PSNIP_CPU_FEATURE_X86_INTEL_PT = 0x01070119, + PSNIP_CPU_FEATURE_X86_AVX512PF = 0x0107011a, + PSNIP_CPU_FEATURE_X86_AVX512ER = 0x0107011b, + PSNIP_CPU_FEATURE_X86_AVX512CD = 0x0107011c, + PSNIP_CPU_FEATURE_X86_SHA = 0x0107011d, + PSNIP_CPU_FEATURE_X86_AVX512BW = 0x0107011e, + PSNIP_CPU_FEATURE_X86_AVX512VL = 0x0107011f, + + PSNIP_CPU_FEATURE_X86_PREFETCHWT1 = 0x01070200, + PSNIP_CPU_FEATURE_X86_AVX512VBMI = 0x01070201, + PSNIP_CPU_FEATURE_X86_UMIP = 0x01070202, + PSNIP_CPU_FEATURE_X86_PKU = 0x01070203, + PSNIP_CPU_FEATURE_X86_OSPKE = 0x01070204, + PSNIP_CPU_FEATURE_X86_AVX512VPOPCNTDQ = 0x0107020e, + PSNIP_CPU_FEATURE_X86_RDPID = 0x01070215, + PSNIP_CPU_FEATURE_X86_SGX_LC = 0x0107021e, + + PSNIP_CPU_FEATURE_X86_AVX512_4VNNIW = 0x01070302, + PSNIP_CPU_FEATURE_X86_AVX512_4FMAPS = 0x01070303, + + PSNIP_CPU_FEATURE_ARM_SWP = PSNIP_CPU_FEATURE_ARM | 1, + PSNIP_CPU_FEATURE_ARM_HALF = PSNIP_CPU_FEATURE_ARM | 2, + PSNIP_CPU_FEATURE_ARM_THUMB = PSNIP_CPU_FEATURE_ARM | 3, + PSNIP_CPU_FEATURE_ARM_26BIT = PSNIP_CPU_FEATURE_ARM | 4, + PSNIP_CPU_FEATURE_ARM_FAST_MULT = PSNIP_CPU_FEATURE_ARM | 5, + PSNIP_CPU_FEATURE_ARM_FPA = PSNIP_CPU_FEATURE_ARM | 6, + PSNIP_CPU_FEATURE_ARM_VFP = PSNIP_CPU_FEATURE_ARM | 7, + PSNIP_CPU_FEATURE_ARM_EDSP = PSNIP_CPU_FEATURE_ARM | 8, + PSNIP_CPU_FEATURE_ARM_JAVA = PSNIP_CPU_FEATURE_ARM | 9, + PSNIP_CPU_FEATURE_ARM_IWMMXT = PSNIP_CPU_FEATURE_ARM | 10, + PSNIP_CPU_FEATURE_ARM_CRUNCH = PSNIP_CPU_FEATURE_ARM | 11, + PSNIP_CPU_FEATURE_ARM_THUMBEE = PSNIP_CPU_FEATURE_ARM | 12, + PSNIP_CPU_FEATURE_ARM_NEON = PSNIP_CPU_FEATURE_ARM | 13, + PSNIP_CPU_FEATURE_ARM_VFPV3 = PSNIP_CPU_FEATURE_ARM | 14, + PSNIP_CPU_FEATURE_ARM_VFPV3D16 = PSNIP_CPU_FEATURE_ARM | 15, + PSNIP_CPU_FEATURE_ARM_TLS = PSNIP_CPU_FEATURE_ARM | 16, + PSNIP_CPU_FEATURE_ARM_VFPV4 = PSNIP_CPU_FEATURE_ARM | 17, + PSNIP_CPU_FEATURE_ARM_IDIVA = PSNIP_CPU_FEATURE_ARM | 18, + PSNIP_CPU_FEATURE_ARM_IDIVT = PSNIP_CPU_FEATURE_ARM | 19, + PSNIP_CPU_FEATURE_ARM_VFPD32 = PSNIP_CPU_FEATURE_ARM | 20, + PSNIP_CPU_FEATURE_ARM_LPAE = PSNIP_CPU_FEATURE_ARM | 21, + PSNIP_CPU_FEATURE_ARM_EVTSTRM = PSNIP_CPU_FEATURE_ARM | 22, + + PSNIP_CPU_FEATURE_ARM_AES = PSNIP_CPU_FEATURE_ARM | 0x0100 | 1, + PSNIP_CPU_FEATURE_ARM_PMULL = PSNIP_CPU_FEATURE_ARM | 0x0100 | 2, + PSNIP_CPU_FEATURE_ARM_SHA1 = PSNIP_CPU_FEATURE_ARM | 0x0100 | 3, + PSNIP_CPU_FEATURE_ARM_SHA2 = PSNIP_CPU_FEATURE_ARM | 0x0100 | 4, + PSNIP_CPU_FEATURE_ARM_CRC32 = PSNIP_CPU_FEATURE_ARM | 0x0100 | 5 +}; + +int psnip_cpu_count (void); +int psnip_cpu_feature_check (enum PSnipCPUFeature feature); +int psnip_cpu_feature_check_many (enum PSnipCPUFeature* feature); + +#if defined(__cplusplus) +} +#endif + +#endif /* PSNIP_CPU__H */ diff --git a/tools/avx-turbo/cpuid.cpp b/tools/avx-turbo/cpuid.cpp new file mode 100644 index 00000000..f96f61f2 --- /dev/null +++ b/tools/avx-turbo/cpuid.cpp @@ -0,0 +1,123 @@ +/* + * cpuid.cpp + */ + +#include "cpuid.hpp" + +#include + +using std::uint8_t; +using std::uint32_t; + + +std::string cpuid_result::to_string() { + std::string s; + s += "eax = " + std::to_string(eax) + ", "; + s += "ebx = " + std::to_string(ebx) + ", "; + s += "ecx = " + std::to_string(ecx) + ", "; + s += "edx = " + std::to_string(edx); + return s; +} + +uint32_t cpuid_highest_leaf_inner() { + return cpuid(0).eax; +} + +uint32_t cpuid_highest_leaf() { + static uint32_t cached = cpuid_highest_leaf_inner(); + return cached; +} + +cpuid_result cpuid(int leaf, int subleaf) { + cpuid_result ret = {}; + asm ("cpuid" + : + "=a" (ret.eax), + "=b" (ret.ebx), + "=c" (ret.ecx), + "=d" (ret.edx) + : + "a" (leaf), + "c" (subleaf) + ); + return ret; +} + +cpuid_result cpuid(int leaf) { + return cpuid(leaf, 0); +} + +family_model gfm_inner() { + auto cpuid1 = cpuid(1); + family_model ret; + ret.family = (cpuid1.eax >> 8) & 0xF; + ret.model = (cpuid1.eax >> 4) & 0xF; + ret.stepping = (cpuid1.eax ) & 0xF; + if (ret.family == 15) { + ret.family += (cpuid1.eax >> 20) & 0xFF; // extended family + } + if (ret.family == 15 || ret.family == 6) { + ret.model += ((cpuid1.eax >> 16) & 0xF) << 4; // extended model + } + return ret; +} + +family_model get_family_model() { + static family_model cached_family_model = gfm_inner(); + return cached_family_model; +} + +std::string get_brand_string() { + auto check = cpuid(0x80000000); + if (check.eax < 0x80000004) { + return std::string("unkown (eax =") + std::to_string(check.eax) +")"; + } + std::string ret; + for (uint32_t eax : {0x80000002, 0x80000003, 0x80000004}) { + char buf[17]; + auto fourchars = cpuid(eax); + memcpy(buf + 0, &fourchars.eax, 4); + memcpy(buf + 4, &fourchars.ebx, 4); + memcpy(buf + 8, &fourchars.ecx, 4); + memcpy(buf + 12, &fourchars.edx, 4); + buf[16] = '\0'; + ret += buf; + } + return ret; +} + +/* get bits [start:end] inclusive of the given value */ +uint32_t get_bits(uint32_t value, int start, int end) { + value >>= start; + uint32_t mask = ((uint64_t)-1) << (end - start + 1); + return value & ~mask; +} + +/** + * Get the shift amount for unique physical core IDs + */ +int get_smt_shift() +{ + if (cpuid_highest_leaf() < 0xb) { + return -1; + } + uint32_t smtShift = -1u; + for (uint32_t subleaf = 0; ; subleaf++) { + cpuid_result leafb = cpuid(0xb, subleaf); + uint32_t type = get_bits(leafb.ecx, 8 ,15); + if (!get_bits(leafb.ebx,0,15) || type == 0) { + // done + break; + } + if (type == 1) { + // here's the value we are after: make sure we don't have more than one entry for + // this type though! + if (smtShift != -1u) { + fprintf(stderr, "Warning: more than one level of type 1 in the x2APIC hierarchy"); + } + smtShift = get_bits(leafb.eax, 0, 4); + } + } + return smtShift; +} + diff --git a/tools/avx-turbo/cpuid.hpp b/tools/avx-turbo/cpuid.hpp new file mode 100644 index 00000000..7d6802d0 --- /dev/null +++ b/tools/avx-turbo/cpuid.hpp @@ -0,0 +1,48 @@ +/* + * cpuid.hpp + */ + +#ifndef CPUID_HPP_ +#define CPUID_HPP_ + +#include +#include + +struct cpuid_result { + std::uint32_t eax, ebx, ecx, edx; + std::string to_string(); +}; + +struct family_model { + uint8_t family; + uint8_t model; + uint8_t stepping; + std::string to_string() { + std::string s; + s += "family = " + std::to_string(family) + ", "; + s += "model = " + std::to_string(model) + ", "; + s += "stepping = " + std::to_string(stepping); + return s; + } +}; + + +/** the highest supported leaf value */ +uint32_t cpuid_highest_leaf(); + +/* return the CPUID result for querying the given leaf (EAX) and no subleaf (ECX=0) */ +cpuid_result cpuid(int leaf); + +/* return the CPUID result for querying the given leaf (EAX) and subleaf (ECX) */ +cpuid_result cpuid(int leaf, int subleaf); + +family_model get_family_model(); + +std::string get_brand_string(); + +int get_smt_shift(); + +/* get bits [start:end] inclusive of the given value */ +uint32_t get_bits(uint32_t value, int start, int end); + +#endif /* CPUID_HPP_ */ diff --git a/tools/avx-turbo/exact-int.h b/tools/avx-turbo/exact-int.h new file mode 100644 index 00000000..918b8f76 --- /dev/null +++ b/tools/avx-turbo/exact-int.h @@ -0,0 +1,229 @@ +/* Exact-width integer types + * Portable Snippets - https://gitub.com/nemequ/portable-snippets + * Created by Evan Nemerson + * + * To the extent possible under law, the authors have waived all + * copyright and related or neighboring rights to this code. For + * details, see the Creative Commons Zero 1.0 Universal license at + * https://creativecommons.org/publicdomain/zero/1.0/ + * + * This header tries to define psnip_(u)int(8|16|32|64)_t to + * appropriate types given your system. For most systems this means + * including and adding a few preprocessor definitions. + * + * If you prefer, you can define any necessary types yourself. + * Snippets in this repository which rely on these types will not + * attempt to include this header if you have already defined the + * types it uses. + */ + +#if !defined(PSNIP_EXACT_INT_H) +# define PSNIP_EXACT_INT_H +# if !defined(PSNIP_EXACT_INT_HAVE_STDINT) +# if defined(_STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) +# define PSNIP_EXACT_INT_HAVE_STDINT +# elif defined(__has_include) +# if __has_include() +# define PSNIP_EXACT_INT_HAVE_STDINT +# endif +# elif \ + defined(HAVE_STDINT_H) || \ + defined(_STDINT_H_INCLUDED) || \ + defined(_STDINT_H) || \ + defined(_STDINT_H_) +# define PSNIP_EXACT_INT_HAVE_STDINT +# elif \ + (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))) || \ + (defined(_MSC_VER) && (_MSC_VER >= 1600)) || \ + (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x570)) || \ + (defined(__WATCOMC__) && (__WATCOMC__ >= 1250)) +# define PSNIP_EXACT_INT_HAVE_STDINT +# endif +# endif + +# if \ + defined(__INT8_TYPE__) && defined(__INT16_TYPE__) && defined(__INT32_TYPE__) && defined(__INT64_TYPE__) && \ + defined(__UINT8_TYPE__) && defined(__UINT16_TYPE__) && defined(__UINT32_TYPE__) && defined(__UINT64_TYPE__) +# define psnip_int8_t __INT8_TYPE__ +# define psnip_int16_t __INT16_TYPE__ +# define psnip_int32_t __INT32_TYPE__ +# define psnip_int64_t __INT64_TYPE__ +# define psnip_uint8_t __UINT8_TYPE__ +# define psnip_uint16_t __UINT16_TYPE__ +# define psnip_uint32_t __UINT32_TYPE__ +# define psnip_uint64_t __UINT64_TYPE__ +# elif defined(PSNIP_EXACT_INT_HAVE_STDINT) +# include +# if !defined(psnip_int8_t) +# define psnip_int8_t int8_t +# endif +# if !defined(psnip_uint8_t) +# define psnip_uint8_t uint8_t +# endif +# if !defined(psnip_int16_t) +# define psnip_int16_t int16_t +# endif +# if !defined(psnip_uint16_t) +# define psnip_uint16_t uint16_t +# endif +# if !defined(psnip_int32_t) +# define psnip_int32_t int32_t +# endif +# if !defined(psnip_uint32_t) +# define psnip_uint32_t uint32_t +# endif +# if !defined(psnip_int64_t) +# define psnip_int64_t int64_t +# endif +# if !defined(psnip_uint64_t) +# define psnip_uint64_t uint64_t +# endif +# elif defined(_MSC_VER) +# if !defined(psnip_int8_t) +# define psnip_int8_t __int8 +# endif +# if !defined(psnip_uint8_t) +# define psnip_uint8_t unsigned __int8 +# endif +# if !defined(psnip_int16_t) +# define psnip_int16_t __int16 +# endif +# if !defined(psnip_uint16_t) +# define psnip_uint16_t unsigned __int16 +# endif +# if !defined(psnip_int32_t) +# define psnip_int32_t __int32 +# endif +# if !defined(psnip_uint32_t) +# define psnip_uint32_t unsigned __int32 +# endif +# if !defined(psnip_int64_t) +# define psnip_int64_t __int64 +# endif +# if !defined(psnip_uint64_t) +# define psnip_uint64_t unsigned __int64 +# endif +# else +# include +# if !defined(psnip_int8_t) +# if defined(CHAR_MIN) && defined(CHAR_MAX) && (CHAR_MIN == (-127-1)) && (CHAR_MAX == 127) +# define psnip_int8_t char +# elif defined(SHRT_MIN) && defined(SHRT_MAX) && (SHRT_MIN == (-127-1)) && (SHRT_MAX == 127) +# define psnip_int8_t short +# elif defined(INT_MIN) && defined(INT_MAX) && (INT_MIN == (-127-1)) && (INT_MAX == 127) +# define psnip_int8_t int +# elif defined(LONG_MIN) && defined(LONG_MAX) && (LONG_MIN == (-127-1)) && (LONG_MAX == 127) +# define psnip_int8_t long +# elif defined(LLONG_MIN) && defined(LLONG_MAX) && (LLONG_MIN == (-127-1)) && (LLONG_MAX == 127) +# define psnip_int8_t long long +# else +# error Unable to locate 8-bit signed integer type. +# endif +# endif +# if !defined(psnip_uint8_t) +# if defined(UCHAR_MAX) && (UCHAR_MAX == 255) +# define psnip_uint8_t unsigned char +# elif defined(USHRT_MAX) && (USHRT_MAX == 255) +# define psnip_uint8_t unsigned short +# elif defined(UINT_MAX) && (UINT_MAX == 255) +# define psnip_uint8_t unsigned int +# elif defined(ULONG_MAX) && (ULONG_MAX == 255) +# define psnip_uint8_t unsigned long +# elif defined(ULLONG_MAX) && (ULLONG_MAX == 255) +# define psnip_uint8_t unsigned long long +# else +# error Unable to locate 8-bit unsigned integer type. +# endif +# endif +# if !defined(psnip_int16_t) +# if defined(CHAR_MIN) && defined(CHAR_MAX) && (CHAR_MIN == (-32767-1)) && (CHAR_MAX == 32767) +# define psnip_int16_t char +# elif defined(SHRT_MIN) && defined(SHRT_MAX) && (SHRT_MIN == (-32767-1)) && (SHRT_MAX == 32767) +# define psnip_int16_t short +# elif defined(INT_MIN) && defined(INT_MAX) && (INT_MIN == (-32767-1)) && (INT_MAX == 32767) +# define psnip_int16_t int +# elif defined(LONG_MIN) && defined(LONG_MAX) && (LONG_MIN == (-32767-1)) && (LONG_MAX == 32767) +# define psnip_int16_t long +# elif defined(LLONG_MIN) && defined(LLONG_MAX) && (LLONG_MIN == (-32767-1)) && (LLONG_MAX == 32767) +# define psnip_int16_t long long +# else +# error Unable to locate 16-bit signed integer type. +# endif +# endif +# if !defined(psnip_uint16_t) +# if defined(UCHAR_MAX) && (UCHAR_MAX == 65535) +# define psnip_uint16_t unsigned char +# elif defined(USHRT_MAX) && (USHRT_MAX == 65535) +# define psnip_uint16_t unsigned short +# elif defined(UINT_MAX) && (UINT_MAX == 65535) +# define psnip_uint16_t unsigned int +# elif defined(ULONG_MAX) && (ULONG_MAX == 65535) +# define psnip_uint16_t unsigned long +# elif defined(ULLONG_MAX) && (ULLONG_MAX == 65535) +# define psnip_uint16_t unsigned long long +# else +# error Unable to locate 16-bit unsigned integer type. +# endif +# endif +# if !defined(psnip_int32_t) +# if defined(CHAR_MIN) && defined(CHAR_MAX) && (CHAR_MIN == (-2147483647-1)) && (CHAR_MAX == 2147483647) +# define psnip_int32_t char +# elif defined(SHRT_MIN) && defined(SHRT_MAX) && (SHRT_MIN == (-2147483647-1)) && (SHRT_MAX == 2147483647) +# define psnip_int32_t short +# elif defined(INT_MIN) && defined(INT_MAX) && (INT_MIN == (-2147483647-1)) && (INT_MAX == 2147483647) +# define psnip_int32_t int +# elif defined(LONG_MIN) && defined(LONG_MAX) && (LONG_MIN == (-2147483647-1)) && (LONG_MAX == 2147483647) +# define psnip_int32_t long +# elif defined(LLONG_MIN) && defined(LLONG_MAX) && (LLONG_MIN == (-2147483647-1)) && (LLONG_MAX == 2147483647) +# define psnip_int32_t long long +# else +# error Unable to locate 32-bit signed integer type. +# endif +# endif +# if !defined(psnip_uint32_t) +# if defined(UCHAR_MAX) && (UCHAR_MAX == 4294967295) +# define psnip_uint32_t unsigned char +# elif defined(USHRT_MAX) && (USHRT_MAX == 4294967295) +# define psnip_uint32_t unsigned short +# elif defined(UINT_MAX) && (UINT_MAX == 4294967295) +# define psnip_uint32_t unsigned int +# elif defined(ULONG_MAX) && (ULONG_MAX == 4294967295) +# define psnip_uint32_t unsigned long +# elif defined(ULLONG_MAX) && (ULLONG_MAX == 4294967295) +# define psnip_uint32_t unsigned long long +# else +# error Unable to locate 32-bit unsigned integer type. +# endif +# endif +# if !defined(psnip_int64_t) +# if defined(CHAR_MIN) && defined(CHAR_MAX) && (CHAR_MIN == (-9223372036854775807LL-1)) && (CHAR_MAX == 9223372036854775807LL) +# define psnip_int64_t char +# elif defined(SHRT_MIN) && defined(SHRT_MAX) && (SHRT_MIN == (-9223372036854775807LL-1)) && (SHRT_MAX == 9223372036854775807LL) +# define psnip_int64_t short +# elif defined(INT_MIN) && defined(INT_MAX) && (INT_MIN == (-9223372036854775807LL-1)) && (INT_MAX == 9223372036854775807LL) +# define psnip_int64_t int +# elif defined(LONG_MIN) && defined(LONG_MAX) && (LONG_MIN == (-9223372036854775807LL-1)) && (LONG_MAX == 9223372036854775807LL) +# define psnip_int64_t long +# elif defined(LLONG_MIN) && defined(LLONG_MAX) && (LLONG_MIN == (-9223372036854775807LL-1)) && (LLONG_MAX == 9223372036854775807LL) +# define psnip_int64_t long long +# else +# error Unable to locate 64-bit signed integer type. +# endif +# endif +# if !defined(psnip_uint64_t) +# if defined(UCHAR_MAX) && (UCHAR_MAX == 18446744073709551615ULL) +# define psnip_uint64_t unsigned char +# elif defined(USHRT_MAX) && (USHRT_MAX == 18446744073709551615ULL) +# define psnip_uint64_t unsigned short +# elif defined(UINT_MAX) && (UINT_MAX == 18446744073709551615ULL) +# define psnip_uint64_t unsigned int +# elif defined(ULONG_MAX) && (ULONG_MAX == 18446744073709551615ULL) +# define psnip_uint64_t unsigned long +# elif defined(ULLONG_MAX) && (ULLONG_MAX == 18446744073709551615ULL) +# define psnip_uint64_t unsigned long long +# else +# error Unable to locate 64-bit unsigned integer type. +# endif +# endif +# endif +#endif diff --git a/tools/avx-turbo/msr-access.c b/tools/avx-turbo/msr-access.c new file mode 100644 index 00000000..902aee4b --- /dev/null +++ b/tools/avx-turbo/msr-access.c @@ -0,0 +1,129 @@ +/* + * msr-access.c + */ + +// for pread() and sched_getcpu() +#define _GNU_SOURCE + +#include "msr-access.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** if there are this many CPUs or less, we'll never allocate memory */ +#define STATIC_ARRAY_SIZE 32 + +#ifndef MSR_USE_PTHREADS +// thread-safe by default +#define MSR_USE_PTHREADS 1 +#endif + +#if MSR_USE_PTHREADS +#include +static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; +void lock() { + pthread_mutex_lock(&mutex); +} +void unlock() { + pthread_mutex_unlock(&mutex); +} +#else +void lock() {} +void unlock(){} +#endif + + + +/* size of the rfile array */ +int rfile_static[STATIC_ARRAY_SIZE] = {}; +int rfile_size = STATIC_ARRAY_SIZE; +int *rfile_array = rfile_static; +//int rfile_error; + +/** get the read-only file associated with the given cpu */ +int get_rfile(int cpu) { + assert(cpu >= 0); + + lock(); + + if (cpu >= rfile_size) { + // expand array + size_t new_size = rfile_size * 2 > cpu ? rfile_size * 2 : cpu; + int *new_array = calloc(new_size, sizeof(int)); + memcpy(new_array, rfile_array, rfile_size * sizeof(int)); + if (rfile_array != rfile_static) { + free(rfile_array); + } + rfile_array = new_array; + rfile_size = new_size; + } + + if (rfile_array[cpu] == 0) { + char filename[64] = {}; + int ret = snprintf(filename, 64, "/dev/cpu/%d/msr", cpu); + assert(ret > 0); + rfile_array[cpu] = open(filename, O_RDONLY); + if (rfile_array[cpu] == -1) { + rfile_array[cpu] = -errno; + } + } + + int ret = rfile_array[cpu]; + + unlock(); + + return ret; +} + +int read_msr(int cpu, uint32_t msr_index, uint64_t* value) { + int file = get_rfile(cpu); + assert(file); + if (file < 0) { + // file open failes are stored as negative errno + return file; + } + int read = pread(file, value, 8, msr_index); + return read == -1 ? errno : 0; +} + +int read_msr_cur_cpu(uint32_t msr_index, uint64_t* value) { + return read_msr(sched_getcpu(), msr_index, value); +} + + +// rename this to main to build an exe that can be run as ./a.out CPU MSR +// to read MSR from CPU (like a really simple rdmsr) +int test(int argc, char** argv) { + assert(argc == 3); + int cpu = atoi(argv[1]); + uint32_t msr = atoi(argv[2]); + printf("reading msr %u from cpu %d\n", msr, cpu); + uint64_t value = -1; + + int res = read_msr(cpu, msr, &value); + if (res) { + printf("error %d\n", res); + } else { + printf("value %lx\n", value); + } + + res = read_msr_cur_cpu(msr, &value); + if (res) { + printf("error %d\n", res); + } else { + printf("value %lx\n", value); + } + + return EXIT_SUCCESS; +} + + diff --git a/tools/avx-turbo/msr-access.h b/tools/avx-turbo/msr-access.h new file mode 100644 index 00000000..003a06fd --- /dev/null +++ b/tools/avx-turbo/msr-access.h @@ -0,0 +1,57 @@ +/* + * msr-access.h + * + * Simple API to access the x86 MSR registers exposed on linux with through the /dev/cpu/N/msr file system. + * + * Unless you've changed the msr permissions, only root can do this. The msr filesystem may not exist until + * 'modprobe msr' is executed to load the msr module. + */ + +#ifndef MSR_ACCESS_H_ +#define MSR_ACCESS_H_ + +#include +// you could get the MSR index values from the following header, although it isn't exported to user-space +// in kernels after 4.12, but you can grab it from the linux source +// #include + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * Read the MSR given by msr_index on the given cpu, storing the result into + * result, which must point to at least 8 bytes of storage. + * + * Returns zero on success, non-zero on failure. + * + * Negative values indicate errors + * opening the underlying MSR file: the value returned is the negative of the errno + * returned by the kernel when trying to open the file. These file errors is cached + * so once a negative value has been returned for a given cpu, subsequent calls will + * always return the same value. + * + * Positive values indicate failures during the pread call performed to actually read + * the msr from the open file. The value is the errno returned by the kernel after the + * read. The most common value is 5 (EIO) which indicates that you can't read that MSR + * on this hardware (e.g., if may not exist). + */ +int read_msr(int cpu, uint32_t msr_index, uint64_t* value); + +/** + * Reads the given MSR on the current CPU. This is just a shortcut for calling + * read_msr(sched_getcpu(), ...), and the result and error handling is the same as that function. + * + * Of course, unless the thread affinity has been restricted for the current thread, + * the result doesn't help the calling code know the true value on the current CPU since + * a context switch can happen at any time (the same caveat applies to getcpu()). + */ +int read_msr_cur_cpu(uint32_t msr_index, uint64_t* value); + + +#ifdef __cplusplus +} // extern "C" { +#endif + +#endif // #ifdef MSR_ACCESS_H_ diff --git a/tools/avx-turbo/nasm-2.13.03/LICENSE b/tools/avx-turbo/nasm-2.13.03/LICENSE new file mode 100644 index 00000000..331e2600 --- /dev/null +++ b/tools/avx-turbo/nasm-2.13.03/LICENSE @@ -0,0 +1,29 @@ +NASM is now licensed under the 2-clause BSD license, also known as the +simplified BSD license. + + Copyright 1996-2010 the NASM Authors - All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following + conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/tools/avx-turbo/nasm-2.13.03/NOTE b/tools/avx-turbo/nasm-2.13.03/NOTE new file mode 100644 index 00000000..dc673736 --- /dev/null +++ b/tools/avx-turbo/nasm-2.13.03/NOTE @@ -0,0 +1,3 @@ +This stable version of the nasm binary is here in avx-turbo since many version of nasm included in distributions are +capable of compiling AVX-512 (2.11 is required at a minimum). So we include the binary here along with the LICENSE +(which allows such binary distribution). diff --git a/tools/avx-turbo/nasm-2.13.03/nasm b/tools/avx-turbo/nasm-2.13.03/nasm new file mode 100755 index 0000000000000000000000000000000000000000..3da333e1ccf1fb6a86138d97169a9d93bf04c7b5 GIT binary patch literal 1470376 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
1poo(TjcstyG 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 ?v}-kAp1e=2@B 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

*)n&TLs@2m?hRbecWlKApc9qzJ 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
$3WY$MfSp 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 g_CTnLK&BC7CM}Ts2|Q=FIuy$Gtvd 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 literal 0 HcmV?d00001 diff --git a/tools/avx-turbo/nasm-utils-helper.c b/tools/avx-turbo/nasm-utils-helper.c new file mode 100644 index 00000000..aa4e38bb --- /dev/null +++ b/tools/avx-turbo/nasm-utils-helper.c @@ -0,0 +1,43 @@ +/* + * nasm-utils-helper.c + * + * C helper functions for some macros in nasm-utils-inc.asm. + * + * If you use any macros that require functionality defined here, just include this C file in + * your project (linked against the same object that contains the assembly generated with the + * help of nasm-utils-inc.asm). + */ + +#include +#include +#include +#include + + +// mapping from reg_id to register name +static const char *reg_names[] = { + "rbp", + "rbx", + "r12", + "r13", + "r14", + "r15" +}; + +/* called when a function using abi_checked_function detects an illegally clobbered register */ +void nasm_util_die_on_reg_clobber(const char *fname, unsigned reg_id) { + reg_id--; // reg ids are 1-based + if (reg_id >= sizeof(sizeof(reg_names)/sizeof(reg_names[0]))) { + fprintf(stderr, "FATAL: function %s clobbered a callee-saved register (thunk returned an invalid reg_id %d)\n", + fname, reg_id); + } else { + fprintf(stderr, "FATAL: function %s clobbered callee-saved register %s\n", fname, reg_names[reg_id]); + } + abort(); +} + +void nasm_util_assert_failed(const char *left, const char *right, const char *filename, int64_t line) { + fprintf(stderr, "%s:%ld : Assertion failed: %s == %s\n", filename, (long)line, left, right); + fflush(stderr); + abort(); +} diff --git a/tools/avx-turbo/nasm-utils-inc.asm b/tools/avx-turbo/nasm-utils-inc.asm new file mode 100644 index 00000000..e87c02cd --- /dev/null +++ b/tools/avx-turbo/nasm-utils-inc.asm @@ -0,0 +1,210 @@ +;; potentially useful macros for asm development + +;; long-nop instructions: nopX inserts a nop of X bytes +;; see "Table 4-12. Recommended Multi-Byte Sequence of NOP Instruction" in +;; "Intelยฎ 64 and IA-32 Architectures Software Developerโ€™s Manual" (325383-061US) +%define nop1 nop ; just a nop, included for completeness +%define nop2 db 0x66, 0x90 ; 66 NOP +%define nop3 db 0x0F, 0x1F, 0x00 ; NOP DWORD ptr [EAX] +%define nop4 db 0x0F, 0x1F, 0x40, 0x00 ; NOP DWORD ptr [EAX + 00H] +%define nop5 db 0x0F, 0x1F, 0x44, 0x00, 0x00 ; NOP DWORD ptr [EAX + EAX*1 + 00H] +%define nop6 db 0x66, 0x0F, 0x1F, 0x44, 0x00, 0x00 ; 66 NOP DWORD ptr [EAX + EAX*1 + 00H] +%define nop7 db 0x0F, 0x1F, 0x80, 0x00, 0x00, 0x00, 0x00 ; NOP DWORD ptr [EAX + 00000000H] +%define nop8 db 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 ; NOP DWORD ptr [EAX + EAX*1 + 00000000H] +%define nop9 db 0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 ; 66 NOP DWORD ptr [EAX + EAX*1 + 00000000H] + +;; push the 6 callee-saved registers defined in the the SysV C ABI +%macro push_callee_saved 0 +push rbp +push rbx +push r12 +push r13 +push r14 +push r15 +%endmacro + +;; pop the 6 callee-saved registers in the order compatible with push_callee_saved +%macro pop_callee_saved 0 +pop r15 +pop r14 +pop r13 +pop r12 +pop rbx +pop rbp +%endmacro + +EXTERN nasm_util_assert_failed + +; place the string value of a tken in .rodata using %defstr +; arg1 - the token to make into a string +; arg2 - label which will point to the string +%macro make_string_tok 2 +%ifdef __YASM_MAJOR__ +; yasm has no support for defstr so we just use a fixed string for now +; see https://github.com/travisdowns/nasm-utils/issues/1 +make_string 'make_string_tok yasm bug', %2 +%else +%defstr make_string_temp %1 +make_string make_string_temp, %2 +%endif +%endmacro + +%macro make_string 2 +[section .rodata] +%2: +db %1,0 +; restore the previous section +__SECT__ +%endmacro + +%macro nasm_util_assert_boilerplate 0 +make_string __FILE__, parent_filename +%define ASSERT_BOILERPLATE 1 +%endmacro + +%macro check_assert_boilerplate 0 +%ifndef ASSERT_BOILERPLATE +%error "To use asserts, you must include a call to nasm_util_assert_boilerplate once in each file" +%endif +%endmacro + +;; assembly level asserts +;; if the assert occurs, termination is assumed so control never passes back to the caller +;; and registers are not preserved +%macro assert_eq 2 +check_assert_boilerplate +cmp %1, %2 +je %%assert_ok +make_string_tok %1, %%assert_string1 +make_string_tok %2, %%assert_string2 +lea rdi, [%%assert_string1] +lea rsi, [%%assert_string2] +lea rdx, [parent_filename] +mov rcx, __LINE__ +jmp nasm_util_assert_failed +%%assert_ok: +%endmacro + +;; boilerplate needed once when abi_checked_function is used +%macro thunk_boilerplate 0 +; this function is defined by the C helper code +EXTERN nasm_util_die_on_reg_clobber + +boil1 rbp, 1 +boil1 rbx, 2 +boil1 r12, 3 +boil1 r13, 4 +boil1 r14, 5 +boil1 r15, 6 +%endmacro + +;; By default, the "assert-like" features that can be conditionally enabled key off the value of the +;; NDEBUG macro: if it is defined, the slower, more heavily checked paths are enabled, otherwise they +;; are omitted (usually resulting in zero additional cost). +;; +;; If you don't want to rely on NDEBUG can specifically enable or disable the debug mode with the +;; NASM_ENABLE_DEBUG set to 0 (equivalent to NDEBUG set) or 1 (equivalent to NDEBUG not set) +%ifndef NASM_ENABLE_DEBUG + %ifdef NDEBUG + %define NASM_ENABLE_DEBUG 0 + %else + %define NASM_ENABLE_DEBUG 1 + %endif +%elif (NASM_ENABLE_DEBUG != 0) && (NASM_ENABLE_DEBUG != 1) + %error bad value for 'NASM_ENABLE_DEBUG': should be 0 or 1 but was NASM_ENABLE_DEBUG +%endif + + + + +;; This macro supports declaring a "ABI-checked" function in asm +;; An ABI-checked function will checked at each invocation for compliance with the SysV ABI +;; rules about callee saved registers. In particular, from the ABI cocument we have the following: +;; +;; Registers %rbp, %rbx and %r12 through %r15 โ€œbelongโ€ to the calling function +;; and the called function is required to preserve their values. +;; (from "System V Application Binary Interface, AMD64 Architecture Processor Supplement") +;; +;; +%macro abi_checked_function 1 +GLOBAL %1:function + +%1: + +%if NASM_ENABLE_DEBUG != 0 + +;%warning compiling ABI checks + +; save all the callee-saved regs +push_callee_saved +push rax ; dummy push to align the stack (before we have rsp % 16 == 8) +call %1_inner +add rsp, 8 ; undo dummy push + +; load the function name (ok to clobber rdi since it's callee-saved) +mov rdi, %1_thunk_fn_name + +; now check whether any regs were clobbered +cmp rbp, [rsp + 40] +jne bad_rbp +cmp rbx, [rsp + 32] +jne bad_rbx +cmp r12, [rsp + 24] +jne bad_r12 +cmp r13, [rsp + 16] +jne bad_r13 +cmp r14, [rsp + 8] +jne bad_r14 +cmp r15, [rsp] +jne bad_r15 + +add rsp, 6 * 8 +ret + + +; here we store strings needed by the failure cases, in the .rodata section +[section .rodata] +%1_thunk_fn_name: +%ifdef __YASM_MAJOR__ +; yasm doesn't support defstr, so for now just use an unknown name +db "unknown (see yasm issue #95)",0 +%else +%defstr fname %1 +db fname,0 +%endif + +; restore the previous section +__SECT__ + +%1_inner: +%endif ; debug off, just assemble the function as-is without any checks + +%endmacro + + +;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; IMPLEMENTATION FOLLOWS +;; below you find internal macros needed for the implementation of the above macros +;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; generate the stubs for the bad_reg functions called from the check-abi thunk +%macro boil1 2 +bad_%1: +; A thunk has determined that a reg was clobbered +; each reg has their own bad_ function which moves the function name (in rdx) into +; rdi and loads a constant indicating which reg was involved and calls a C routine +; that will do the rest (abort the program generall). We follow up with an ud2 in case +; the C routine returns, since this mechanism is not designed for recovery. +mov rsi, %2 +; here we set up a stack frame - this gives a meaningful backtrace in any core file produced by the abort +; first we need to pop the saved regs off the stack so the rbp chain is consistent +add rsp, 6 * 8 +push rbp +mov rbp, rsp +call nasm_util_die_on_reg_clobber +ud2 +%endmacro + + + + diff --git a/tools/avx-turbo/once.h b/tools/avx-turbo/once.h new file mode 100644 index 00000000..586bcac8 --- /dev/null +++ b/tools/avx-turbo/once.h @@ -0,0 +1,128 @@ +/* Once (v1) + * Portable Snippets - https://gitub.com/nemequ/portable-snippets + * Created by Evan Nemerson + * + * To the extent possible under law, the authors have waived all + * copyright and related or neighboring rights to this code. For + * details, see the Creative Commons Zero 1.0 Universal license at + * https://creativecommons.org/publicdomain/zero/1.0/ + */ + +#if !defined(PSNIP_ONCE__H) +#define PSNIP_ONCE__H + +#define PSNIP_ONCE__BACKEND_ATOMIC 1 +#define PSNIP_ONCE__BACKEND_PTHREAD 2 +#define PSNIP_ONCE__BACKEND_NONE 3 +#define PSNIP_ONCE__BACKEND_C11 11 +#define PSNIP_ONCE__BACKEND_WIN32 32 + +#if !defined(PSNIP_ONCE_BACKEND) +# if defined(__STDC_NO_THREADS__) && __STDC_NO_THREADS__ +# elif defined(__EMSCRIPTEN__) +# elif defined(__has_include) +# if __has_include() +# include +# define PSNIP_ONCE_BACKEND PSNIP_ONCE__BACKEND_C11 +# endif +# elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201102L) && !defined(__STDC_NO_THREADS__) +# include +# if defined(__STDC_NO_THREADS__) || (defined(__GNUC__) && (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 16))) +/* stdc-predef.h didn't include __STDC_NO_THREADS__ until 2.16. icc + doesn't include stdc-predef.h until we pull in limits.h, so the + first check doesn't work. */ +# else +# include +# define PSNIP_ONCE_BACKEND PSNIP_ONCE__BACKEND_C11 +# endif +# endif +#endif + +#if !defined(PSNIP_ONCE_BACKEND) && defined(_WIN32) && (!defined(WINVER) || (defined(WINVER) && (WINVER >= 0x0600))) +# include +# define PSNIP_ONCE_BACKEND PSNIP_ONCE__BACKEND_WIN32 +#endif + +#if !defined(PSNIP_ONCE_BACKEND) && defined(PTHREAD_ONCE_INIT) +# define PSNIP_ONCE_BACKEND PSNIP_ONCE__BACKEND_PTHREAD +#endif + +#if !defined(PSNIP_ONCE_BACKEND) +# include "atomic.h" +# if !defined(PSNIP_ATOMIC_NOT_FOUND) +# define PSNIP_ONCE_BACKEND PSNIP_ONCE__BACKEND_ATOMIC +# endif +#endif + +#if !defined(PSNIP_ONCE_BACKEND) +# error No once backend found. +#endif + +#if defined(__GNUC__) && (__GNUC__ >= 3) +# define PSNIP_ONCE__UNLIKELY(expr) __builtin_expect(!!(expr), !!0) +#else +# define PSNIP_ONCE__UNLIKELY(expr) (!!(expr)) +#endif + +#if PSNIP_ONCE_BACKEND == PSNIP_ONCE__BACKEND_C11 +# define PSNIP_ONCE_INIT ONCE_FLAG_INIT +typedef once_flag psnip_once; +# define psnip_once_call(flag, func) call_once(flag, func) +#elif PSNIP_ONCE_BACKEND == PSNIP_ONCE__BACKEND_PTHREAD +# define PSNIP_ONCE_INIT PTHREAD_ONCE_INIT +typedef pthread_once_t psnip_once; +# define psnip_once_call(flag, func) pthread_once(flag, func) +#elif PSNIP_ONCE_BACKEND == PSNIP_ONCE__BACKEND_WIN32 +# define PSNIP_ONCE_INIT INIT_ONCE_STATIC_INIT +typedef INIT_ONCE psnip_once; +static BOOL CALLBACK psnip_once__callback_wrap(INIT_ONCE* InitOnce, void* Parameter, void** Context) { + (void) Context; + (void) InitOnce; +#if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable:4055) +#endif + ((void (*)(void)) Parameter)(); +#if defined(_MSC_VER) +# pragma warning(pop) +#endif + return !0; +} +# if defined(_MSC_VER) && (_MSC_VER >= 1500) +# define psnip_once_call(flag, func) \ + __pragma(warning(push)) \ + __pragma(warning(disable:4152)) \ + InitOnceExecuteOnce(flag, &psnip_once__callback_wrap, func, NULL) \ + __pragma(warning(pop)) +# else +# define psnip_once_call(flag, func) InitOnceExecuteOnce(flag, &psnip_once__callback_wrap, func, NULL) +# endif +#elif PSNIP_ONCE_BACKEND == PSNIP_ONCE__BACKEND_ATOMIC +# define PSNIP_ONCE_INIT PSNIP_ATOMIC_VAR_INIT(0) +typedef psnip_atomic_int32 psnip_once; +static void psnip_once_call(psnip_once* flag, void (*func)(void)) { + psnip_int32_t state = psnip_atomic_int32_load(flag); + if (PSNIP_ONCE__UNLIKELY(state == 0)) { + if (psnip_atomic_int32_compare_exchange(flag, &state, 1)) { + func(); + psnip_atomic_int32_store(flag, 2); + } else { + do { + /* Spin; another thread is calling the initialization + function. */ + } while (psnip_atomic_int32_load(flag) == 1); + } + } +} +#elif PSNIP_ONCE_BACKEND == PSNIP_ONCE__BACKEND_NONE +# define PSNIP_ONCE_INIT 0 +typedef int psnip_once; +static void psnip_once_call(psnip_once* flag, void (*func)(void)) { + if (*flag == 0) { + func(); + *flag = 1; + } +} +#endif + +#endif /* !defined(PSNIP_ONCE__H) */ diff --git a/tools/avx-turbo/stats.hpp b/tools/avx-turbo/stats.hpp new file mode 100644 index 00000000..ab938be2 --- /dev/null +++ b/tools/avx-turbo/stats.hpp @@ -0,0 +1,128 @@ +/* + * Really simple descriptive stats. + * + * stats.hpp + */ + +#ifndef STATS_HPP_ +#define STATS_HPP_ + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace Stats { + +class DescriptiveStats { + double min_, max_, avg_, median_; + size_t count_; +public: + DescriptiveStats(double min, double max, double avg, double median, size_t count) : + min_(min), max_(max), avg_(avg), median_(median), count_(count) {} + + double getAvg() const { + return avg_; + } + + size_t getCount() const { + return count_; + } + + double getMax() const { + return max_; + } + + double getMin() const { + return min_; + } + + double getMedian() const { + return median_; + } + + /* + * Return a string with the values of min/median/avg/max at the specified precision. + * Note that the count is not included. + */ + std::string getString4(int width, int precision) const { + std::ostringstream os; + os << std::fixed << std::setprecision(precision) << + std::setw(width) << getMin() << "/" << + std::setw(width) << getMedian() << "/" << + std::setw(width) << getAvg() << "/" << + std::setw(width) << getMax(); + + return os.str(); + } +}; + +template +typename std::iterator_traits::value_type median(iter_type first, iter_type last, LESS comp) { + if (first == last) { + throw std::logic_error("can't get median of empty range"); + } + using T = typename std::iterator_traits::value_type; + std::vector copy(first, last); + std::sort(copy.begin(), copy.end(), comp); + size_t sz = copy.size(), half_sz = sz / 2; + return sz % 2 ? copy[half_sz] : (copy[half_sz - 1] + copy[half_sz]) / 2; +} + +/** + * Like median above, except that with an even number of elements, where there are two middle elements with + * equal claim to the throne, the lesser of the two elements is returned rather trying to average them. This + * method is more generally applicable since it always returns on of the elements of the input range directly + * and doesn't require the elements to expose the operations required to calculate an average. + */ +template +typename std::iterator_traits::value_type medianf(iter_type first, iter_type last, LESS comp) { + if (first == last) { + throw std::logic_error("can't get median of empty range"); + } + using T = typename std::iterator_traits::value_type; + std::vector copy(first, last); + std::sort(copy.begin(), copy.end(), comp); + assert(!copy.empty()); + return copy[(copy.size() - 1) / 2]; +} + +template +typename std::iterator_traits::value_type median(iter_type first, iter_type last) { + auto p = std::less::value_type>(); + return Stats::median(first, last, p); +} + + +template +DescriptiveStats get_stats(iter_type first, iter_type last) { + using dlimits = std::numeric_limits; + double min = dlimits::max(), max = dlimits::min(), total = 0; + size_t count = 0; + for (iter_type itr = first; itr != last; itr++) { + auto val = *itr; + double vald = val; + if (vald < min) min = vald; + if (vald > max) max = vald; + total += vald; + count++; + } + + return DescriptiveStats(min, max, total / count, median(first, last), count); +} + + + +inline std::ostream& operator<<(std::ostream &os, const DescriptiveStats &stats) { + os << "min=" << stats.getMin() << ", median=" << stats.getMedian() << ", avg=" << stats.getAvg() + << ", max=" << stats.getMax() << ", n=" << stats.getCount(); + return os; +} + +} // namepsace Stats + +#endif /* STATS_HPP_ */ diff --git a/tools/avx-turbo/table.hpp b/tools/avx-turbo/table.hpp new file mode 100644 index 00000000..9c65fd9d --- /dev/null +++ b/tools/avx-turbo/table.hpp @@ -0,0 +1,177 @@ +/* + * table.hpp + * + * Simple tabular output. + */ + +#ifndef TABLE_HPP_ +#define TABLE_HPP_ + +#include +#include +#include +#include +#include +#include + +namespace table { + +/* + * Given a printf-style format and args, return the formatted string as a std::string. + * + * See https://stackoverflow.com/a/26221725/149138. + */ +template +std::string string_format(const std::string& format, Args ... args) { + size_t size = snprintf( nullptr, 0, format.c_str(), args ... ) + 1; // Extra space for '\0' + std::unique_ptr buf( new char[ size ] ); + snprintf( buf.get(), size, format.c_str(), args ... ); + return std::string( buf.get(), buf.get() + size - 1 ); // We don't want the '\0' inside +} + +class Table; + +struct ColInfo { + enum Justification { LEFT, RIGHT } justify; + ColInfo() : justify(LEFT) {} +}; + +class Row { + friend Table; + using row_t = std::vector; + + const Table* table_; + row_t elems_; + + Row(const Table& table) : table_(&table) {} + + /** return a vector of sizes for each element */ + std::vector getSizes() const { + std::vector sizes; + for (const auto& e : elems_) { + sizes.push_back(e.size()); + } + return sizes; + } + + inline void str(std::ostream& os, const std::vector sizes) const; + + std::string justify(const ColInfo& cinfo, const std::string& e, size_t w) const { + // left pad + std::stringstream ss; + ss << std::setw(w) << (cinfo.justify == ColInfo::LEFT ? std::left : std::right) << e; + auto s = ss.str(); + assert(s.size() == w); + return s; + } + +public: + /** add a cell to this row with the given element, returns a reference to this row */ + template + Row& add(const T& elem) { + std::stringstream ss; + ss << elem; + elems_.push_back(ss.str()); + return *this; + } + + /** + * Add a formatted cell to this row with the given element. + * The format is a printf-style format string and any additional arguments are the format arguments. + * Returns a reference to this row. + */ + template + Row& addf(const char* format, Args ... args) { + elems_.push_back(string_format(format, args...)); + return *this; + } + + /** the number of elements currently in the row */ + size_t size() { + return elems_.size(); + } +}; + +class Table { + friend Row; + using table_t = std::vector; + using colinfo_t = std::vector; + + table_t rows_; + colinfo_t colinfo_; + std::string sep; + +public: + + Table() : sep(" ") {} + + /** + * Get a reference to the ColInfo object for the given column, which lets you + * set column-global info such as the justification. + */ + ColInfo& colInfo(size_t col) { + if (col >= colinfo_.size()) { + colinfo_.resize(col + 1); + } + return colinfo_.at(col); + } + + /* in the cost case, return a default ColInfo if it doesn't exist */ + ColInfo colInfo(size_t col) const { + return col < colinfo_.size() ? colinfo_.at(col) : ColInfo{}; + } + + Row& newRow() { + rows_.push_back(Row{*this}); + return rows_.back(); + } + + /** return the current representation of the table as a string */ + std::string str() const { + + // calculate max row sizes + std::vector max_sizes; + for (const auto& r : rows_) { + std::vector sizes = r.getSizes(); + for (size_t c = 0; c < sizes.size(); c++) { + size_t row_size = sizes[c]; + if (c >= max_sizes.size()) { + assert(max_sizes.size() == c); + max_sizes.push_back(row_size); + } else { + max_sizes[c] = std::max(max_sizes[c], row_size); + } + } + } + + std::stringstream ss; + for (const auto& r : rows_) { + r.str(ss, max_sizes); + ss << "\n"; + } + + return ss.str(); + } + + void setColColumnSeparator(std::string s) { + sep = s; + } + +}; + +inline void Row::str(std::ostream& os, const std::vector sizes) const +{ + bool first = true; + for (size_t c = 0; c < elems_.size(); c++) { + const auto& e = elems_[c]; + assert(c < sizes.size()); + if (!first) os << table_->sep; // inter-cell padding + first = false; + os << justify(table_->colInfo(c), e, sizes[c]); + } +} + +} + + +#endif /* TABLE_HPP_ */ diff --git a/tools/avx-turbo/test/catch.hpp b/tools/avx-turbo/test/catch.hpp new file mode 100644 index 00000000..7e706f94 --- /dev/null +++ b/tools/avx-turbo/test/catch.hpp @@ -0,0 +1,17959 @@ +/* + * Catch v2.13.7 + * Generated: 2021-07-28 20:29:27.753164 + * ---------------------------------------------------------- + * This file has been merged from multiple headers. Please don't edit it directly + * Copyright (c) 2021 Two Blue Cubes Ltd. All rights reserved. + * + * Distributed under the Boost Software License, Version 1.0. (See accompanying + * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + */ +#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED +#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED +// start catch.hpp + + +#define CATCH_VERSION_MAJOR 2 +#define CATCH_VERSION_MINOR 13 +#define CATCH_VERSION_PATCH 7 + +#ifdef __clang__ +# pragma clang system_header +#elif defined __GNUC__ +# pragma GCC system_header +#endif + +// start catch_suppress_warnings.h + +#ifdef __clang__ +# ifdef __ICC // icpc defines the __clang__ macro +# pragma warning(push) +# pragma warning(disable: 161 1682) +# else // __ICC +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wpadded" +# pragma clang diagnostic ignored "-Wswitch-enum" +# pragma clang diagnostic ignored "-Wcovered-switch-default" +# endif +#elif defined __GNUC__ + // Because REQUIREs trigger GCC's -Wparentheses, and because still + // supported version of g++ have only buggy support for _Pragmas, + // Wparentheses have to be suppressed globally. +# pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details + +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-variable" +# pragma GCC diagnostic ignored "-Wpadded" +#endif +// end catch_suppress_warnings.h +#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER) +# define CATCH_IMPL +# define CATCH_CONFIG_ALL_PARTS +#endif + +// In the impl file, we want to have access to all parts of the headers +// Can also be used to sanely support PCHs +#if defined(CATCH_CONFIG_ALL_PARTS) +# define CATCH_CONFIG_EXTERNAL_INTERFACES +# if defined(CATCH_CONFIG_DISABLE_MATCHERS) +# undef CATCH_CONFIG_DISABLE_MATCHERS +# endif +# if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER) +# define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER +# endif +#endif + +#if !defined(CATCH_CONFIG_IMPL_ONLY) +// start catch_platform.h + +// See e.g.: +// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html +#ifdef __APPLE__ +# include +# if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \ + (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1) +# define CATCH_PLATFORM_MAC +# elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1) +# define CATCH_PLATFORM_IPHONE +# endif + +#elif defined(linux) || defined(__linux) || defined(__linux__) +# define CATCH_PLATFORM_LINUX + +#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__) +# define CATCH_PLATFORM_WINDOWS +#endif + +// end catch_platform.h + +#ifdef CATCH_IMPL +# ifndef CLARA_CONFIG_MAIN +# define CLARA_CONFIG_MAIN_NOT_DEFINED +# define CLARA_CONFIG_MAIN +# endif +#endif + +// start catch_user_interfaces.h + +namespace Catch { + unsigned int rngSeed(); +} + +// end catch_user_interfaces.h +// start catch_tag_alias_autoregistrar.h + +// start catch_common.h + +// start catch_compiler_capabilities.h + +// Detect a number of compiler features - by compiler +// The following features are defined: +// +// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported? +// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported? +// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported? +// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled? +// **************** +// Note to maintainers: if new toggles are added please document them +// in configuration.md, too +// **************** + +// In general each macro has a _NO_ form +// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature. +// Many features, at point of detection, define an _INTERNAL_ macro, so they +// can be combined, en-mass, with the _NO_ forms later. + +#ifdef __cplusplus + +# if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L) +# define CATCH_CPP14_OR_GREATER +# endif + +# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) +# define CATCH_CPP17_OR_GREATER +# endif + +#endif + +// Only GCC compiler should be used in this block, so other compilers trying to +// mask themselves as GCC should be ignored. +#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" ) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" ) + +# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) + +#endif + +#if defined(__clang__) + +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" ) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic pop" ) + +// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug +// which results in calls to destructors being emitted for each temporary, +// without a matching initialization. In practice, this can result in something +// like `std::string::~string` being called on an uninitialized value. +// +// For example, this code will likely segfault under IBM XL: +// ``` +// REQUIRE(std::string("12") + "34" == "1234") +// ``` +// +// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented. +# if !defined(__ibmxl__) && !defined(__CUDACC__) +# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */ +# endif + +# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \ + _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"") + +# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wparentheses\"" ) + +# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" ) + +# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" ) + +# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wunused-template\"" ) + +#endif // __clang__ + +//////////////////////////////////////////////////////////////////////////////// +// Assume that non-Windows platforms support posix signals by default +#if !defined(CATCH_PLATFORM_WINDOWS) + #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS +#endif + +//////////////////////////////////////////////////////////////////////////////// +// We know some environments not to support full POSIX signals +#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__) + #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS +#endif + +#ifdef __OS400__ +# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS +# define CATCH_CONFIG_COLOUR_NONE +#endif + +//////////////////////////////////////////////////////////////////////////////// +// Android somehow still does not support std::to_string +#if defined(__ANDROID__) +# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING +# define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE +#endif + +//////////////////////////////////////////////////////////////////////////////// +// Not all Windows environments support SEH properly +#if defined(__MINGW32__) +# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH +#endif + +//////////////////////////////////////////////////////////////////////////////// +// PS4 +#if defined(__ORBIS__) +# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE +#endif + +//////////////////////////////////////////////////////////////////////////////// +// Cygwin +#ifdef __CYGWIN__ + +// Required for some versions of Cygwin to declare gettimeofday +// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin +# define _BSD_SOURCE +// some versions of cygwin (most) do not support std::to_string. Use the libstd check. +// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813 +# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \ + && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF)) + +# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING + +# endif +#endif // __CYGWIN__ + +//////////////////////////////////////////////////////////////////////////////// +// Visual C++ +#if defined(_MSC_VER) + +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) ) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION __pragma( warning(pop) ) + +// Universal Windows platform does not support SEH +// Or console colours (or console at all...) +# if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP) +# define CATCH_CONFIG_COLOUR_NONE +# else +# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH +# endif + +// MSVC traditional preprocessor needs some workaround for __VA_ARGS__ +// _MSVC_TRADITIONAL == 0 means new conformant preprocessor +// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor +# if !defined(__clang__) // Handle Clang masquerading for msvc +# if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL) +# define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +# endif // MSVC_TRADITIONAL +# endif // __clang__ + +#endif // _MSC_VER + +#if defined(_REENTRANT) || defined(_MSC_VER) +// Enable async processing, as -pthread is specified or no additional linking is required +# define CATCH_INTERNAL_CONFIG_USE_ASYNC +#endif // _MSC_VER + +//////////////////////////////////////////////////////////////////////////////// +// Check if we are compiled with -fno-exceptions or equivalent +#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND) +# define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED +#endif + +//////////////////////////////////////////////////////////////////////////////// +// DJGPP +#ifdef __DJGPP__ +# define CATCH_INTERNAL_CONFIG_NO_WCHAR +#endif // __DJGPP__ + +//////////////////////////////////////////////////////////////////////////////// +// Embarcadero C++Build +#if defined(__BORLANDC__) + #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN +#endif + +//////////////////////////////////////////////////////////////////////////////// + +// Use of __COUNTER__ is suppressed during code analysis in +// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly +// handled by it. +// Otherwise all supported compilers support COUNTER macro, +// but user still might want to turn it off +#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L ) + #define CATCH_INTERNAL_CONFIG_COUNTER +#endif + +//////////////////////////////////////////////////////////////////////////////// + +// RTX is a special version of Windows that is real time. +// This means that it is detected as Windows, but does not provide +// the same set of capabilities as real Windows does. +#if defined(UNDER_RTSS) || defined(RTX64_BUILD) + #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH + #define CATCH_INTERNAL_CONFIG_NO_ASYNC + #define CATCH_CONFIG_COLOUR_NONE +#endif + +#if !defined(_GLIBCXX_USE_C99_MATH_TR1) +#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER +#endif + +// Various stdlib support checks that require __has_include +#if defined(__has_include) + // Check if string_view is available and usable + #if __has_include() && defined(CATCH_CPP17_OR_GREATER) + # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW + #endif + + // Check if optional is available and usable + # if __has_include() && defined(CATCH_CPP17_OR_GREATER) + # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL + # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) + + // Check if byte is available and usable + # if __has_include() && defined(CATCH_CPP17_OR_GREATER) + # include + # if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0) + # define CATCH_INTERNAL_CONFIG_CPP17_BYTE + # endif + # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) + + // Check if variant is available and usable + # if __has_include() && defined(CATCH_CPP17_OR_GREATER) + # if defined(__clang__) && (__clang_major__ < 8) + // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852 + // fix should be in clang 8, workaround in libstdc++ 8.2 + # include + # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) + # define CATCH_CONFIG_NO_CPP17_VARIANT + # else + # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT + # endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) + # else + # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT + # endif // defined(__clang__) && (__clang_major__ < 8) + # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) +#endif // defined(__has_include) + +#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) +# define CATCH_CONFIG_COUNTER +#endif +#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH) +# define CATCH_CONFIG_WINDOWS_SEH +#endif +// This is set by default, because we assume that unix compilers are posix-signal-compatible by default. +#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS) +# define CATCH_CONFIG_POSIX_SIGNALS +#endif +// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions. +#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR) +# define CATCH_CONFIG_WCHAR +#endif + +#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING) +# define CATCH_CONFIG_CPP11_TO_STRING +#endif + +#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL) +# define CATCH_CONFIG_CPP17_OPTIONAL +#endif + +#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW) +# define CATCH_CONFIG_CPP17_STRING_VIEW +#endif + +#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT) +# define CATCH_CONFIG_CPP17_VARIANT +#endif + +#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE) +# define CATCH_CONFIG_CPP17_BYTE +#endif + +#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT) +# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE +#endif + +#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE) +# define CATCH_CONFIG_NEW_CAPTURE +#endif + +#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) +# define CATCH_CONFIG_DISABLE_EXCEPTIONS +#endif + +#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN) +# define CATCH_CONFIG_POLYFILL_ISNAN +#endif + +#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC) +# define CATCH_CONFIG_USE_ASYNC +#endif + +#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE) +# define CATCH_CONFIG_ANDROID_LOGWRITE +#endif + +#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER) +# define CATCH_CONFIG_GLOBAL_NEXTAFTER +#endif + +// Even if we do not think the compiler has that warning, we still have +// to provide a macro that can be used by the code. +#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION) +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION +#endif +#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION +#endif +#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS +#endif +#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS +#endif +#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS +#endif +#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS +#endif + +// The goal of this macro is to avoid evaluation of the arguments, but +// still have the compiler warn on problems inside... +#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN) +# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) +#endif + +#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10) +# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS +#elif defined(__clang__) && (__clang_major__ < 5) +# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS +#endif + +#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS +#endif + +#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) +#define CATCH_TRY if ((true)) +#define CATCH_CATCH_ALL if ((false)) +#define CATCH_CATCH_ANON(type) if ((false)) +#else +#define CATCH_TRY try +#define CATCH_CATCH_ALL catch (...) +#define CATCH_CATCH_ANON(type) catch (type) +#endif + +#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) +#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +#endif + +// end catch_compiler_capabilities.h +#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line +#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) +#ifdef CATCH_CONFIG_COUNTER +# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ ) +#else +# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) +#endif + +#include +#include +#include + +// We need a dummy global operator<< so we can bring it into Catch namespace later +struct Catch_global_namespace_dummy {}; +std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy); + +namespace Catch { + + struct CaseSensitive { enum Choice { + Yes, + No + }; }; + + class NonCopyable { + NonCopyable( NonCopyable const& ) = delete; + NonCopyable( NonCopyable && ) = delete; + NonCopyable& operator = ( NonCopyable const& ) = delete; + NonCopyable& operator = ( NonCopyable && ) = delete; + + protected: + NonCopyable(); + virtual ~NonCopyable(); + }; + + struct SourceLineInfo { + + SourceLineInfo() = delete; + SourceLineInfo( char const* _file, std::size_t _line ) noexcept + : file( _file ), + line( _line ) + {} + + SourceLineInfo( SourceLineInfo const& other ) = default; + SourceLineInfo& operator = ( SourceLineInfo const& ) = default; + SourceLineInfo( SourceLineInfo&& ) noexcept = default; + SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default; + + bool empty() const noexcept { return file[0] == '\0'; } + bool operator == ( SourceLineInfo const& other ) const noexcept; + bool operator < ( SourceLineInfo const& other ) const noexcept; + + char const* file; + std::size_t line; + }; + + std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ); + + // Bring in operator<< from global namespace into Catch namespace + // This is necessary because the overload of operator<< above makes + // lookup stop at namespace Catch + using ::operator<<; + + // Use this in variadic streaming macros to allow + // >> +StreamEndStop + // as well as + // >> stuff +StreamEndStop + struct StreamEndStop { + std::string operator+() const; + }; + template + T const& operator + ( T const& value, StreamEndStop ) { + return value; + } +} + +#define CATCH_INTERNAL_LINEINFO \ + ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) + +// end catch_common.h +namespace Catch { + + struct RegistrarForTagAliases { + RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); + }; + +} // end namespace Catch + +#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \ + CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ + CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ + namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \ + CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION + +// end catch_tag_alias_autoregistrar.h +// start catch_test_registry.h + +// start catch_interfaces_testcase.h + +#include + +namespace Catch { + + class TestSpec; + + struct ITestInvoker { + virtual void invoke () const = 0; + virtual ~ITestInvoker(); + }; + + class TestCase; + struct IConfig; + + struct ITestCaseRegistry { + virtual ~ITestCaseRegistry(); + virtual std::vector const& getAllTests() const = 0; + virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0; + }; + + bool isThrowSafe( TestCase const& testCase, IConfig const& config ); + bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ); + std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ); + std::vector const& getAllTestCasesSorted( IConfig const& config ); + +} + +// end catch_interfaces_testcase.h +// start catch_stringref.h + +#include +#include +#include +#include + +namespace Catch { + + /// A non-owning string class (similar to the forthcoming std::string_view) + /// Note that, because a StringRef may be a substring of another string, + /// it may not be null terminated. + class StringRef { + public: + using size_type = std::size_t; + using const_iterator = const char*; + + private: + static constexpr char const* const s_empty = ""; + + char const* m_start = s_empty; + size_type m_size = 0; + + public: // construction + constexpr StringRef() noexcept = default; + + StringRef( char const* rawChars ) noexcept; + + constexpr StringRef( char const* rawChars, size_type size ) noexcept + : m_start( rawChars ), + m_size( size ) + {} + + StringRef( std::string const& stdString ) noexcept + : m_start( stdString.c_str() ), + m_size( stdString.size() ) + {} + + explicit operator std::string() const { + return std::string(m_start, m_size); + } + + public: // operators + auto operator == ( StringRef const& other ) const noexcept -> bool; + auto operator != (StringRef const& other) const noexcept -> bool { + return !(*this == other); + } + + auto operator[] ( size_type index ) const noexcept -> char { + assert(index < m_size); + return m_start[index]; + } + + public: // named queries + constexpr auto empty() const noexcept -> bool { + return m_size == 0; + } + constexpr auto size() const noexcept -> size_type { + return m_size; + } + + // Returns the current start pointer. If the StringRef is not + // null-terminated, throws std::domain_exception + auto c_str() const -> char const*; + + public: // substrings and searches + // Returns a substring of [start, start + length). + // If start + length > size(), then the substring is [start, size()). + // If start > size(), then the substring is empty. + auto substr( size_type start, size_type length ) const noexcept -> StringRef; + + // Returns the current start pointer. May not be null-terminated. + auto data() const noexcept -> char const*; + + constexpr auto isNullTerminated() const noexcept -> bool { + return m_start[m_size] == '\0'; + } + + public: // iterators + constexpr const_iterator begin() const { return m_start; } + constexpr const_iterator end() const { return m_start + m_size; } + }; + + auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&; + auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&; + + constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef { + return StringRef( rawChars, size ); + } +} // namespace Catch + +constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef { + return Catch::StringRef( rawChars, size ); +} + +// end catch_stringref.h +// start catch_preprocessor.hpp + + +#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__ +#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__))) +#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__))) +#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__))) +#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__))) +#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__))) + +#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__ +// MSVC needs more evaluations +#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__))) +#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__)) +#else +#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__) +#endif + +#define CATCH_REC_END(...) +#define CATCH_REC_OUT + +#define CATCH_EMPTY() +#define CATCH_DEFER(id) id CATCH_EMPTY() + +#define CATCH_REC_GET_END2() 0, CATCH_REC_END +#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2 +#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1 +#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT +#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0) +#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next) + +#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) +#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ ) +#define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) + +#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) +#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ ) +#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) + +// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results, +// and passes userdata as the first parameter to each invocation, +// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c) +#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) + +#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) + +#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param) +#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__ +#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__ +#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF +#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__) +#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__ +#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) +#else +// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF +#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__) +#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__ +#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1) +#endif + +#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__ +#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name) + +#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__) + +#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper()) +#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)) +#else +#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper())) +#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))) +#endif + +#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\ + CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__) + +#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0) +#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1) +#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2) +#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3) +#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4) +#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5) +#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6) +#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7) +#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8) +#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9) +#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) + +#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N + +#define INTERNAL_CATCH_TYPE_GEN\ + template struct TypeList {};\ + template\ + constexpr auto get_wrapper() noexcept -> TypeList { return {}; }\ + template class...> struct TemplateTypeList{};\ + template class...Cs>\ + constexpr auto get_wrapper() noexcept -> TemplateTypeList { return {}; }\ + template\ + struct append;\ + template\ + struct rewrap;\ + template class, typename...>\ + struct create;\ + template class, typename>\ + struct convert;\ + \ + template \ + struct append { using type = T; };\ + template< template class L1, typename...E1, template class L2, typename...E2, typename...Rest>\ + struct append, L2, Rest...> { using type = typename append, Rest...>::type; };\ + template< template class L1, typename...E1, typename...Rest>\ + struct append, TypeList, Rest...> { using type = L1; };\ + \ + template< template class Container, template class List, typename...elems>\ + struct rewrap, List> { using type = TypeList>; };\ + template< template class Container, template class List, class...Elems, typename...Elements>\ + struct rewrap, List, Elements...> { using type = typename append>, typename rewrap, Elements...>::type>::type; };\ + \ + template