[ { "path": ".github/workflows/build.yml", "content": "name: build\non: [push]\njobs:\n build:\n runs-on: ${{ matrix.os }}\n strategy:\n fail-fast: false\n matrix:\n os: [ubuntu-20.04]\n cpp_compiler: [g++, g++-7, g++-8, g++-9, clang++, clang++-9]\n include:\n - c_compiler: gcc\n - cpp_compiler: g++-7\n c_compiler: gcc-7\n - cpp_compiler: g++-8\n c_compiler: gcc-8\n - cpp_compiler: g++-9\n c_compiler: gcc-9\n - cpp_compiler: clang++\n c_compiler: clang\n - cpp_compiler: clang++-9\n c_compiler: clang-9\n steps:\n - name: Install C Compiler\n if: ${{ startsWith(matrix.c_compiler, 'gcc-') || startsWith(matrix.c_compiler, 'clang-') }}\n run: |\n sudo apt-get update\n sudo apt-get install -y ${{ matrix.c_compiler }}\n - name: Install C++ Compiler\n if: ${{ startsWith(matrix.cpp_compiler, 'g++-') || startsWith(matrix.cpp_compiler, 'clang++-') }}\n run: |\n sudo apt-get update\n sudo apt-get install -y ${{ matrix.cpp_compiler }}\n - uses: actions/checkout@v2\n - run: lscpu\n - run: make -j2 CC=${{ matrix.c_compiler }} CXX=${{ matrix.cpp_compiler }}\n - run: ./unit-test\n - run: ./avx-turbo --no-pin --max-threads 2\n\n" }, { "path": ".gitignore", "content": "# Prerequisites\n*.d\n\n# Compiled Object files\n*.slo\n*.lo\n*.o\n*.obj\n\n# Precompiled Headers\n*.gch\n*.pch\n\n# Compiled Dynamic libraries\n*.so\n*.dylib\n*.dll\n\n# Fortran module files\n*.mod\n*.smod\n\n# Compiled Static libraries\n*.lai\n*.la\n*.a\n*.lib\n\n# Executables\n*.exe\n*.out\n*.app\navx-turbo\nunit-test\n\n# Eclipse CDT artifacts\n.cproject\n.project\n.settings\n\n# nasm listing file\n*.list\n\n# libpfm4 directory\nlibpfm-4*/*\n\n# core files\n/core*\n/vgcore*\n\n# perf files\n/perf.*\n\n/tmp/*\n\ndummy.rebuild\n\n# local make config file\nlocal.mk\n" }, { "path": ".travis.yml", "content": "dist: xenial\nlanguage: cpp\nsudo: false\nbranches:\n except:\n - /^(wip\\/)?(appveyor|msvc|mingw|windows)(\\-.+)?$/\n\naddons:\n apt:\n sources: &default_sources\n - ubuntu-toolchain-r-test\n\n# the anchors element doesn't do anything but itself except define some anchors to be used later as aliases\nanchors:\n - &unit_command ./unit-test\n - &uarch_command ./uarch-bench --test-tag=~slow\n\nmatrix:\n include:\n # clang-5.0 is the default installed on travis VMs\n - compiler: clang-default\n env: TRUE_CC=clang TRUE_CXX=clang++ CXXFLAGS=-stdlib=libc++\n addons:\n apt:\n sources:\n - *default_sources\n - llvm-toolchain-trusty-5.0\n packages:\n - libc++abi1\n - libc++1\n - compiler: gcc-4.9\n env: TRUE_CC=gcc-4.9 TRUE_CXX=g++-4.9\n addons:\n apt:\n sources:\n - *default_sources\n packages:\n - gcc-4.9\n - g++-4.9\n - compiler: gcc-6\n env: TRUE_CC=gcc-6 TRUE_CXX=g++-6\n addons:\n apt:\n sources:\n - *default_sources\n packages:\n - gcc-6\n - g++-6\n - compiler: clang-6.0\n env: TRUE_CC=clang-6.0 TRUE_CXX=clang++-6.0\n addons:\n apt:\n sources:\n - *default_sources\n - llvm-toolchain-xenial-6.0\n packages:\n - clang-6.0\n - clang++-6.0\n\nbefore_install:\n# Travis will set CC and CXX after the env commands specified in the matrix are run, overwriting whatever\n# we've specified there, so we need to reset them here. See also https://github.com/travis-ci/travis-ci/issues/6633 .\n - CC=\"${TRUE_CC:-$CC}\"\n - CXX=\"${TRUE_CXX:-$CXX}\"\n\n\nscript:\n- set -e && echo \"CC is ${CC}, CXX is ${CXX}\" && ${CC} --version && ${CXX} --version\n- make\n- ./avx-turbo --no-pin --max-threads 2\n" }, { "path": "LICENSE", "content": "MIT License\n\nCopyright (c) 2018 travisdowns\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n" }, { "path": "Makefile", "content": "include config.mk\n\n# rebuild when makefile changes\n-include dummy.rebuild\n\n.PHONY: all clean\n\nASM_FLAGS ?= -DNASM_ENABLE_DEBUG=$(NASM_DEBUG) -w+all -l x86_methods.list\n\nifneq ($(CPU_ARCH),)\nARCH_FLAGS := -march=$(CPU_ARCH)\nendif\nO_LEVEL ?= -O2\n\nCOMMON_FLAGS := -MMD -Wall -Wextra -Wundef $(ARCH_FLAGS) -g $(O_LEVEL)\nCPPFLAGS := $(COMMON_FLAGS)\nCFLAGS := $(COMMON_FLAGS)\n\nSRC_FILES := $(wildcard *.cpp) $(wildcard *.c)\n\nOBJECTS := $(SRC_FILES:.cpp=.o) asm-methods.o\nOBJECTS := $(OBJECTS:.c=.o)\nDEPFILES = $(OBJECTS:.o=.d)\n# $(info OBJECTS=$(OBJECTS))\n\nVPATH = test\n\n###########\n# Targets #\n###########\n\nall: avx-turbo unit-test\n\n-include $(DEPFILES) unit-test.d\n\nclean:\n\trm -f *.d *.o avx-turbo\n\ndist-clean: clean $(CLEAN_TARGETS)\n\nunit-test: unit-test.o unit-test-main.o cpuid.o\n\t$(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(LDLIBS) -std=c++11 $^ -o $@\n\navx-turbo: $(OBJECTS)\n\t$(CXX) $(OBJECTS) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(LDLIBS) -std=c++11 -lpthread -o $@\n\n%.o : %.c\n\t$(CC) $(CFLAGS) -c -std=c11 -o $@ $<\n\n%.o : %.cpp\n\t$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c -std=c++11 -o $@ $<\n\n%.o: %.asm nasm-utils-inc.asm\n\t$(ASM) $(ASM_FLAGS) -f elf64 $<\n\nLOCAL_MK = $(wildcard local.mk)\n\n# https://stackoverflow.com/a/3892826/149138\ndummy.rebuild: Makefile config.mk $(LOCAL_MK)\n\ttouch $@\n\t$(MAKE) -s clean\n" }, { "path": "README.md", "content": "# avx-turbo\n\nTest 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.\n\nCurrently 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). \n\n# CI Status\n\n**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)\n\n\n# build\n\n make\n \n# msr kernel module\n\nYou should load the `msr` kernel module if it is not already loaded. This is as simple as:\n\n modprobe msr\n\nOr as complex as (if you want nice messages about what happened):\n\n lsmod | grep -q msr && echo \"MSR already loaded\" || { echo \"Loading MSR module\"; sudo modprobe msr ; }\n\n# run\n\nYou get the most info running as root (since we can read various MSRs to calculate the frequency directly):\n\n sudo ./avx-turbo\n\nYou can also run it without root, but you only get the \"Mops\" reading (but this can be read directly as frequency\nfor the 1-latency tests). \n\n## spec-based tests\n\nThe 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.\n\nAn 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,\nif 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.\n\nThis mode is useful to testing that happens when not all cores are doing the same thing.\n\n# help\n\nTry:\n\n ./avx-turbo --help\n \nfor a summary of some options something like this:\n\n```\n ./avx-turbo {OPTIONS}\n\n avx-turbo: Determine AVX2 and AVX-512 downclocking behavior\n\n OPTIONS:\n\n -h, --help Display this help menu\n --force-tsc-calibrate Force manual TSC calibration loop, even\n if cpuid TSC Hz is available\n --no-pin Don't try to pin threads to CPU - gives\n worse results but works around affinity\n issues on TravisCI\n --verbose Output more info\n --no-barrier Don't sync up threads before each test\n (no real purpose)\n --list List the available tests and their\n descriptions\n --allow-hyperthreads By default we try to filter down the\n available cpus to include only physical\n cores, but with this option we'll use\n all logical cores meaning you'll run two\n tests on cores with hyperthreading\n --test=[TEST-ID] Run only the specified test (by ID)\n --spec=[SPEC] Run a specific type of test specified by\n a specification string\n --iters=[ITERS] Run the test loop ITERS times (default\n 100000)\n --min-threads=[MIN] The minimum number of threads to use\n --max-threads=[MAX] The maximum number of threads to use\n --warmup-ms=[MILLISECONDS] Warmup milliseconds for each thread\n after pinning (default 100)\n\n```\n\n# output\n\nThe output looks like this:\n\n```\nRunning as root : [YES]\nCPU supports AVX2 : [YES]\nCPU supports AVX-512: [NO ]\ncpuid = eax = 2, ebx = 216, ecx = 0, edx = 0\ncpu: family = 6, model = 94, stepping = 3\ntsc_freq = 2592.0 MHz (from cpuid leaf 0x15)\nWill test up to 4 CPUs\n============================== Threads: 1 ==============================\nID | Description | Mops | A/M-ratio | A/M-MHz | M/tsc-ratio\nscalar_iadd | Scalar integer adds | 2594 | 1.00 | 2592 | 1.00\navx128_iadd | 128-bit integer adds | 2594 | 1.00 | 2592 | 1.00\navx128_imul | 128-bit integer muls | 519 | 1.00 | 2592 | 1.00\navx128_fma | 128-bit 64-bit FMAs | 649 | 1.00 | 2592 | 1.00\navx256_iadd | 256-bit integer adds | 2594 | 1.00 | 2592 | 1.00\navx256_imul | 256-bit integer muls | 519 | 1.00 | 2592 | 1.00\navx256_fma | 256-bit serial DP FMAs | 648 | 1.00 | 2592 | 1.00\navx256_fma_t | 256-bit parallel DP FMAs | 5189 | 1.00 | 2592 | 1.00\n=========================================================================\n\n============================== Threads: 2 ==============================\nID | Description | Mops | A/M-ratio | A/M-MHz | M/tsc-ratio\nscalar_iadd | Scalar integer adds | 2593, 2593 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00\navx128_iadd | 128-bit integer adds | 2594, 2594 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00\navx128_imul | 128-bit integer muls | 519, 519 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00\navx128_fma | 128-bit 64-bit FMAs | 648, 649 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00\navx256_iadd | 256-bit integer adds | 2594, 2594 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00\navx256_imul | 256-bit integer muls | 519, 519 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00\navx256_fma | 256-bit serial DP FMAs | 648, 648 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00\navx256_fma_t | 256-bit parallel DP FMAs | 5188, 5189 | 1.00, 1.00 | 2592, 2592 | 1.00, 1.00\n=========================================================================\n\n============================== Threads: 3 ==============================\nID | Description | Mops | A/M-ratio | A/M-MHz | M/tsc-ratio\nscalar_iadd | Scalar integer adds | 2594, 2594, 2594 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00\navx128_iadd | 128-bit integer adds | 2594, 2594, 2594 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00\navx128_imul | 128-bit integer muls | 519, 519, 519 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00\navx128_fma | 128-bit 64-bit FMAs | 649, 648, 648 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00\navx256_iadd | 256-bit integer adds | 2594, 2594, 2594 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00\navx256_imul | 256-bit integer muls | 519, 519, 519 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00\navx256_fma | 256-bit serial DP FMAs | 649, 648, 649 | 1.00, 1.00, 1.00 | 2592, 2592, 2592 | 1.00, 1.00, 1.00\navx256_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\n=========================================================================\n\n============================== Threads: 4 ==============================\nID | Description | Mops | A/M-ratio | A/M-MHz | M/tsc-ratio\nscalar_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\navx128_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\navx128_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\navx128_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\navx256_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\navx256_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\navx256_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\navx256_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\n=========================================================================\n```\n\nThe headings are:\n\n - `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`).\n - `Description` Yes, it's a description.\n - `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.\n - `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).\n - `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.\n - `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. \n" }, { "path": "args.hxx", "content": "/* Copyright (c) 2016-2017 Taylor C. Richberger and Pavel\n * Belikov\n * \n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n * \n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n * \n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\n/** \\file args.hxx\n * \\brief this single-header lets you use all of the args functionality\n *\n * The important stuff is done inside the args namespace\n */\n\n#ifndef ARGS_HXX\n#define ARGS_HXX\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#ifdef ARGS_TESTNAMESPACE\nnamespace argstest\n{\n#else\n\n/** \\namespace args\n * \\brief contains all the functionality of the args library\n */\nnamespace args\n{\n#endif\n /** Getter to grab the value from the argument type.\n *\n * If the Get() function of the type returns a reference, so does this, and\n * the value will be modifiable.\n */\n template \n auto get(Option &option_) -> decltype(option_.Get())\n {\n return option_.Get();\n }\n\n /** (INTERNAL) Count UTF-8 glyphs\n *\n * This is not reliable, and will fail for combinatory glyphs, but it's\n * good enough here for now.\n *\n * \\param string The string to count glyphs from\n * \\return The UTF-8 glyphs in the string\n */\n inline std::string::size_type Glyphs(const std::string &string_)\n {\n std::string::size_type length = 0;\n for (const char c: string_)\n {\n if ((c & 0xc0) != 0x80)\n {\n ++length;\n }\n }\n return length;\n }\n\n /** (INTERNAL) Wrap a string into a vector of lines\n *\n * This is quick and hacky, but works well enough. You can specify a\n * different width for the first line\n *\n * \\param width The width of the body\n * \\param the width of the first line, defaults to the width of the body\n * \\return the vector of lines\n */\n inline std::vector Wrap(const std::string &in, const std::string::size_type width, std::string::size_type firstlinewidth = 0)\n {\n // Preserve existing line breaks\n const auto newlineloc = in.find('\\n');\n if (newlineloc != in.npos)\n {\n auto first = Wrap(std::string(in, 0, newlineloc), width);\n auto second = Wrap(std::string(in, newlineloc + 1), width);\n first.insert(\n std::end(first),\n std::make_move_iterator(std::begin(second)),\n std::make_move_iterator(std::end(second)));\n return first;\n }\n if (firstlinewidth == 0)\n {\n firstlinewidth = width;\n }\n auto currentwidth = firstlinewidth;\n\n std::istringstream stream(in);\n std::vector output;\n std::ostringstream line;\n std::string::size_type linesize = 0;\n while (stream)\n {\n std::string item;\n stream >> item;\n auto itemsize = Glyphs(item);\n if ((linesize + 1 + itemsize) > currentwidth)\n {\n if (linesize > 0)\n {\n output.push_back(line.str());\n line.str(std::string());\n linesize = 0;\n currentwidth = width;\n }\n }\n if (itemsize > 0)\n {\n if (linesize)\n {\n ++linesize;\n line << \" \";\n }\n line << item;\n linesize += itemsize;\n }\n }\n if (linesize > 0)\n {\n output.push_back(line.str());\n }\n return output;\n }\n\n#ifdef ARGS_NOEXCEPT\n /// Error class, for when ARGS_NOEXCEPT is defined\n enum class Error\n {\n None,\n Usage,\n Parse,\n Validation,\n Required,\n Map,\n Extra,\n Help\n };\n#else\n /** Base error class\n */\n class Error : public std::runtime_error\n {\n public:\n Error(const std::string &problem) : std::runtime_error(problem) {}\n virtual ~Error() {};\n };\n\n /** Errors that occur during usage\n */\n class UsageError : public Error\n {\n public:\n UsageError(const std::string &problem) : Error(problem) {}\n virtual ~UsageError() {};\n };\n\n /** Errors that occur during regular parsing\n */\n class ParseError : public Error\n {\n public:\n ParseError(const std::string &problem) : Error(problem) {}\n virtual ~ParseError() {};\n };\n\n /** Errors that are detected from group validation after parsing finishes\n */\n class ValidationError : public Error\n {\n public:\n ValidationError(const std::string &problem) : Error(problem) {}\n virtual ~ValidationError() {};\n };\n\n /** Errors that when a required flag is omitted\n */\n class RequiredError : public ValidationError\n {\n public:\n RequiredError(const std::string &problem) : ValidationError(problem) {}\n virtual ~RequiredError() {};\n };\n\n /** Errors in map lookups\n */\n class MapError : public ParseError\n {\n public:\n MapError(const std::string &problem) : ParseError(problem) {}\n virtual ~MapError() {};\n };\n\n /** Error that occurs when a singular flag is specified multiple times\n */\n class ExtraError : public ParseError\n {\n public:\n ExtraError(const std::string &problem) : ParseError(problem) {}\n virtual ~ExtraError() {};\n };\n\n /** An exception that indicates that the user has requested help\n */\n class Help : public Error\n {\n public:\n Help(const std::string &flag) : Error(flag) {}\n virtual ~Help() {};\n };\n#endif\n\n /** A simple unified option type for unified initializer lists for the Matcher class.\n */\n struct EitherFlag\n {\n const bool isShort;\n const char shortFlag;\n const std::string longFlag;\n EitherFlag(const std::string &flag) : isShort(false), shortFlag(), longFlag(flag) {}\n EitherFlag(const char *flag) : isShort(false), shortFlag(), longFlag(flag) {}\n EitherFlag(const char flag) : isShort(true), shortFlag(flag), longFlag() {}\n\n /** Get just the long flags from an initializer list of EitherFlags\n */\n static std::unordered_set GetLong(std::initializer_list flags)\n {\n std::unordered_set longFlags;\n for (const EitherFlag &flag: flags)\n {\n if (!flag.isShort)\n {\n longFlags.insert(flag.longFlag);\n }\n }\n return longFlags;\n }\n\n /** Get just the short flags from an initializer list of EitherFlags\n */\n static std::unordered_set GetShort(std::initializer_list flags)\n {\n std::unordered_set shortFlags;\n for (const EitherFlag &flag: flags)\n {\n if (flag.isShort)\n {\n shortFlags.insert(flag.shortFlag);\n }\n }\n return shortFlags;\n }\n };\n\n\n\n /** A class of \"matchers\", specifying short and flags that can possibly be\n * matched.\n *\n * This is supposed to be constructed and then passed in, not used directly\n * from user code.\n */\n class Matcher\n {\n private:\n const std::unordered_set shortFlags;\n const std::unordered_set longFlags;\n\n public:\n /** Specify short and long flags separately as iterators\n *\n * ex: `args::Matcher(shortFlags.begin(), shortFlags.end(), longFlags.begin(), longFlags.end())`\n */\n template \n Matcher(ShortIt shortFlagsStart, ShortIt shortFlagsEnd, LongIt longFlagsStart, LongIt longFlagsEnd) :\n shortFlags(shortFlagsStart, shortFlagsEnd),\n longFlags(longFlagsStart, longFlagsEnd)\n {}\n\n /** Specify short and long flags separately as iterables\n *\n * ex: `args::Matcher(shortFlags, longFlags)`\n */\n template \n Matcher(Short &&shortIn, Long &&longIn) :\n shortFlags(std::begin(shortIn), std::end(shortIn)), longFlags(std::begin(longIn), std::end(longIn))\n {}\n\n /** Specify a mixed single initializer-list of both short and long flags\n *\n * This is the fancy one. It takes a single initializer list of\n * any number of any mixed kinds of flags. Chars are\n * automatically interpreted as short flags, and strings are\n * automatically interpreted as long flags:\n *\n * args::Matcher{'a'}\n * args::Matcher{\"foo\"}\n * args::Matcher{'h', \"help\"}\n * args::Matcher{\"foo\", 'f', 'F', \"FoO\"}\n */\n Matcher(std::initializer_list in) :\n shortFlags(EitherFlag::GetShort(in)), longFlags(EitherFlag::GetLong(in)) {}\n\n Matcher(Matcher &&other) : shortFlags(std::move(other.shortFlags)), longFlags(std::move(other.longFlags))\n {}\n\n ~Matcher() {}\n\n /** (INTERNAL) Check if there is a match of a short flag\n */\n bool Match(const char flag) const\n {\n return shortFlags.find(flag) != shortFlags.end();\n }\n\n /** (INTERNAL) Check if there is a match of a long flag\n */\n bool Match(const std::string &flag) const\n {\n return longFlags.find(flag) != longFlags.end();\n }\n\n /** (INTERNAL) Get all flag strings as a vector, with the prefixes embedded\n */\n std::vector GetFlagStrings(const std::string &shortPrefix, const std::string &longPrefix) const\n {\n std::vector flagStrings;\n flagStrings.reserve(shortFlags.size() + longFlags.size());\n for (const char flag: shortFlags)\n {\n flagStrings.emplace_back(shortPrefix + std::string(1, flag));\n }\n for (const std::string &flag: longFlags)\n {\n flagStrings.emplace_back(longPrefix + flag);\n }\n return flagStrings;\n }\n\n /** (INTERNAL) Get all flag strings as a vector, with the prefixes and names embedded\n */\n std::vector GetFlagStrings(const std::string &shortPrefix, const std::string &longPrefix, const std::string &name, const std::string &shortSeparator, const std::string longSeparator) const\n {\n const std::string bracedname(std::string(\"[\") + name + \"]\");\n std::vector flagStrings;\n flagStrings.reserve(shortFlags.size() + longFlags.size());\n for (const char flag: shortFlags)\n {\n flagStrings.emplace_back(shortPrefix + std::string(1, flag) + shortSeparator + bracedname);\n }\n for (const std::string &flag: longFlags)\n {\n flagStrings.emplace_back(longPrefix + flag + longSeparator + bracedname);\n }\n return flagStrings;\n }\n };\n\n enum class Options\n {\n /** Default options.\n */\n None = 0x0,\n\n /** Flag can't be passed multiple times.\n */\n Single = 0x01,\n\n /** Flag can't be omitted.\n */\n Required = 0x02,\n\n /** Flag is excluded from help output.\n */\n Hidden = 0x04,\n };\n\n inline Options operator | (Options lhs, Options rhs)\n {\n return static_cast(static_cast(lhs) | static_cast(rhs));\n }\n\n inline Options operator & (Options lhs, Options rhs)\n {\n return static_cast(static_cast(lhs) & static_cast(rhs));\n }\n\n /** Base class for all match types\n */\n class Base\n {\n private:\n const Options options;\n\n protected:\n bool matched;\n const std::string help;\n#ifdef ARGS_NOEXCEPT\n /// Only for ARGS_NOEXCEPT\n Error error;\n#endif\n\n public:\n Base(const std::string &help_, Options options_ = {}) : options(options_), matched(false), help(help_) {}\n virtual ~Base() {}\n\n Options GetOptions() const noexcept\n {\n return options;\n }\n\n virtual bool Matched() const noexcept\n {\n return matched;\n }\n\n virtual void Validate(const std::string &, const std::string &)\n {\n }\n\n operator bool() const noexcept\n {\n return Matched();\n }\n\n virtual std::tuple GetDescription(const std::string &, const std::string &, const std::string &, const std::string &) const\n {\n std::tuple description;\n std::get<1>(description) = help;\n return description;\n }\n\n virtual void Reset() noexcept\n {\n matched = false;\n#ifdef ARGS_NOEXCEPT\n error = Error::None;\n#endif\n }\n\n#ifdef ARGS_NOEXCEPT\n /// Only for ARGS_NOEXCEPT\n virtual Error GetError() const\n {\n return error;\n }\n#endif\n };\n\n /** Base class for all match types that have a name\n */\n class NamedBase : public Base\n {\n protected:\n const std::string name;\n bool kickout;\n\n public:\n NamedBase(const std::string &name_, const std::string &help_, Options options_ = {}) : Base(help_, options_), name(name_), kickout(false) {}\n virtual ~NamedBase() {}\n\n virtual std::tuple GetDescription(const std::string &, const std::string &, const std::string &, const std::string &) const override\n {\n std::tuple description;\n std::get<0>(description) = Name();\n std::get<1>(description) = help;\n return description;\n }\n\n virtual std::string Name() const\n {\n return name;\n }\n\n /// Sets a kick-out value for building subparsers\n void KickOut(bool kickout_) noexcept\n {\n this->kickout = kickout_;\n }\n\n /// Gets the kick-out value for building subparsers\n bool KickOut() const noexcept\n {\n return kickout;\n }\n };\n\n struct Nargs\n {\n const size_t min;\n const size_t max;\n\n Nargs(size_t min_, size_t max_) : min(min_), max(max_)\n {\n#ifndef ARGS_NOEXCEPT\n if (max < min)\n {\n throw std::invalid_argument(\"Nargs: max > min\");\n }\n#endif\n }\n\n Nargs(size_t num_) : min(num_), max(num_)\n {\n }\n };\n\n /** Base class for all flag options\n */\n class FlagBase : public NamedBase\n {\n protected:\n const Matcher matcher;\n\n public:\n 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_)) {}\n\n FlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) : NamedBase(name_, help_, options_), matcher(std::move(matcher_)) {}\n\n virtual ~FlagBase() {}\n\n virtual FlagBase *Match(const std::string &flag)\n {\n if (matcher.Match(flag))\n {\n if ((GetOptions() & Options::Single) != Options::None && matched)\n {\n#ifdef ARGS_NOEXCEPT\n error = Error::Extra;\n#else\n std::ostringstream problem;\n problem << \"Flag '\" << flag << \"' was passed multiple times, but is only allowed to be passed once\";\n throw ExtraError(problem.str());\n#endif\n }\n matched = true;\n return this;\n }\n return nullptr;\n }\n\n virtual void Validate(const std::string &shortPrefix, const std::string &longPrefix) override\n {\n if (!Matched() && (GetOptions() & Options::Required) != Options::None)\n {\n#ifdef ARGS_NOEXCEPT\n error = Error::Required;\n#else\n std::ostringstream problem;\n problem << \"Flag '\" << matcher.GetFlagStrings(shortPrefix, longPrefix).at(0) << \"' is required\";\n throw RequiredError(problem.str());\n#endif\n }\n }\n\n virtual FlagBase *Match(const char flag)\n {\n if (matcher.Match(flag))\n {\n if ((GetOptions() & Options::Single) != Options::None && matched)\n {\n#ifdef ARGS_NOEXCEPT\n error = Error::Extra;\n#else\n std::ostringstream problem;\n problem << \"Flag '\" << flag << \"' was passed multiple times, but is only allowed to be passed once\";\n throw ExtraError(problem.str());\n#endif\n }\n matched = true;\n return this;\n }\n return nullptr;\n }\n\n virtual std::tuple GetDescription(const std::string &shortPrefix, const std::string &longPrefix, const std::string &, const std::string &) const override\n {\n std::tuple description;\n const auto flagStrings = matcher.GetFlagStrings(shortPrefix, longPrefix);\n std::ostringstream flagstream;\n for (auto it = std::begin(flagStrings); it != std::end(flagStrings); ++it)\n {\n if (it != std::begin(flagStrings))\n {\n flagstream << \", \";\n }\n flagstream << *it;\n }\n std::get<0>(description) = flagstream.str();\n std::get<1>(description) = help;\n return description;\n }\n\n /** Defines how many values can be consumed by this option.\n *\n * \\return closed interval [min, max]\n */\n virtual Nargs NumberOfArguments() const noexcept = 0;\n\n /** Parse values of this option.\n *\n * \\param value Vector of values. It's size must be in NumberOfArguments() interval.\n */\n virtual void ParseValue(const std::vector &value) = 0;\n };\n\n /** Base class for value-accepting flag options\n */\n class ValueFlagBase : public FlagBase\n {\n public:\n ValueFlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, const bool extraError_ = false) : FlagBase(name_, help_, std::move(matcher_), extraError_) {}\n ValueFlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) : FlagBase(name_, help_, std::move(matcher_), options_) {}\n virtual ~ValueFlagBase() {}\n\n virtual std::tuple GetDescription(const std::string &shortPrefix, const std::string &longPrefix, const std::string &shortSeparator, const std::string &longSeparator) const override\n {\n std::tuple description;\n const auto flagStrings = matcher.GetFlagStrings(shortPrefix, longPrefix, Name(), shortSeparator, longSeparator);\n std::ostringstream flagstream;\n for (auto it = std::begin(flagStrings); it != std::end(flagStrings); ++it)\n {\n if (it != std::begin(flagStrings))\n {\n flagstream << \", \";\n }\n flagstream << *it;\n }\n std::get<0>(description) = flagstream.str();\n std::get<1>(description) = help;\n return description;\n }\n\n virtual Nargs NumberOfArguments() const noexcept override\n {\n return 1;\n }\n };\n\n /** Base class for positional options\n */\n class PositionalBase : public NamedBase\n {\n protected:\n bool ready;\n\n public:\n PositionalBase(const std::string &name_, const std::string &help_, Options options_ = Options::None) : NamedBase(name_, help_, options_), ready(true) {}\n virtual ~PositionalBase() {}\n\n bool Ready()\n {\n return ready;\n }\n\n virtual void ParseValue(const std::string &value_) = 0;\n\n virtual void Reset() noexcept override\n {\n matched = false;\n ready = true;\n#ifdef ARGS_NOEXCEPT\n error = Error::None;\n#endif\n }\n\n virtual void Validate(const std::string &, const std::string &) override\n {\n if ((GetOptions() & Options::Required) != Options::None && !Matched())\n {\n#ifdef ARGS_NOEXCEPT\n error = Error::Required;\n#else\n std::ostringstream problem;\n problem << \"Option '\" << Name() << \"' is required\";\n throw RequiredError(problem.str());\n#endif\n }\n }\n };\n\n /** Class for all kinds of validating groups, including ArgumentParser\n */\n class Group : public Base\n {\n private:\n std::vector children;\n std::function validator;\n\n public:\n /** Default validators\n */\n struct Validators\n {\n static bool Xor(const Group &group)\n {\n return group.MatchedChildren() == 1;\n }\n\n static bool AtLeastOne(const Group &group)\n {\n return group.MatchedChildren() >= 1;\n }\n\n static bool AtMostOne(const Group &group)\n {\n return group.MatchedChildren() <= 1;\n }\n\n static bool All(const Group &group)\n {\n return group.Children().size() == group.MatchedChildren();\n }\n\n static bool AllOrNone(const Group &group)\n {\n return (All(group) || None(group));\n }\n\n static bool AllChildGroups(const Group &group)\n {\n return std::find_if(std::begin(group.Children()), std::end(group.Children()), [](const Base* child) -> bool {\n return dynamic_cast(child) && !child->Matched();\n }) == std::end(group.Children());\n }\n\n static bool DontCare(const Group &)\n {\n return true;\n }\n\n static bool CareTooMuch(const Group &)\n {\n return false;\n }\n\n static bool None(const Group &group)\n {\n return group.MatchedChildren() == 0;\n }\n };\n /// If help is empty, this group will not be printed in help output\n Group(const std::string &help_ = std::string(), const std::function &validator_ = Validators::DontCare) : Base(help_), validator(validator_) {}\n /// If help is empty, this group will not be printed in help output\n Group(Group &group_, const std::string &help_ = std::string(), const std::function &validator_ = Validators::DontCare) : Base(help_), validator(validator_)\n {\n group_.Add(*this);\n }\n virtual ~Group() {}\n\n /** Return the first FlagBase that matches flag, or nullptr\n *\n * \\param flag The flag with prefixes stripped\n * \\return the first matching FlagBase pointer, or nullptr if there is no match\n */\n template \n FlagBase *Match(const T &flag)\n {\n for (Base *child: children)\n {\n if (FlagBase *flagBase = dynamic_cast(child))\n {\n if (FlagBase *match = flagBase->Match(flag))\n {\n return match;\n }\n } else if (Group *group = dynamic_cast(child))\n {\n if (FlagBase *match = group->Match(flag))\n {\n return match;\n }\n }\n }\n return nullptr;\n }\n\n virtual void Validate(const std::string &shortPrefix, const std::string &longPrefix) override\n {\n for (Base *child: children)\n {\n child->Validate(shortPrefix, longPrefix);\n }\n }\n\n /** Get the next ready positional, or nullptr if there is none\n *\n * \\return the first ready PositionalBase pointer, or nullptr if there is no match\n */\n PositionalBase *GetNextPositional()\n {\n for (Base *child: children)\n {\n auto next = dynamic_cast(child);\n auto group = dynamic_cast(child);\n if (group)\n {\n next = group->GetNextPositional();\n }\n if (next && next->Ready())\n {\n return next;\n }\n }\n return nullptr;\n }\n\n /** Get whether this has any FlagBase children\n *\n * \\return Whether or not there are any FlagBase children\n */\n bool HasFlag() const\n {\n for (Base *child: children)\n {\n if (dynamic_cast(child))\n {\n return true;\n }\n if (auto group = dynamic_cast(child))\n {\n if (group->HasFlag())\n {\n return true;\n }\n }\n }\n return false;\n }\n\n /** Append a child to this Group.\n */\n void Add(Base &child)\n {\n children.emplace_back(&child);\n }\n\n /** Get all this group's children\n */\n const std::vector &Children() const\n {\n return children;\n }\n\n /** Count the number of matched children this group has\n */\n std::vector::size_type MatchedChildren() const\n {\n return std::count_if(std::begin(children), std::end(children), [](const Base *child){return child->Matched();});\n }\n\n /** Whether or not this group matches validation\n */\n virtual bool Matched() const noexcept override\n {\n return validator(*this);\n }\n\n /** Get validation\n */\n bool Get() const\n {\n return Matched();\n }\n\n /** Get all the child descriptions for help generation\n */\n 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\n {\n std::vector> descriptions;\n for (const auto &child: children)\n {\n if ((child->GetOptions() & Options::Hidden) != Options::None)\n {\n continue;\n }\n\n if (const auto group = dynamic_cast(child))\n {\n // Push that group description on the back if not empty\n unsigned char addindent = 0;\n if (!group->help.empty())\n {\n descriptions.emplace_back(group->help, \"\", indent);\n addindent = 1;\n }\n auto groupDescriptions = group->GetChildDescriptions(shortPrefix, longPrefix, shortSeparator, longSeparator, indent + addindent);\n descriptions.insert(\n std::end(descriptions),\n std::make_move_iterator(std::begin(groupDescriptions)),\n std::make_move_iterator(std::end(groupDescriptions)));\n } else if (const auto named = dynamic_cast(child))\n {\n const auto description = named->GetDescription(shortPrefix, longPrefix, shortSeparator, longSeparator);\n descriptions.emplace_back(std::get<0>(description), std::get<1>(description), indent);\n }\n }\n return descriptions;\n }\n\n /** Get the names of positional parameters\n */\n std::vector GetPosNames() const\n {\n std::vector names;\n for (const auto &child: children)\n {\n if (const Group *group = dynamic_cast(child))\n {\n auto groupNames = group->GetPosNames();\n names.insert(\n std::end(names),\n std::make_move_iterator(std::begin(groupNames)),\n std::make_move_iterator(std::end(groupNames)));\n } else if (const PositionalBase *pos = dynamic_cast(child))\n {\n names.emplace_back(pos->Name());\n }\n }\n return names;\n }\n\n virtual void Reset() noexcept override\n {\n for (auto &child: children)\n {\n child->Reset();\n }\n#ifdef ARGS_NOEXCEPT\n error = Error::None;\n#endif\n }\n\n#ifdef ARGS_NOEXCEPT\n /// Only for ARGS_NOEXCEPT\n virtual Error GetError() const override\n {\n if (error != Error::None)\n {\n return error;\n }\n\n auto it = std::find_if(std::begin(children), std::end(children), [](const Base *child){return child->GetError() != Error::None;});\n if (it == std::end(children))\n {\n return Error::None;\n } else\n {\n return (*it)->GetError();\n }\n }\n#endif\n\n };\n\n /** The main user facing command line argument parser class\n */\n class ArgumentParser : public Group\n {\n private:\n std::string prog;\n std::string proglinePostfix;\n std::string description;\n std::string epilog;\n\n std::string longprefix;\n std::string shortprefix;\n\n std::string longseparator;\n\n std::string terminator;\n\n bool allowJoinedShortValue;\n bool allowJoinedLongValue;\n bool allowSeparateShortValue;\n bool allowSeparateLongValue;\n\n protected:\n bool RaiseParseError(const std::string &message)\n {\n#ifdef ARGS_NOEXCEPT\n (void)message;\n error = Error::Parse;\n return false;\n#else\n throw ParseError(message);\n#endif\n }\n\n enum class OptionType\n {\n LongFlag,\n ShortFlag,\n Positional\n };\n\n OptionType ParseOption(const std::string &s)\n {\n if (s.find(longprefix) == 0 && s.length() > longprefix.length())\n {\n return OptionType::LongFlag;\n }\n\n if (s.find(shortprefix) == 0 && s.length() > shortprefix.length())\n {\n return OptionType::ShortFlag;\n }\n\n return OptionType::Positional;\n }\n\n /** (INTERNAL) Parse flag's values\n *\n * \\param arg The string to display in error message as a flag name\n * \\param[in, out] it The iterator to first value. It will point to the last value\n * \\param end The end iterator\n * \\param joinedArg Joined value (e.g. bar in --foo=bar)\n * \\param canDiscardJoined If true joined value can be parsed as flag not as a value (as in -abcd)\n * \\param[out] values The vector to store parsed arg's values\n */\n template \n bool ParseArgsValues(FlagBase &flag, const std::string &arg, It &it, It end,\n const bool allowSeparate, const bool allowJoined,\n const bool hasJoined, const std::string &joinedArg,\n const bool canDiscardJoined, std::vector &values)\n {\n values.clear();\n\n Nargs nargs = flag.NumberOfArguments();\n\n if (hasJoined && !allowJoined && nargs.min != 0)\n {\n return RaiseParseError(\"Flag '\" + arg + \"' was passed a joined argument, but these are disallowed\");\n }\n\n if (hasJoined)\n {\n if (!canDiscardJoined || nargs.max != 0)\n {\n values.push_back(joinedArg);\n }\n } else if (!allowSeparate)\n {\n if (nargs.min != 0)\n {\n return RaiseParseError(\"Flag '\" + arg + \"' was passed a separate argument, but these are disallowed\");\n }\n } else\n {\n auto valueIt = it;\n ++valueIt;\n\n while (valueIt != end &&\n values.size() < nargs.max &&\n (nargs.min == nargs.max || ParseOption(*valueIt) == OptionType::Positional))\n {\n\n values.push_back(*valueIt);\n ++it;\n ++valueIt;\n }\n }\n\n if (values.size() > nargs.max)\n {\n return RaiseParseError(\"Passed an argument into a non-argument flag: \" + arg);\n } else if (values.size() < nargs.min)\n {\n if (nargs.min == 1 && nargs.max == 1)\n {\n return RaiseParseError(\"Flag '\" + arg + \"' requires an argument but received none\");\n } else if (nargs.min == 1)\n {\n return RaiseParseError(\"Flag '\" + arg + \"' requires at least one argument but received none\");\n } else if (nargs.min != nargs.max)\n {\n return RaiseParseError(\"Flag '\" + arg + \"' requires at least \" + std::to_string(nargs.min) +\n \" arguments but received \" + std::to_string(values.size()));\n } else\n {\n return RaiseParseError(\"Flag '\" + arg + \"' requires \" + std::to_string(nargs.min) +\n \" arguments but received \" + std::to_string(values.size()));\n }\n }\n\n return true;\n }\n\n template \n bool ParseLong(It &it, It end)\n {\n const auto &chunk = *it;\n const auto argchunk = chunk.substr(longprefix.size());\n // Try to separate it, in case of a separator:\n const auto separator = longseparator.empty() ? argchunk.npos : argchunk.find(longseparator);\n // If the separator is in the argument, separate it.\n const auto arg = (separator != argchunk.npos ?\n std::string(argchunk, 0, separator)\n : argchunk);\n const auto joined = (separator != argchunk.npos ?\n argchunk.substr(separator + longseparator.size())\n : std::string());\n\n if (auto flag = Match(arg))\n {\n std::vector values;\n if (!ParseArgsValues(*flag, arg, it, end, allowSeparateLongValue, allowJoinedLongValue,\n separator != argchunk.npos, joined, false, values))\n {\n return false;\n }\n\n flag->ParseValue(values);\n\n if (flag->KickOut())\n {\n ++it;\n return false;\n }\n } else\n {\n return RaiseParseError(\"Flag could not be matched: \" + arg);\n }\n\n return true;\n }\n\n template \n bool ParseShort(It &it, It end)\n {\n const auto &chunk = *it;\n const auto argchunk = chunk.substr(shortprefix.size());\n for (auto argit = std::begin(argchunk); argit != std::end(argchunk); ++argit)\n {\n const auto arg = *argit;\n\n if (auto flag = Match(arg))\n {\n const std::string value(argit + 1, std::end(argchunk));\n std::vector values;\n if (!ParseArgsValues(*flag, std::string(1, arg), it, end,\n allowSeparateShortValue, allowJoinedShortValue,\n !value.empty(), value, !value.empty(), values))\n {\n return false;\n }\n\n flag->ParseValue(values);\n\n if (flag->KickOut())\n {\n ++it;\n return false;\n }\n\n if (!values.empty())\n {\n break;\n }\n } else\n {\n return RaiseParseError(\"Flag could not be matched: '\" + std::string(1, arg) + \"'\");\n }\n }\n\n return true;\n }\n\n public:\n /** A simple structure of parameters for easy user-modifyable help menus\n */\n struct HelpParams\n {\n /** The width of the help menu\n */\n unsigned int width = 80;\n /** The indent of the program line\n */\n unsigned int progindent = 2;\n /** The indent of the program trailing lines for long parameters\n */\n unsigned int progtailindent = 4;\n /** The indent of the description and epilogs\n */\n unsigned int descriptionindent = 4;\n /** The indent of the flags\n */\n unsigned int flagindent = 6;\n /** The indent of the flag descriptions\n */\n unsigned int helpindent = 40;\n /** The additional indent each group adds\n */\n unsigned int eachgroupindent = 2;\n\n /** The minimum gutter between each flag and its help\n */\n unsigned int gutter = 1;\n\n /** Show the terminator when both options and positional parameters are present\n */\n bool showTerminator = true;\n\n /** Show the {OPTIONS} on the prog line when this is true\n */\n bool showProglineOptions = true;\n\n /** Show the positionals on the prog line when this is true\n */\n bool showProglinePositionals = true;\n } helpParams;\n ArgumentParser(const std::string &description_, const std::string &epilog_ = std::string()) :\n Group(\"\", Group::Validators::AllChildGroups),\n description(description_),\n epilog(epilog_),\n longprefix(\"--\"),\n shortprefix(\"-\"),\n longseparator(\"=\"),\n terminator(\"--\"),\n allowJoinedShortValue(true),\n allowJoinedLongValue(true),\n allowSeparateShortValue(true),\n allowSeparateLongValue(true) {}\n\n /** The program name for help generation\n */\n const std::string &Prog() const\n { return prog; }\n /** The program name for help generation\n */\n void Prog(const std::string &prog_)\n { this->prog = prog_; }\n\n /** The description that appears on the prog line after options\n */\n const std::string &ProglinePostfix() const\n { return proglinePostfix; }\n /** The description that appears on the prog line after options\n */\n void ProglinePostfix(const std::string &proglinePostfix_)\n { this->proglinePostfix = proglinePostfix_; }\n\n /** The description that appears above options\n */\n const std::string &Description() const\n { return description; }\n /** The description that appears above options\n */\n void Description(const std::string &description_)\n { this->description = description_; }\n \n /** The description that appears below options\n */\n const std::string &Epilog() const\n { return epilog; }\n /** The description that appears below options\n */\n void Epilog(const std::string &epilog_)\n { this->epilog = epilog_; }\n\n /** The prefix for long flags\n */\n const std::string &LongPrefix() const\n { return longprefix; }\n /** The prefix for long flags\n */\n void LongPrefix(const std::string &longprefix_)\n { this->longprefix = longprefix_; }\n\n /** The prefix for short flags\n */\n const std::string &ShortPrefix() const\n { return shortprefix; }\n /** The prefix for short flags\n */\n void ShortPrefix(const std::string &shortprefix_)\n { this->shortprefix = shortprefix_; }\n\n /** The separator for long flags\n */\n const std::string &LongSeparator() const\n { return longseparator; }\n /** The separator for long flags\n */\n void LongSeparator(const std::string &longseparator_)\n {\n if (longseparator_.empty())\n {\n#ifdef ARGS_NOEXCEPT\n error = Error::Usage;\n#else\n throw UsageError(\"longseparator can not be set to empty\");\n#endif\n } else\n {\n this->longseparator = longseparator_;\n }\n }\n\n /** The terminator that forcibly separates flags from positionals\n */\n const std::string &Terminator() const\n { return terminator; }\n /** The terminator that forcibly separates flags from positionals\n */\n void Terminator(const std::string &terminator_)\n { this->terminator = terminator_; }\n\n /** Get the current argument separation parameters.\n *\n * See SetArgumentSeparations for details on what each one means.\n */\n void GetArgumentSeparations(\n bool &allowJoinedShortValue_,\n bool &allowJoinedLongValue_,\n bool &allowSeparateShortValue_,\n bool &allowSeparateLongValue_) const\n {\n allowJoinedShortValue_ = this->allowJoinedShortValue;\n allowJoinedLongValue_ = this->allowJoinedLongValue;\n allowSeparateShortValue_ = this->allowSeparateShortValue;\n allowSeparateLongValue_ = this->allowSeparateLongValue;\n }\n\n /** Change allowed option separation.\n *\n * \\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)\n * \\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)\n * \\param allowSeparateShortValue Allow a short flag that accepts an argument to be passed its argument separated by whitespace (ie. in the next argv field)\n * \\param allowSeparateLongValue Allow a long flag that accepts an argument to be passed its argument separated by whitespace (ie. in the next argv field)\n */\n void SetArgumentSeparations(\n const bool allowJoinedShortValue_,\n const bool allowJoinedLongValue_,\n const bool allowSeparateShortValue_,\n const bool allowSeparateLongValue_)\n {\n this->allowJoinedShortValue = allowJoinedShortValue_;\n this->allowJoinedLongValue = allowJoinedLongValue_;\n this->allowSeparateShortValue = allowSeparateShortValue_;\n this->allowSeparateLongValue = allowSeparateLongValue_;\n }\n\n /** Pass the help menu into an ostream\n */\n void Help(std::ostream &help_) const\n {\n bool hasoptions = false;\n bool hasarguments = false;\n\n const auto description_text = Wrap(this->description, helpParams.width - helpParams.descriptionindent);\n const auto epilog_text = Wrap(this->epilog, helpParams.width - helpParams.descriptionindent);\n std::ostringstream prognameline;\n prognameline << prog;\n if (HasFlag())\n {\n hasoptions = true;\n if (helpParams.showProglineOptions)\n {\n prognameline << \" {OPTIONS}\";\n }\n }\n for (const std::string &posname: GetPosNames())\n {\n hasarguments = true;\n if (helpParams.showProglinePositionals)\n {\n prognameline << \" [\" << posname << ']';\n }\n }\n if (!proglinePostfix.empty())\n {\n prognameline << ' ' << proglinePostfix;\n }\n const auto proglines = Wrap(prognameline.str(), helpParams.width - (helpParams.progindent + 4), helpParams.width - helpParams.progindent);\n auto progit = std::begin(proglines);\n if (progit != std::end(proglines))\n {\n help_ << std::string(helpParams.progindent, ' ') << *progit << '\\n';\n ++progit;\n }\n for (; progit != std::end(proglines); ++progit)\n {\n help_ << std::string(helpParams.progtailindent, ' ') << *progit << '\\n';\n }\n\n help_ << '\\n';\n\n for (const auto &line: description_text)\n {\n help_ << std::string(helpParams.descriptionindent, ' ') << line << \"\\n\";\n }\n help_ << \"\\n\";\n help_ << std::string(helpParams.progindent, ' ') << \"OPTIONS:\\n\\n\";\n for (const auto &desc: GetChildDescriptions(shortprefix, longprefix, allowJoinedShortValue ? \"\" : \" \", allowJoinedLongValue ? longseparator : \" \"))\n {\n const auto groupindent = std::get<2>(desc) * helpParams.eachgroupindent;\n const auto flags = Wrap(std::get<0>(desc), helpParams.width - (helpParams.flagindent + helpParams.helpindent + helpParams.gutter));\n const auto info = Wrap(std::get<1>(desc), helpParams.width - (helpParams.helpindent + groupindent));\n\n std::string::size_type flagssize = 0;\n for (auto flagsit = std::begin(flags); flagsit != std::end(flags); ++flagsit)\n {\n if (flagsit != std::begin(flags))\n {\n help_ << '\\n';\n }\n help_ << std::string(groupindent + helpParams.flagindent, ' ') << *flagsit;\n flagssize = Glyphs(*flagsit);\n }\n\n auto infoit = std::begin(info);\n // groupindent is on both sides of this inequality, and therefore can be removed\n if ((helpParams.flagindent + flagssize + helpParams.gutter) > helpParams.helpindent || infoit == std::end(info))\n {\n help_ << '\\n';\n } else\n {\n // groupindent is on both sides of the minus sign, and therefore doesn't actually need to be in here\n help_ << std::string(helpParams.helpindent - (helpParams.flagindent + flagssize), ' ') << *infoit << '\\n';\n ++infoit;\n }\n for (; infoit != std::end(info); ++infoit)\n {\n help_ << std::string(groupindent + helpParams.helpindent, ' ') << *infoit << '\\n';\n }\n }\n if (hasoptions && hasarguments && helpParams.showTerminator)\n {\n 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))\n {\n help_ << std::string(helpParams.flagindent, ' ') << item << '\\n';\n }\n }\n\n help_ << \"\\n\";\n for (const auto &line: epilog_text)\n {\n help_ << std::string(helpParams.descriptionindent, ' ') << line << \"\\n\";\n }\n }\n\n /** Generate a help menu as a string.\n *\n * \\return the help text as a single string\n */\n std::string Help() const\n {\n std::ostringstream help_;\n Help(help_);\n return help_.str();\n }\n\n /** Parse all arguments.\n *\n * \\param begin an iterator to the beginning of the argument list\n * \\param end an iterator to the past-the-end element of the argument list\n * \\return the iterator after the last parsed value. Only useful for kick-out\n */\n template \n It ParseArgs(It begin, It end)\n {\n // Reset all Matched statuses and errors\n Reset();\n bool terminated = false;\n\n // Check all arg chunks\n for (auto it = begin; it != end; ++it)\n {\n const auto &chunk = *it;\n\n if (!terminated && chunk == terminator)\n {\n terminated = true;\n } else if (!terminated && ParseOption(chunk) == OptionType::LongFlag)\n {\n if (!ParseLong(it, end))\n {\n return it;\n }\n } else if (!terminated && ParseOption(chunk) == OptionType::ShortFlag)\n {\n if (!ParseShort(it, end))\n {\n return it;\n }\n } else\n {\n auto pos = GetNextPositional();\n if (pos)\n {\n pos->ParseValue(chunk);\n\n if (pos->KickOut())\n {\n return ++it;\n }\n } else\n {\n RaiseParseError(\"Passed in argument, but no positional arguments were ready to receive it: \" + chunk);\n return it;\n }\n }\n }\n\n for (Base *child: Children())\n {\n child->Validate(shortprefix, longprefix);\n }\n\n if (!Matched())\n {\n#ifdef ARGS_NOEXCEPT\n error = Error::Validation;\n#else\n std::ostringstream problem;\n problem << \"Group validation failed somewhere!\";\n throw ValidationError(problem.str());\n#endif\n }\n\n return end;\n }\n\n /** Parse all arguments.\n *\n * \\param args an iterable of the arguments\n * \\return the iterator after the last parsed value. Only useful for kick-out\n */\n template \n auto ParseArgs(const T &args) -> decltype(std::begin(args))\n {\n return ParseArgs(std::begin(args), std::end(args));\n }\n\n /** Convenience function to parse the CLI from argc and argv\n *\n * Just assigns the program name and vectorizes arguments for passing into ParseArgs()\n *\n * \\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.\n */\n bool ParseCLI(const int argc, const char * const * argv)\n {\n if (prog.empty())\n {\n prog.assign(argv[0]);\n }\n const std::vector args(argv + 1, argv + argc);\n return ParseArgs(args) == std::end(args);\n }\n };\n\n inline std::ostream &operator<<(std::ostream &os, const ArgumentParser &parser)\n {\n parser.Help(os);\n return os;\n }\n\n /** Boolean argument matcher\n */\n class Flag : public FlagBase\n {\n public:\n Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): FlagBase(name_, help_, std::move(matcher_), options_)\n {\n group_.Add(*this);\n }\n\n 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)\n {\n }\n\n virtual ~Flag() {}\n\n /** Get whether this was matched\n */\n bool Get() const\n {\n return Matched();\n }\n\n virtual Nargs NumberOfArguments() const noexcept override\n {\n return 0;\n }\n\n virtual void ParseValue(const std::vector&) override\n {\n }\n };\n\n /** Help flag class\n *\n * Works like a regular flag, but throws an instance of Help when it is matched\n */\n class HelpFlag : public Flag\n {\n public:\n HelpFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_): Flag(group_, name_, help_, std::move(matcher_)) {}\n\n virtual ~HelpFlag() {}\n\n virtual FlagBase *Match(const std::string &arg) override\n {\n if (FlagBase::Match(arg))\n {\n#ifdef ARGS_NOEXCEPT\n error = Error::Help;\n return this;\n#else\n throw Help(arg);\n#endif\n }\n return nullptr;\n }\n\n virtual FlagBase *Match(const char arg) override\n {\n if (FlagBase::Match(arg))\n {\n#ifdef ARGS_NOEXCEPT\n error = Error::Help;\n return this;\n#else\n throw Help(std::string(1, arg));\n#endif\n }\n return nullptr;\n }\n\n /** Get whether this was matched\n */\n bool Get() const noexcept\n {\n return Matched();\n }\n };\n\n /** A flag class that simply counts the number of times it's matched\n */\n class CounterFlag : public Flag\n {\n private:\n const int startcount;\n int count;\n\n public:\n 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_) {}\n\n virtual ~CounterFlag() {}\n\n virtual FlagBase *Match(const std::string &arg) override\n {\n auto me = FlagBase::Match(arg);\n if (me)\n {\n ++count;\n }\n return me;\n }\n\n virtual FlagBase *Match(const char arg) override\n {\n auto me = FlagBase::Match(arg);\n if (me)\n {\n ++count;\n }\n return me;\n }\n\n /** Get the count\n */\n int &Get() noexcept\n {\n return count;\n }\n\n virtual void Reset() noexcept override\n {\n FlagBase::Reset();\n count = startcount;\n }\n };\n\n /** A default Reader class for argument classes\n *\n * Simply uses a std::istringstream to read into the destination type, and\n * raises a ParseError if there are any characters left.\n */\n template \n struct ValueReader\n {\n bool operator ()(const std::string &name, const std::string &value, T &destination)\n {\n std::istringstream ss(value);\n ss >> destination;\n\n if (ss.rdbuf()->in_avail() > 0)\n {\n#ifdef ARGS_NOEXCEPT\n return false;\n#else\n std::ostringstream problem;\n problem << \"Argument '\" << name << \"' received invalid value type '\" << value << \"'\";\n throw ParseError(problem.str());\n#endif\n }\n return true;\n }\n };\n\n /** std::string specialization for ValueReader\n *\n * By default, stream extraction into a string splits on white spaces, and\n * it is more efficient to ust copy a string into the destination.\n */\n template <>\n struct ValueReader\n {\n bool operator()(const std::string &, const std::string &value, std::string &destination)\n {\n destination.assign(value);\n return true;\n }\n };\n\n /** An argument-accepting flag class\n * \n * \\tparam T the type to extract the argument as\n * \\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)\n */\n template <\n typename T,\n typename Reader = ValueReader>\n class ValueFlag : public ValueFlagBase\n {\n protected:\n T value;\n\n private:\n Reader reader;\n\n public:\n\n 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_)\n {\n group_.Add(*this);\n }\n\n 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)\n {\n }\n\n ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): ValueFlag(group_, name_, help_, std::move(matcher_), T(), options_)\n {\n }\n\n virtual ~ValueFlag() {}\n\n virtual void ParseValue(const std::vector &values_) override\n {\n const std::string &value_ = values_.at(0);\n\n#ifdef ARGS_NOEXCEPT\n if (!reader(name, value_, this->value))\n {\n error = Error::Parse;\n }\n#else\n reader(name, value_, this->value);\n#endif\n }\n\n /** Get the value\n */\n T &Get() noexcept\n {\n return value;\n }\n };\n\n /** An optional argument-accepting flag class\n *\n * \\tparam T the type to extract the argument as\n * \\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)\n */\n template <\n typename T,\n typename Reader = ValueReader>\n class ImplicitValueFlag : public ValueFlag\n {\n protected:\n\n T implicitValue;\n T defaultValue;\n\n public:\n\n ImplicitValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &implicitValue_, const T &defaultValue_ = T(), Options options_ = {})\n : ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, options_), implicitValue(implicitValue_), defaultValue(defaultValue_)\n {\n }\n\n ImplicitValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), Options options_ = {})\n : ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, options_), implicitValue(defaultValue_), defaultValue(defaultValue_)\n {\n }\n\n ImplicitValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_)\n : ValueFlag(group_, name_, help_, std::move(matcher_), {}, options_), implicitValue(), defaultValue()\n {\n }\n\n virtual ~ImplicitValueFlag() {}\n\n virtual Nargs NumberOfArguments() const noexcept override\n {\n return {0, 1};\n }\n\n virtual void ParseValue(const std::vector &value_) override\n {\n if (value_.empty())\n {\n this->value = implicitValue;\n } else\n {\n ValueFlag::ParseValue(value_);\n }\n }\n\n virtual void Reset() noexcept override\n {\n this->value = defaultValue;\n ValueFlag::Reset();\n }\n };\n\n /** A variadic arguments accepting flag class\n *\n * \\tparam T the type to extract the argument as\n * \\tparam List the list type that houses the values\n * \\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)\n */\n template <\n typename T,\n template class List = std::vector,\n typename Reader = ValueReader>\n class NargsValueFlag : public FlagBase\n {\n protected:\n\n List values;\n Nargs nargs;\n Reader reader;\n\n public:\n\n typedef List Container;\n typedef T value_type;\n typedef typename Container::allocator_type allocator_type;\n typedef typename Container::pointer pointer;\n typedef typename Container::const_pointer const_pointer;\n typedef T& reference;\n typedef const T& const_reference;\n typedef typename Container::size_type size_type;\n typedef typename Container::difference_type difference_type;\n typedef typename Container::iterator iterator;\n typedef typename Container::const_iterator const_iterator;\n typedef std::reverse_iterator reverse_iterator;\n typedef std::reverse_iterator const_reverse_iterator;\n\n NargsValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Nargs nargs_, const List &defaultValues_ = {}, Options options_ = {})\n : FlagBase(name_, help_, std::move(matcher_), options_), values(defaultValues_), nargs(nargs_)\n {\n group_.Add(*this);\n }\n\n virtual ~NargsValueFlag() {}\n\n virtual Nargs NumberOfArguments() const noexcept override\n {\n return nargs;\n }\n\n virtual void ParseValue(const std::vector &values_) override\n {\n values.clear();\n\n for (const std::string &value : values_)\n {\n T v;\n#ifdef ARGS_NOEXCEPT\n if (!reader(name, value, v))\n {\n error = Error::Parse;\n }\n#else\n reader(name, value, v);\n#endif\n values.insert(std::end(values), v);\n }\n }\n\n List &Get() noexcept\n {\n return values;\n }\n\n iterator begin() noexcept\n {\n return values.begin();\n }\n\n const_iterator begin() const noexcept\n {\n return values.begin();\n }\n\n const_iterator cbegin() const noexcept\n {\n return values.cbegin();\n }\n\n iterator end() noexcept\n {\n return values.end();\n }\n\n const_iterator end() const noexcept \n {\n return values.end();\n }\n\n const_iterator cend() const noexcept\n {\n return values.cend();\n }\n };\n\n /** An argument-accepting flag class that pushes the found values into a list\n * \n * \\tparam T the type to extract the argument as\n * \\tparam List the list type that houses the values\n * \\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)\n */\n template <\n typename T,\n template class List = std::vector,\n typename Reader = ValueReader>\n class ValueFlagList : public ValueFlagBase\n {\n private:\n using Container = List;\n Container values;\n Reader reader;\n\n public:\n\n typedef T value_type;\n typedef typename Container::allocator_type allocator_type;\n typedef typename Container::pointer pointer;\n typedef typename Container::const_pointer const_pointer;\n typedef T& reference;\n typedef const T& const_reference;\n typedef typename Container::size_type size_type;\n typedef typename Container::difference_type difference_type;\n typedef typename Container::iterator iterator;\n typedef typename Container::const_iterator const_iterator;\n typedef std::reverse_iterator reverse_iterator;\n typedef std::reverse_iterator const_reverse_iterator;\n\n 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_)\n {\n group_.Add(*this);\n }\n\n virtual ~ValueFlagList() {}\n\n virtual void ParseValue(const std::vector &values_) override\n {\n const std::string &value_ = values_.at(0);\n\n T v;\n#ifdef ARGS_NOEXCEPT\n if (!reader(name, value_, v))\n {\n error = Error::Parse;\n }\n#else\n reader(name, value_, v);\n#endif\n values.insert(std::end(values), v);\n }\n\n /** Get the values\n */\n Container &Get() noexcept\n {\n return values;\n }\n\n virtual std::string Name() const override\n {\n return name + std::string(\"...\");\n }\n\n virtual void Reset() noexcept override\n {\n ValueFlagBase::Reset();\n values.clear();\n }\n\n iterator begin() noexcept\n {\n return values.begin();\n }\n\n const_iterator begin() const noexcept\n {\n return values.begin();\n }\n\n const_iterator cbegin() const noexcept\n {\n return values.cbegin();\n }\n\n iterator end() noexcept\n {\n return values.end();\n }\n\n const_iterator end() const noexcept \n {\n return values.end();\n }\n\n const_iterator cend() const noexcept\n {\n return values.cend();\n }\n };\n\n /** A mapping value flag class\n * \n * \\tparam K the type to extract the argument as\n * \\tparam T the type to store the result as\n * \\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)\n * \\tparam Map The Map type. Should operate like std::map or std::unordered_map\n */\n template <\n typename K,\n typename T,\n typename Reader = ValueReader,\n template class Map = std::unordered_map>\n class MapFlag : public ValueFlagBase\n {\n private:\n const Map map;\n T value;\n Reader reader;\n\n public:\n\n 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_)\n {\n group_.Add(*this);\n }\n\n 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)\n {\n }\n\n 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_)\n {\n }\n\n virtual ~MapFlag() {}\n\n virtual void ParseValue(const std::vector &values_) override\n {\n const std::string &value_ = values_.at(0);\n\n K key;\n#ifdef ARGS_NOEXCEPT\n if (!reader(name, value_, key))\n {\n error = Error::Parse;\n }\n#else\n reader(name, value_, key);\n#endif\n auto it = map.find(key);\n if (it == std::end(map))\n {\n#ifdef ARGS_NOEXCEPT\n error = Error::Map;\n#else\n std::ostringstream problem;\n problem << \"Could not find key '\" << key << \"' in map for arg '\" << name << \"'\";\n throw MapError(problem.str());\n#endif\n } else\n {\n this->value = it->second;\n }\n }\n\n /** Get the value\n */\n T &Get() noexcept\n {\n return value;\n }\n };\n\n /** A mapping value flag list class\n * \n * \\tparam K the type to extract the argument as\n * \\tparam T the type to store the result as\n * \\tparam List the list type that houses the values\n * \\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)\n * \\tparam Map The Map type. Should operate like std::map or std::unordered_map\n */\n template <\n typename K,\n typename T,\n template class List = std::vector,\n typename Reader = ValueReader,\n template class Map = std::unordered_map>\n class MapFlagList : public ValueFlagBase\n {\n private:\n using Container = List;\n const Map map;\n Container values;\n Reader reader;\n\n public:\n typedef T value_type;\n typedef typename Container::allocator_type allocator_type;\n typedef typename Container::pointer pointer;\n typedef typename Container::const_pointer const_pointer;\n typedef T& reference;\n typedef const T& const_reference;\n typedef typename Container::size_type size_type;\n typedef typename Container::difference_type difference_type;\n typedef typename Container::iterator iterator;\n typedef typename Container::const_iterator const_iterator;\n typedef std::reverse_iterator reverse_iterator;\n typedef std::reverse_iterator const_reverse_iterator;\n\n 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_)\n {\n group_.Add(*this);\n }\n\n virtual ~MapFlagList() {}\n\n virtual void ParseValue(const std::vector &values_) override\n {\n const std::string &value = values_.at(0);\n\n K key;\n#ifdef ARGS_NOEXCEPT\n if (!reader(name, value, key))\n {\n error = Error::Parse;\n }\n#else\n reader(name, value, key);\n#endif\n auto it = map.find(key);\n if (it == std::end(map))\n {\n#ifdef ARGS_NOEXCEPT\n error = Error::Map;\n#else\n std::ostringstream problem;\n problem << \"Could not find key '\" << key << \"' in map for arg '\" << name << \"'\";\n throw MapError(problem.str());\n#endif\n } else\n {\n this->values.emplace_back(it->second);\n }\n }\n\n /** Get the value\n */\n Container &Get() noexcept\n {\n return values;\n }\n\n virtual std::string Name() const override\n {\n return name + std::string(\"...\");\n }\n\n virtual void Reset() noexcept override\n {\n ValueFlagBase::Reset();\n values.clear();\n }\n\n iterator begin() noexcept\n {\n return values.begin();\n }\n\n const_iterator begin() const noexcept\n {\n return values.begin();\n }\n\n const_iterator cbegin() const noexcept\n {\n return values.cbegin();\n }\n\n iterator end() noexcept\n {\n return values.end();\n }\n\n const_iterator end() const noexcept \n {\n return values.end();\n }\n\n const_iterator cend() const noexcept\n {\n return values.cend();\n }\n };\n\n /** A positional argument class\n *\n * \\tparam T the type to extract the argument as\n * \\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)\n */\n template <\n typename T,\n typename Reader = ValueReader>\n class Positional : public PositionalBase\n {\n private:\n T value;\n Reader reader;\n public:\n 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_)\n {\n group_.Add(*this);\n }\n\n Positional(Group &group_, const std::string &name_, const std::string &help_, Options options_): Positional(group_, name_, help_, T(), options_)\n {\n }\n\n virtual ~Positional() {}\n\n virtual void ParseValue(const std::string &value_) override\n {\n#ifdef ARGS_NOEXCEPT\n if (!reader(name, value_, this->value))\n {\n error = Error::Parse;\n }\n#else\n reader(name, value_, this->value);\n#endif\n ready = false;\n matched = true;\n }\n\n /** Get the value\n */\n T &Get() noexcept\n {\n return value;\n }\n };\n\n /** A positional argument class that pushes the found values into a list\n * \n * \\tparam T the type to extract the argument as\n * \\tparam List the list type that houses the values\n * \\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)\n */\n template <\n typename T,\n template class List = std::vector,\n typename Reader = ValueReader>\n class PositionalList : public PositionalBase\n {\n private:\n using Container = List;\n Container values;\n Reader reader;\n\n public:\n typedef T value_type;\n typedef typename Container::allocator_type allocator_type;\n typedef typename Container::pointer pointer;\n typedef typename Container::const_pointer const_pointer;\n typedef T& reference;\n typedef const T& const_reference;\n typedef typename Container::size_type size_type;\n typedef typename Container::difference_type difference_type;\n typedef typename Container::iterator iterator;\n typedef typename Container::const_iterator const_iterator;\n typedef std::reverse_iterator reverse_iterator;\n typedef std::reverse_iterator const_reverse_iterator;\n\n PositionalList(Group &group_, const std::string &name_, const std::string &help_, const Container &defaultValues_ = Container()): PositionalBase(name_, help_), values(defaultValues_)\n {\n group_.Add(*this);\n }\n\n virtual ~PositionalList() {}\n\n virtual void ParseValue(const std::string &value_) override\n {\n T v;\n#ifdef ARGS_NOEXCEPT\n if (!reader(name, value_, v))\n {\n error = Error::Parse;\n }\n#else\n reader(name, value_, v);\n#endif\n values.insert(std::end(values), v);\n matched = true;\n }\n\n virtual std::string Name() const override\n {\n return name + std::string(\"...\");\n }\n\n /** Get the values\n */\n Container &Get() noexcept\n {\n return values;\n }\n\n virtual void Reset() noexcept override\n {\n PositionalBase::Reset();\n values.clear();\n }\n\n iterator begin() noexcept\n {\n return values.begin();\n }\n\n const_iterator begin() const noexcept\n {\n return values.begin();\n }\n\n const_iterator cbegin() const noexcept\n {\n return values.cbegin();\n }\n\n iterator end() noexcept\n {\n return values.end();\n }\n\n const_iterator end() const noexcept \n {\n return values.end();\n }\n\n const_iterator cend() const noexcept\n {\n return values.cend();\n }\n };\n\n /** A positional argument mapping class\n * \n * \\tparam K the type to extract the argument as\n * \\tparam T the type to store the result as\n * \\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)\n * \\tparam Map The Map type. Should operate like std::map or std::unordered_map\n */\n template <\n typename K,\n typename T,\n typename Reader = ValueReader,\n template class Map = std::unordered_map>\n class MapPositional : public PositionalBase\n {\n private:\n const Map map;\n T value;\n Reader reader;\n\n public:\n\n 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_)\n {\n group_.Add(*this);\n }\n\n virtual ~MapPositional() {}\n\n virtual void ParseValue(const std::string &value_) override\n {\n K key;\n#ifdef ARGS_NOEXCEPT\n if (!reader(name, value_, key))\n {\n error = Error::Parse;\n }\n#else\n reader(name, value_, key);\n#endif\n auto it = map.find(key);\n if (it == std::end(map))\n {\n#ifdef ARGS_NOEXCEPT\n error = Error::Map;\n#else\n std::ostringstream problem;\n problem << \"Could not find key '\" << key << \"' in map for arg '\" << name << \"'\";\n throw MapError(problem.str());\n#endif\n } else\n {\n this->value = it->second;\n ready = false;\n matched = true;\n }\n }\n\n /** Get the value\n */\n T &Get() noexcept\n {\n return value;\n }\n };\n\n /** A positional argument mapping list class\n * \n * \\tparam K the type to extract the argument as\n * \\tparam T the type to store the result as\n * \\tparam List the list type that houses the values\n * \\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)\n * \\tparam Map The Map type. Should operate like std::map or std::unordered_map\n */\n template <\n typename K,\n typename T,\n template class List = std::vector,\n typename Reader = ValueReader,\n template class Map = std::unordered_map>\n class MapPositionalList : public PositionalBase\n {\n private:\n using Container = List;\n\n const Map map;\n Container values;\n Reader reader;\n\n public:\n typedef T value_type;\n typedef typename Container::allocator_type allocator_type;\n typedef typename Container::pointer pointer;\n typedef typename Container::const_pointer const_pointer;\n typedef T& reference;\n typedef const T& const_reference;\n typedef typename Container::size_type size_type;\n typedef typename Container::difference_type difference_type;\n typedef typename Container::iterator iterator;\n typedef typename Container::const_iterator const_iterator;\n typedef std::reverse_iterator reverse_iterator;\n typedef std::reverse_iterator const_reverse_iterator;\n\n 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_)\n {\n group_.Add(*this);\n }\n\n virtual ~MapPositionalList() {}\n\n virtual void ParseValue(const std::string &value_) override\n {\n K key;\n#ifdef ARGS_NOEXCEPT\n if (!reader(name, value_, key))\n {\n error = Error::Parse;\n }\n#else\n reader(name, value_, key);\n#endif\n auto it = map.find(key);\n if (it == std::end(map))\n {\n#ifdef ARGS_NOEXCEPT\n error = Error::Map;\n#else\n std::ostringstream problem;\n problem << \"Could not find key '\" << key << \"' in map for arg '\" << name << \"'\";\n throw MapError(problem.str());\n#endif\n } else\n {\n this->values.emplace_back(it->second);\n matched = true;\n }\n }\n\n /** Get the value\n */\n Container &Get() noexcept\n {\n return values;\n }\n\n virtual std::string Name() const override\n {\n return name + std::string(\"...\");\n }\n\n virtual void Reset() noexcept override\n {\n PositionalBase::Reset();\n values.clear();\n }\n\n iterator begin() noexcept\n {\n return values.begin();\n }\n\n const_iterator begin() const noexcept\n {\n return values.begin();\n }\n\n const_iterator cbegin() const noexcept\n {\n return values.cbegin();\n }\n\n iterator end() noexcept\n {\n return values.end();\n }\n\n const_iterator end() const noexcept \n {\n return values.end();\n }\n\n const_iterator cend() const noexcept\n {\n return values.cend();\n }\n };\n}\n\n#endif\n" }, { "path": "asm-methods.asm", "content": "BITS 64\ndefault rel\n\n%if (__NASM_MAJOR__ < 2) || (__NASM_MINOR__ < 11)\n%deftok ver __NASM_VER__\n%error Your nasm version (ver) is too old, you need at least 2.11 to compile this\n%endif\n\n%include \"nasm-utils-inc.asm\"\n\nnasm_util_assert_boilerplate\nthunk_boilerplate\n\n; aligns and declares the global label for the bench with the given name\n; also potentally checks the ABI compliance (if enabled)\n%macro define_func 1\nabi_checked_function %1\n%endmacro\n\n; define a test func that unrolls the loop by 100\n; with the given body instruction\n; %1 - function name\n; %2 - init instruction (e.g., xor out the variable you'll add to)\n; %3 - loop body instruction\n; %4 - repeat count, defaults to 100 - values other than 100 mean the Mops value will be wrong\n%macro test_func 3-4 100\ndefine_func %1\n%2\n.top:\ntimes %4 %3\nsub rdi, 100\njnz .top\nret\n%endmacro\n\n; pause\ntest_func pause_only, {}, {pause}, 1\n\n; vpermw latency\ntest_func avx512_vpermw, {vpcmpeqd ymm0, ymm0, ymm0}, {vpermw zmm0, zmm0, zmm0}\n\n; vpermb latency\ntest_func avx512_vpermd, {vpcmpeqd ymm0, ymm0, ymm0}, {vpermd zmm0, zmm0, zmm0}\n\n; imul latency\ntest_func avx128_imul, {vpcmpeqd xmm0, xmm0, xmm0}, {vpmuldq xmm0, xmm0, xmm0}\ntest_func avx256_imul, {vpcmpeqd ymm0, ymm0, ymm0}, {vpmuldq ymm0, ymm0, ymm0}\ntest_func avx512_imul, {vpcmpeqd ymm0, ymm0, ymm0}, {vpmuldq zmm0, zmm0, zmm0}\n\n; imul throughput\ntest_func avx128_imul_t, {vpcmpeqd xmm0, xmm0, xmm0}, {vpmuldq xmm0, xmm1, xmm1}\ntest_func avx256_imul_t, {vpcmpeqd ymm0, ymm0, ymm0}, {vpmuldq ymm0, ymm1, ymm1}\ntest_func avx512_imul_t, {vpcmpeqd ymm0, ymm0, ymm0}, {vpmuldq zmm0, zmm1, zmm1}\n\n; iadd latency\ntest_func scalar_iadd, {xor eax, eax}, {add rax, rax}\n\ntest_func avx128_iadd, {vpcmpeqd xmm0, xmm0, xmm0}, {vpaddq xmm0, xmm0, xmm0}\ntest_func avx256_iadd, {vpcmpeqd ymm0, ymm0, ymm0}, {vpaddq ymm0, ymm0, ymm0}\ntest_func avx512_iadd, {vpcmpeqd ymm0, ymm0, ymm0}, {vpaddq zmm0, zmm0, zmm0}\n\n; iadd latency with zmm16\ntest_func avx128_iadd16, {vpternlogd xmm16, xmm16, xmm16, 0xff}, {vpaddq xmm16, xmm16, xmm16}\ntest_func avx256_iadd16, {vpternlogd ymm16, ymm16, ymm16, 0xff}, {vpaddq ymm16, ymm16, ymm16}\ntest_func avx512_iadd16, {vpternlogd zmm16, zmm16, zmm16, 0xff}, {vpaddq zmm16, zmm16, zmm16}\n\n; iadd throughput\ntest_func avx128_iadd_t, {vpcmpeqd xmm1, xmm0, xmm0}, {vpaddq xmm0, xmm1, xmm1}\ntest_func avx256_iadd_t, {vpcmpeqd ymm1, ymm0, ymm0}, {vpaddq ymm0, ymm1, ymm1}\n\n; zeroing xor\ntest_func avx128_xor_zero, {}, {vpxor xmm0, xmm0, xmm0}\ntest_func avx256_xor_zero, {}, {vpxor ymm0, ymm0, ymm0}\ntest_func avx512_xor_zero, {}, {vpxord zmm0, zmm0, zmm0}\n\n; vpsrlvd latency\ntest_func avx128_vshift, {vpcmpeqd xmm1, xmm0, xmm0}, {vpsrlvd xmm0, xmm0, xmm0}\ntest_func avx256_vshift, {vpcmpeqd xmm1, xmm0, xmm0}, {vpsrlvd ymm0, ymm0, ymm0}\ntest_func avx512_vshift, {vpcmpeqd xmm1, xmm0, xmm0}, {vpsrlvd zmm0, zmm0, zmm0}\n\n; vpsrlvd throughput\ntest_func avx128_vshift_t,{vpcmpeqd xmm1, xmm0, xmm0}, {vpsrlvd xmm0, xmm1, xmm1}\ntest_func avx256_vshift_t,{vpcmpeqd xmm1, xmm0, xmm0}, {vpsrlvd ymm0, ymm1, ymm1}\ntest_func avx512_vshift_t,{vpcmpeqd xmm1, xmm0, xmm0}, {vpsrlvd zmm0, zmm1, zmm1}\n\n; vplzcntd latency\ntest_func avx128_vlzcnt, {vpcmpeqd xmm1, xmm0, xmm0}, {vplzcntd xmm0, xmm0}\ntest_func avx256_vlzcnt, {vpcmpeqd xmm1, xmm0, xmm0}, {vplzcntd ymm0, ymm0}\ntest_func avx512_vlzcnt, {vpcmpeqd xmm1, xmm0, xmm0}, {vplzcntd zmm0, zmm0}\n\n; vplzcntd throughput\ntest_func avx128_vlzcnt_t,{vpcmpeqd xmm1, xmm0, xmm0}, {vplzcntd xmm0, xmm1}\ntest_func avx256_vlzcnt_t,{vpcmpeqd xmm1, xmm0, xmm0}, {vplzcntd ymm0, ymm1}\ntest_func avx512_vlzcnt_t,{vpcmpeqd xmm1, xmm0, xmm0}, {vplzcntd zmm0, zmm1}\n\n; FMA\ntest_func avx128_fma , {vpxor xmm0, xmm0, xmm0}, {vfmadd132pd xmm0, xmm0, xmm0}\ntest_func avx256_fma , {vpxor xmm0, xmm0, xmm0}, {vfmadd132pd ymm0, ymm0, ymm0}\ntest_func avx512_fma , {vpxor xmm0, xmm0, xmm0}, {vfmadd132pd zmm0, zmm0, zmm0}\n\n; this is like test_func, but it uses 10 parallel chains of instructions,\n; unrolled 10 times, so (probably) max throughput at least if latency * throughput\n; product for the instruction <= 10\n; %1 - function name\n; %2 - init instruction (e.g., xor out the variable you'll add to)\n; %3 - register base like xmm, ymm, zmm\n; %4 - loop body instruction only (no operands)\n; %5 - init value for xmm0-9, used as first (dest) arg as in vfmadd132pd xmm0..9, xmm10, xmm11\n; %6 - init value for xmm10, used as second arg as in vfmadd132pd reg, xmm10, xmm11\n; %7 - init value for xmm11, used as third arg as in vfmadd132pd reg, xmm10, xmm11\n%macro test_func_tput 7\ndefine_func %1\n\n; init reg 0-9\n%assign r 0\n%rep 10\n%2 %3 %+ r, %5\n%assign r (r+1)\n%endrep\n\n; init reg10, reg11\n%2 %3 %+ 10, %6\n%2 %3 %+ 11, %7\n\n.top:\n%rep 10\n%assign r 0\n%rep 10\n%4 %3 %+ r, %3 %+ 10, %3 %+ 11\n%assign r (r+1)\n%endrep\n%endrep\nsub rdi, 100\njnz .top\nret\n%endmacro\n\ntest_func_tput avx128_fma_t , vmovddup, xmm, vfmadd132pd, [zero_dp], [one_dp], [half_dp]\ntest_func_tput avx256_fma_t , vbroadcastsd, ymm, vfmadd132pd, [zero_dp], [one_dp], [half_dp]\ntest_func_tput avx512_fma_t , vbroadcastsd, zmm, vfmadd132pd, [zero_dp], [one_dp], [half_dp]\ntest_func_tput avx512_vpermw_t ,vbroadcastsd, zmm, vpermw, [zero_dp], [one_dp], [half_dp]\ntest_func_tput avx512_vpermd_t ,vbroadcastsd, zmm, vpermd, [zero_dp], [one_dp], [half_dp]\n\n; this is like test_func except that the 100x unrolled loop instruction is\n; always a serial scalar add, while the passed instruction to test is only\n; executed once per loop (so at a ratio of 1:100 for the scalar adds). This\n; test the effect of an \"occasional\" AVX instruction.\n; %1 - function name\n; %2 - init instruction (e.g., xor out the variable you'll add to)\n; %3 - loop body instruction\n%macro test_func_sparse 4\ndefine_func %1\n%2\n%4\nxor eax, eax\n.top:\n%3\ntimes 100 add eax, eax\nsub rdi, 100\njnz .top\nret\n%endmacro\n\ntest_func_sparse avx128_mov_sparse, {vbroadcastsd ymm0, [one_dp]}, {vmovdqa xmm0, xmm0}, {}\ntest_func_sparse avx256_mov_sparse, {vbroadcastsd ymm0, [one_dp]}, {vmovdqa ymm0, ymm0}, {}\ntest_func_sparse avx512_mov_sparse, {vbroadcastsd zmm0, [one_dp]}, {vmovdqa32 zmm0, zmm0}, {}\ntest_func_sparse avx128_merge_sparse, {vbroadcastsd ymm0, [one_dp]}, {vmovdqa32 xmm0{k1}, xmm0}, {kmovw k1, [kmask]}\ntest_func_sparse avx256_merge_sparse, {vbroadcastsd ymm0, [one_dp]}, {vmovdqa32 ymm0{k1}, ymm0}, {kmovw k1, [kmask]}\ntest_func_sparse avx512_merge_sparse, {vbroadcastsd zmm0, [one_dp]}, {vmovdqa32 zmm0{k1}, zmm0}, {kmovw k1, [kmask]}\n\ntest_func_sparse avx128_fma_sparse, {vbroadcastsd ymm0, [zero_dp]}, {vfmadd132pd xmm0, xmm0, xmm0 }, {}\ntest_func_sparse avx256_fma_sparse, {vbroadcastsd ymm0, [zero_dp]}, {vfmadd132pd ymm0, ymm0, ymm0 }, {}\ntest_func_sparse avx512_fma_sparse, {vbroadcastsd zmm0, [zero_dp]}, {vfmadd132pd zmm0, zmm0, zmm0 }, {}\n\n; %1 function name suffix\n; %2 dirty instruction\n%macro define_ucomis 2\ndefine_func ucomis_%1\n;vpxor xmm15, xmm15, xmm15\n;vzeroupper\n%2\nmovdqu xmm0, [one_dp]\nmovdqu xmm2, [one_dp]\nmovdqu xmm1, [zero_dp]\nalign 64\n.top:\n%rep 100\naddsd xmm0, xmm2\nucomisd xmm1, xmm0\nja .never\n%endrep\nsub rdi, 100\njnz .top\nret\n.never:\nud2\n%endmacro\n\ndefine_ucomis clean, {vzeroupper}\ndefine_ucomis dirty, {}\n\n\ndefine_func dirty_it\nvzeroupper\nvpxord zmm15, zmm14, zmm15\nret\n\ndefine_func dirty_it16\nvzeroupper\nvpxord zmm16, zmm14, zmm15\nret\n\nGLOBAL zeroupper_asm:function\nzeroupper_asm:\nvzeroupper\nret\n\nzero_dp: dq 0.0\nhalf_dp: dq 0.5\none_dp: dq 1.0\nkmask: dq 0x5555555555555555\n\n\n\n" }, { "path": "atomic.h", "content": "/* Atomic operations (v1)\n * Portable Snippets - https://gitub.com/nemequ/portable-snippets\n * Created by Evan Nemerson \n *\n * To the extent possible under law, the authors have waived all\n * copyright and related or neighboring rights to this code. For\n * details, see the Creative Commons Zero 1.0 Universal license at\n * https://creativecommons.org/publicdomain/zero/1.0/\n *\n * This is a small abstraction layer for some common atomic operations\n * (load, store, add, subtract, and compare & swap) implemented using\n * various compiler-specific builtins.\n *\n * There are four types, 32-bit and 64-bit integers which are both\n * atomic and non-atomic. The atomic versions should be used for the\n * atomic variable, the non-atomic variables should be used to store\n * values read from or written to an atomic variable. For example, a\n * basic CAS loop:\n *\n * void square_dest(psnip_atomic_int64* value) {\n * psnip_int64_t expected;\n * do {\n * expected = psnip_atomic_int64_load(&value);\n * } while (!psnip_atomic_int64_compare_exchange(&value, &expected, expected * expected));\n * }\n *\n * Most things are implemented with the preprocessor, but if they were\n * functions the prototypes (the 64-bit versions, just s/64/32/ for\n * the 32-bit versions) would loo like:\n *\n * psnip_int64_t psnip_atomic_int64_load(\n * psnip_atomic_int64* object);\n * void psnip_atomic_int64_store(\n * psnip_atomic_int64* object,\n * psnip_int64_t desired);\n * _Bool psnip_atomic_int64_compare_exchange(\n * psnip_atomic_int64* object,\n * psnip_int64_t* expected,\n * psnip_int64_t desired);\n * psnip_int64_t psnip_atomic_int64_add(\n * psnip_atomic_int64* object,\n * psnip_int64_t operand);\n * psnip_int64_t psnip_atomic_int64_sub(\n * psnip_atomic_int64* object,\n * psnip_int64_t operand);\n */\n\n#if !defined(PSNIP_ATOMIC_H)\n#define PSNIP_ATOMIC_H\n\n#if !defined(psnip_int64_t) || !defined(psnip_int32_t)\n# include \"exact-int.h\"\n#endif\n\n#if !defined(PSNIP_ATOMIC_STATIC_INLINE)\n# if defined(__GNUC__)\n# define PSNIP_ATOMIC__COMPILER_ATTRIBUTES __attribute__((__unused__))\n# else\n# define PSNIP_ATOMIC__COMPILER_ATTRIBUTES\n# endif\n\n# if defined(HEDLEY_INLINE)\n# define PSNIP_ATOMIC__INLINE HEDLEY_INLINE\n# elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L\n# define PSNIP_ATOMIC__INLINE inline\n# elif defined(__GNUC_STDC_INLINE__)\n# define PSNIP_ATOMIC__INLINE __inline__\n# elif defined(_MSC_VER) && _MSC_VER >= 1200\n# define PSNIP_ATOMIC__INLINE __inline\n# else\n# define PSNIP_ATOMIC__INLINE\n# endif\n\n# define PSNIP_ATOMIC__FUNCTION PSNIP_ATOMIC__COMPILER_ATTRIBUTES static PSNIP_ATOMIC__INLINE\n#endif\n\n#if defined(__has_feature)\n# define PSNIP_ATOMIC_HAS_FEATURE(feature) __has_feature(feature)\n#else\n# define PSNIP_ATOMIC_HAS_FEATURE(feature) 0\n#endif\n\n#define PSNIP_ATOMIC_IMPL_NONE 0\n#define PSNIP_ATOMIC_IMPL_GCC 1\n#define PSNIP_ATOMIC_IMPL_GCC_SYNC 2\n#define PSNIP_ATOMIC_IMPL_CLANG 3\n#define PSNIP_ATOMIC_IMPL_MS 4\n#define PSNIP_ATOMIC_IMPL_OPENMP 5\n#define PSNIP_ATOMIC_IMPL_C11 11\n\n#if defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))\n# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_GCC\n#elif !defined(__INTEL_COMPILER) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_ATOMICS__)\n/* GCC 4.7 and 4.8 sets __STDC_VERSION__ to C11 (if compiling in C11\n * mode) and didn't have stdatomic.h, but failed to set\n * __STDC_NO_ATOMICS__. Verions prior to 4.7 didn't set\n * __STDC_VERSION__ to C11. */\n# if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 9)\n# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_GCC\n# else\n# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_C11\n# endif\n#elif defined(_MSC_VER)\n# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_MS\n#elif defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))\n# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_GCC\n#elif PSNIP_ATOMIC_HAS_FEATURE(c_atomic)\n# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_CLANG\n#elif defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1))\n# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_GCC_SYNC\n#elif (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x5140)) || (defined(__SUNPRO_CC) && (__SUNPRO_CC >= 0x5140))\n# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_GCC\n#elif defined(_OPENMP)\n# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_OPENMP\n#else\n# define PSNIP_ATOMIC_NOT_FOUND\n# define PSNIP_ATOMIC_IMPL PSNIP_ATOMIC_IMPL_NONE\n# warning No atomic implementation found\n#endif\n\n#if !defined(PSNIP_ATOMIC_NOT_FOUND)\n\n#if PSNIP_ATOMIC_IMPL == PSNIP_ATOMIC_IMPL_C11\n\n#include \ntypedef atomic_int_fast64_t psnip_atomic_int64;\ntypedef atomic_int_fast32_t psnip_atomic_int32;\n\n#define PSNIP_ATOMIC_VAR_INIT(value) ATOMIC_VAR_INIT(value)\n\n#define psnip_atomic_int64_load(object) \\\n atomic_load(object)\n#define psnip_atomic_int64_store(object, desired) \\\n atomic_store(object, desired)\n#define psnip_atomic_int64_compare_exchange(object, expected, desired) \\\n atomic_compare_exchange_strong(object, expected, desired)\n#define psnip_atomic_int64_add(object, operand) \\\n atomic_fetch_add(object, operand)\n#define psnip_atomic_int64_sub(object, operand) \\\n atomic_fetch_sub(object, operand)\n#define psnip_atomic_fence() \\\n atomic_thread_fence(memory_order_seq_cst)\n\n#define PSNIP_ATOMIC_IS_TG\n\n#elif PSNIP_ATOMIC_IMPL == PSNIP_ATOMIC_IMPL_CLANG\n\n#include \ntypedef _Atomic psnip_int64_t psnip_atomic_int64;\ntypedef _Atomic psnip_int32_t psnip_atomic_int32;\n\n#define psnip_atomic_int64_load(object) \\\n __c11_atomic_load(object, __ATOMIC_SEQ_CST)\n#define psnip_atomic_int64_store(object, desired) \\\n __c11_atomic_store(object, desired, __ATOMIC_SEQ_CST)\n#define psnip_atomic_int64_compare_exchange(object, expected, desired) \\\n __c11_atomic_compare_exchange_strong(object, expected, desired, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)\n#define psnip_atomic_int64_add(object, operand) \\\n __c11_atomic_fetch_add(object, operand, __ATOMIC_SEQ_CST)\n#define psnip_atomic_int64_sub(object, operand) \\\n __c11_atomic_fetch_sub(object, operand, __ATOMIC_SEQ_CST)\n#define psnip_atomic_fence() \\\n __c11_atomic_thread_fence(__ATOMIC_SEQ_CST)\n\n#define PSNIP_ATOMIC_IS_TG\n\n#elif PSNIP_ATOMIC_IMPL == PSNIP_ATOMIC_IMPL_GCC\n\n#include \n#if !defined(__INTEL_COMPILER) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)) && !defined(_OPENMP)\ntypedef _Atomic psnip_int64_t psnip_atomic_int64;\ntypedef _Atomic psnip_int32_t psnip_atomic_int32;\n#else\ntypedef psnip_int64_t psnip_atomic_int64;\ntypedef psnip_int32_t psnip_atomic_int32;\n#endif\n\n#define psnip_atomic_int64_load(object) \\\n __atomic_load_n(object, __ATOMIC_SEQ_CST)\n#define psnip_atomic_int64_store(object, desired) \\\n __atomic_store_n(object, desired, __ATOMIC_SEQ_CST)\n#define psnip_atomic_int64_compare_exchange(object, expected, desired) \\\n __atomic_compare_exchange_n(object, expected, desired, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)\n#define psnip_atomic_int64_add(object, operand) \\\n __atomic_add_fetch(object, operand, __ATOMIC_SEQ_CST)\n#define psnip_atomic_int64_sub(object, operand) \\\n __atomic_sub_fetch(object, operand, __ATOMIC_SEQ_CST)\n#define psnip_atomic_fence() \\\n __atomic_thread_fence(__ATOMIC_SEQ_CST)\n\n#define PSNIP_ATOMIC_IS_TG\n\n#elif PSNIP_ATOMIC_IMPL == PSNIP_ATOMIC_IMPL_GCC_SYNC\n\n#include \ntypedef psnip_int64_t psnip_atomic_int64;\ntypedef psnip_int32_t psnip_atomic_int32;\n\nPSNIP_ATOMIC__FUNCTION\npsnip_int64_t\npsnip_atomic_int64_load(psnip_atomic_int64* object) {\n __sync_synchronize();\n return (psnip_int64_t) *object;\n}\n\nPSNIP_ATOMIC__FUNCTION\nvoid\npsnip_atomic_int64_store(psnip_atomic_int64* object, psnip_int64_t desired) {\n *object = desired;\n __sync_synchronize();\n}\n\n#define psnip_atomic_int64_compare_exchange(object, expected, desired) \\\n __sync_bool_compare_and_swap(object, *(expected), desired)\n#define psnip_atomic_int64_add(object, operand) \\\n __sync_fetch_and_add(object, operand)\n#define psnip_atomic_int64_sub(object, operand) \\\n __sync_fetch_and_sub(object, operand)\n\nPSNIP_ATOMIC__FUNCTION\npsnip_int32_t\npsnip_atomic_int32_load(psnip_atomic_int32* object) {\n __sync_synchronize();\n return (psnip_int32_t) *object;\n}\n\nPSNIP_ATOMIC__FUNCTION\nvoid\npsnip_atomic_int32_store(psnip_atomic_int32* object, psnip_int32_t desired) {\n *object = desired;\n __sync_synchronize();\n}\n\n#define psnip_atomic_int32_compare_exchange(object, expected, desired) \\\n __sync_bool_compare_and_swap(object, *(expected), desired)\n#define psnip_atomic_int32_add(object, operand) \\\n __sync_fetch_and_add(object, operand)\n#define psnip_atomic_int32_sub(object, operand) \\\n __sync_fetch_and_sub(object, operand)\n\n#define psnip_atomic_fence() \\\n __sync_synchronize()\n\n#elif PSNIP_ATOMIC_IMPL == PSNIP_ATOMIC_IMPL_MS\n\n#include \n\ntypedef long long volatile psnip_atomic_int64;\ntypedef long volatile psnip_atomic_int32;\n\n#define psnip_atomic_int32_load(object) \\\n __pragma(warning(push)) \\\n __pragma(warning(disable:28112)) \\\n (*(object)) \\\n __pragma(warning(pop))\n#define psnip_atomic_int32_store(object, desired) \\\n InterlockedExchange(object, desired)\n#define psnip_atomic_int32_compare_exchange(object, expected, desired) \\\n InterlockedCompareExchange(object, desired, *(expected))\n#define psnip_atomic_int32_add(object, operand) \\\n InterlockedExchangeAdd(object, operand)\n#define psnip_atomic_int32_sub(object, operand) \\\n InterlockedExchangeAdd(object, -(operand))\n\n#define psnip_atomic_int64_load(object) \\\n __pragma(warning(push)) \\\n __pragma(warning(disable:28112)) \\\n (*(object)) \\\n __pragma(warning(pop))\n#define psnip_atomic_int64_store(object, desired) \\\n InterlockedExchange64(object, desired)\n#define psnip_atomic_int64_compare_exchange(object, expected, desired) \\\n InterlockedCompareExchange64(object, desired, *(expected))\n#define psnip_atomic_int64_add(object, operand) \\\n InterlockedExchangeAdd64(object, operand)\n#define psnip_atomic_int64_sub(object, operand) \\\n InterlockedExchangeAdd64(object, -(operand))\n\n#define psnip_atomic_fence() \\\n MemoryBarrier()\n\n#elif PSNIP_ATOMIC_IMPL == PSNIP_ATOMIC_IMPL_OPENMP\n\n#include \ntypedef psnip_int64_t psnip_atomic_int64;\ntypedef psnip_int32_t psnip_atomic_int32;\n\nPSNIP_ATOMIC__FUNCTION\npsnip_int64_t\npsnip_atomic_int64_load(psnip_atomic_int64* object) {\n psnip_int64_t ret;\n#pragma omp critical(psnip_atomic)\n ret = *object;\n return ret;\n}\n\nPSNIP_ATOMIC__FUNCTION\nvoid\npsnip_atomic_int64_store(psnip_atomic_int64* object, psnip_int64_t desired) {\n#pragma omp critical(psnip_atomic)\n *object = desired;\n}\n\nPSNIP_ATOMIC__FUNCTION\nint\npsnip_atomic_int64_compare_exchange_(psnip_atomic_int64* object, psnip_int64_t* expected, psnip_int64_t desired) {\n int ret;\n#pragma omp critical(psnip_atomic)\n ret = (*object == *expected) ? ((*object = desired), 1) : 0;\n return ret;\n}\n\n#define psnip_atomic_int64_compare_exchange(object, expected, desired) \\\n psnip_atomic_int64_compare_exchange_(object, expected, desired)\n\nPSNIP_ATOMIC__FUNCTION\npsnip_int64_t\npsnip_atomic_int64_add(psnip_atomic_int64* object, psnip_int64_t operand) {\n int ret;\n#pragma omp critical(psnip_atomic)\n *object = (ret = *object) + operand;\n return ret;\n}\n\nPSNIP_ATOMIC__FUNCTION\npsnip_int64_t\npsnip_atomic_int64_sub(psnip_atomic_int64* object, psnip_int64_t operand) {\n int ret;\n#pragma omp critical(psnip_atomic)\n *object = (ret = *object) - operand;\n return ret;\n}\nPSNIP_ATOMIC__FUNCTION\npsnip_int32_t\npsnip_atomic_int32_load(psnip_atomic_int32* object) {\n psnip_int32_t ret;\n#pragma omp critical(psnip_atomic)\n ret = *object;\n return ret;\n}\n\nPSNIP_ATOMIC__FUNCTION\nvoid\npsnip_atomic_int32_store(psnip_atomic_int32* object, psnip_int32_t desired) {\n#pragma omp critical(psnip_atomic)\n *object = desired;\n}\n\nPSNIP_ATOMIC__FUNCTION\nint\npsnip_atomic_int32_compare_exchange_(psnip_atomic_int32* object, psnip_int32_t* expected, psnip_int32_t desired) {\n int ret = 1;\n#pragma omp critical(psnip_atomic)\n ret = (*object == *expected) ? ((*object = desired), 1) : 0;\n return ret;\n}\n\n#define psnip_atomic_int32_compare_exchange(object, expected, desired) \\\n psnip_atomic_int32_compare_exchange_(object, expected, desired)\n\nPSNIP_ATOMIC__FUNCTION\npsnip_int32_t\npsnip_atomic_int32_add(psnip_atomic_int32* object, psnip_int32_t operand) {\n int ret;\n#pragma omp critical(psnip_atomic)\n *object = (ret = *object) + operand;\n return ret;\n}\n\nPSNIP_ATOMIC__FUNCTION\npsnip_int32_t\npsnip_atomic_int32_sub(psnip_atomic_int32* object, psnip_int32_t operand) {\n int ret;\n#pragma omp critical(psnip_atomic)\n *object = (ret = *object) - operand;\n return ret;\n}\n\nPSNIP_ATOMIC__FUNCTION\nvoid\npsnip_atomic_fence() {\n#pragma omp critical(psnip_atomic)\n { }\n}\n\n\n#endif\n\n#if !defined(PSNIP_ATOMIC_VAR_INIT)\n# define PSNIP_ATOMIC_VAR_INIT(value) (value)\n#endif\n\n/* Most compilers have type-generic atomic implementations. */\n#if defined(PSNIP_ATOMIC_IS_TG)\n#define psnip_atomic_int32_load(object) \\\n psnip_atomic_int64_load(object)\n#define psnip_atomic_int32_store(object, desired) \\\n psnip_atomic_int64_store(object, desired)\n#define psnip_atomic_int32_compare_exchange(object, expected, desired) \\\n psnip_atomic_int64_compare_exchange(object, expected, desired)\n#define psnip_atomic_int32_add(object, operand) \\\n psnip_atomic_int64_add(object, operand)\n#define psnip_atomic_int32_sub(object, operand) \\\n psnip_atomic_int64_sub(object, operand)\n#endif /* defined(PSNIP_ATOMIC_IS_TG) */\n\n#endif /* !defined(PSNIP_ATOMIC_NOT_FOUND) */\n\n#endif /* defined(PSNIP_ATOMIC_H) */\n" }, { "path": "avx-turbo.cpp", "content": "/*\n * avx-turbo.cpp\n */\n\n#include \"args.hxx\"\n#include \"cpu.h\"\n#include \"cpuid.hpp\"\n#include \"msr-access.h\"\n#include \"stats.hpp\"\n#include \"tsc-support.hpp\"\n#include \"table.hpp\"\n#include \"util.hpp\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n\n#define MSR_IA32_MPERF 0x000000e7\n#define MSR_IA32_APERF 0x000000e8\n\nusing std::uint64_t;\nusing namespace std::chrono;\n\nusing namespace Stats;\n\ntypedef void (cal_f)(uint64_t iters);\n\nenum ISA {\n BASE = 1 << 0,\n AVX2 = 1 << 1,\n AVX512F = 1 << 2, // note: does not imply VL, so xmm and ymm may not be available\n AVX512VL = 1 << 3, // note: does not imply F, although i don't know any CPU with VL but not F\n AVX512CD = 1 << 4,\n AVX512BW = 1 << 5,\n};\n\nstruct test_func {\n // function pointer to the test function\n cal_f* func;\n const char* id;\n const char* description;\n ISA isa;\n};\n\n\n#define FUNCS_X(x) \\\n x(pause_only , \"pause instruction\" , BASE) \\\n x(ucomis_clean , \"scalar ucomis (w/ vzeroupper)\" , AVX2) \\\n x(ucomis_dirty , \"scalar ucomis (no vzeroupper)\" , AVX2) \\\n \\\n /* iadd */ \\\n x(scalar_iadd , \"Scalar integer adds\" , BASE) \\\n x(avx128_iadd , \"128-bit integer serial adds\" , AVX2 ) \\\n x(avx256_iadd , \"256-bit integer serial adds\" , AVX2 ) \\\n x(avx512_iadd , \"512-bit integer serial adds\" , AVX512F) \\\n \\\n x(avx128_iadd16 , \"128-bit integer serial adds zmm16\", AVX512VL) \\\n x(avx256_iadd16 , \"256-bit integer serial adds zmm16\", AVX512VL) \\\n x(avx512_iadd16 , \"512-bit integer serial adds zmm16\", AVX512F) \\\n \\\n /* iadd throughput */ \\\n x(avx128_iadd_t , \"128-bit integer parallel adds\" , AVX2 ) \\\n x(avx256_iadd_t , \"256-bit integer parallel adds\" , AVX2 ) \\\n \\\n /* zeroing xor */ \\\n x(avx128_xor_zero , \"128-bit zeroing xor\" , AVX2 ) \\\n x(avx256_xor_zero , \"256-bit zeroing xor\" , AVX2 ) \\\n x(avx512_xor_zero , \"512-bit zeroing xord\" , AVX512F) \\\n \\\n /* reg-reg mov */ \\\n x(avx128_mov_sparse , \"128-bit reg-reg mov\" , AVX2) \\\n x(avx256_mov_sparse , \"256-bit reg-reg mov\" , AVX2 ) \\\n x(avx512_mov_sparse , \"512-bit reg-reg mov\" , AVX512F) \\\n \\\n /* merge */ \\\n x(avx128_merge_sparse , \"128-bit reg-reg merge mov\" , AVX512VL) \\\n x(avx256_merge_sparse , \"256-bit reg-reg merge mov\" , AVX512VL) \\\n x(avx512_merge_sparse , \"512-bit reg-reg merge mov\" , AVX512F) \\\n \\\n /* variable shift latency */ \\\n x(avx128_vshift , \"128-bit variable shift (vpsrlvd)\", AVX2 ) \\\n x(avx256_vshift , \"256-bit variable shift (vpsrlvd)\", AVX2 ) \\\n x(avx512_vshift , \"512-bit variable shift (vpsrlvd)\", AVX512F) \\\n /* variable shift throughput */ \\\n x(avx128_vshift_t , \"128-bit variable shift (vpsrlvd)\", AVX2 ) \\\n x(avx256_vshift_t , \"256-bit variable shift (vpsrlvd)\", AVX2 ) \\\n x(avx512_vshift_t , \"512-bit variable shift (vpsrlvd)\", AVX512F) \\\n \\\n /* vplzcntd latency */ \\\n x(avx128_vlzcnt , \"128-bit lzcnt (vplzcntd)\", AVX512CD | AVX512VL) \\\n x(avx256_vlzcnt , \"256-bit lzcnt (vplzcntd)\", AVX512CD | AVX512VL) \\\n x(avx512_vlzcnt , \"512-bit lzcnt (vplzcntd)\", AVX512CD) \\\n /* vplzcntd throughput */ \\\n x(avx128_vlzcnt_t , \"128-bit lzcnt (vplzcntd)\", AVX512CD | AVX512VL) \\\n x(avx256_vlzcnt_t , \"256-bit lzcnt (vplzcntd)\", AVX512CD | AVX512VL) \\\n x(avx512_vlzcnt_t , \"512-bit lzcnt (vplzcntd)\", AVX512CD) \\\n \\\n x(avx128_imul , \"128-bit integer muls (vpmuldq)\" , AVX2 ) \\\n x(avx256_imul , \"256-bit integer muls (vpmuldq)\" , AVX2 ) \\\n x(avx512_imul , \"512-bit integer muls (vpmuldq)\" , AVX512F) \\\n \\\n /* fma */ \\\n x(avx128_fma_sparse , \"128-bit 64-bit sparse FMAs\" , AVX2 ) \\\n x(avx256_fma_sparse , \"256-bit 64-bit sparse FMAs\" , AVX2 ) \\\n x(avx512_fma_sparse , \"512-bit 64-bit sparse FMAs\" , AVX512F) \\\n x(avx128_fma , \"128-bit serial DP FMAs\" , AVX2 ) \\\n x(avx256_fma , \"256-bit serial DP FMAs\" , AVX2 ) \\\n x(avx512_fma , \"512-bit serial DP FMAs\" , AVX512F) \\\n x(avx128_fma_t , \"128-bit parallel DP FMAs\" , AVX2 ) \\\n x(avx256_fma_t , \"256-bit parallel DP FMAs\" , AVX2 ) \\\n x(avx512_fma_t , \"512-bit parallel DP FMAs\" , AVX512F) \\\n \\\n x(avx512_vpermw , \"512-bit serial WORD permute\" , AVX512BW) \\\n x(avx512_vpermw_t , \"512-bit parallel WORD permute\" , AVX512BW) \\\n x(avx512_vpermd , \"512-bit serial DWORD permute\" , AVX512F) \\\n x(avx512_vpermd_t , \"512-bit parallel DWORD permute\" , AVX512F) \\\n\n\n#define DECLARE(f,...) cal_f f;\n\nextern \"C\" {\n// functions declared in asm-methods.asm\nFUNCS_X(DECLARE);\n\n\n// misc helpers\nvoid zeroupper_asm();\n\nstatic bool zeroupper_allowed;\n\nvoid zeroupper() {\n if (zeroupper_allowed) zeroupper_asm();\n}\n\n}\n\n#define MAKE_STRUCT(f, d, i) { f, #f, d, (ISA)(i) },\nconst test_func ALL_FUNCS[] = {\nFUNCS_X(MAKE_STRUCT)\n};\n\nvoid pin_to_cpu(int cpu) {\n cpu_set_t cpuset;\n CPU_ZERO(&cpuset);\n CPU_SET(cpu, &cpuset);\n if (sched_setaffinity(0, sizeof(cpuset), &cpuset) == -1) {\n error(EXIT_FAILURE, errno, \"could not pin to CPU %d\", cpu);\n }\n}\n\n/** args */\nargs::ArgumentParser parser{\"avx-turbo: Determine AVX2 and AVX-512 downclocking behavior\"};\nargs::HelpFlag help{parser, \"help\", \"Display this help menu\", {'h', \"help\"}};\nargs::Flag arg_force_tsc_cal{parser, \"force-tsc-calibrate\",\n \"Force manual TSC calibration loop, even if cpuid TSC Hz is available\", {\"force-tsc-calibrate\"}};\nargs::Flag arg_no_pin{parser, \"no-pin\",\n \"Don't try to pin threads to CPU - gives worse results but works around affinity issues on TravisCI\", {\"no-pin\"}};\nargs::Flag arg_verbose{parser, \"verbose\", \"Output more info\", {\"verbose\"}};\nargs::Flag arg_nobarrier{parser, \"no-barrier\", \"Don't sync up threads before each test (debugging only)\", {\"no-barrier\"}};\nargs::Flag arg_list{parser, \"list\", \"List the available tests and their descriptions\", {\"list\"}};\nargs::Flag arg_hyperthreads{parser, \"allow-hyperthreads\", \"By default we try to filter down the available cpus to include only physical cores, but \"\n \"with this option we'll use all logical cores meaning you'll run two tests on cores with hyperthreading\", {\"allow-hyperthreads\"}};\nargs::Flag arg_dirty{parser, \"dirty-upper\", \"AVX-512 only: the 512-bit zmm15 register is dirtied befor each test\",\n {\"dirty-upper\"}};\nargs::Flag arg_dirty16{parser, \"dirty-upper\", \"AVX-512 only: the 512-bit zmm16 register is dirtied befor each test\",\n {\"dirty-upper16\"}};\nargs::ValueFlag arg_focus{parser, \"TEST-ID\", \"Run only the specified test (by ID)\", {\"test\"}};\nargs::ValueFlag arg_spec{parser, \"SPEC\", \"Run a specific type of test specified by a specification string\", {\"spec\"}};\nargs::ValueFlag arg_iters{parser, \"ITERS\", \"Run the test loop ITERS times (default 100000)\", {\"iters\"}, 100000};\nargs::ValueFlag arg_min_threads{parser, \"MIN\", \"The minimum number of threads to use\", {\"min-threads\"}, 1};\nargs::ValueFlag arg_max_threads{parser, \"MAX\", \"The maximum number of threads to use\", {\"max-threads\"}};\nargs::ValueFlag arg_num_cpus{parser, \"CPUS\", \"Override number of available CPUs\", {\"num-cpus\"}};\nargs::ValueFlag arg_warm_ms{parser, \"MILLISECONDS\", \"Warmup milliseconds for each thread after pinning (default 100)\", {\"warmup-ms\"}, 100};\n\n\nbool verbose;\n\ntemplate \nstruct StdClock {\n using now_t = decltype(CHRONO_CLOCK::now());\n using delta_t = typename CHRONO_CLOCK::duration;\n\n static now_t now() {\n return CHRONO_CLOCK::now();\n }\n\n /* accept the result of subtraction of durations and convert to nanos */\n static uint64_t to_nanos(typename CHRONO_CLOCK::duration d) {\n return duration_cast(d).count();\n }\n};\n\nstruct RdtscClock {\n using now_t = uint64_t;\n using delta_t = uint64_t;\n\n static now_t now() {\n _mm_lfence();\n now_t ret = rdtsc();\n _mm_lfence();\n return ret;\n }\n\n /* accept the result of subtraction of durations and convert to nanos */\n static uint64_t to_nanos(now_t diff) {\n static double tsc_to_nanos = 1000000000.0 / tsc_freq();\n return diff * tsc_to_nanos;\n }\n\n static uint64_t tsc_freq() {\n static uint64_t freq = get_tsc_freq(arg_force_tsc_cal);\n return freq;\n }\n\n};\n\n/**\n * We pass an outer_clock to run_test which times outside the iteration of the innermost loop (i.e.,\n * it times around the loop that runs TRIES times), start should reset the state unless you want to\n * time warmup iterations.\n */\nstruct outer_timer {\n virtual void start() = 0;\n virtual void stop() = 0;\n virtual ~outer_timer() {}\n};\n\nstruct dummy_outer : outer_timer {\n static dummy_outer dummy;\n virtual void start() override {};\n virtual void stop() override {};\n};\ndummy_outer dummy_outer::dummy{};\n\n/** lets you determine the actual frequency over any interval using the free-running APERF and MPERF counters */\nstruct aperf_ghz : outer_timer {\n uint64_t mperf_value, aperf_value, tsc_value;\n enum {\n STARTED, STOPPED\n } state;\n\n aperf_ghz() : mperf_value(0), aperf_value(0), tsc_value(0), state(STOPPED) {}\n\n static uint64_t mperf() {\n return read(MSR_IA32_MPERF);\n }\n\n static uint64_t aperf() {\n return read(MSR_IA32_APERF);\n }\n\n static uint64_t read(uint32_t msr) {\n uint64_t value = -1;\n int res = read_msr_cur_cpu(msr, &value);\n assert(res == 0);\n return value;\n }\n\n /**\n * Return true iff APERF and MPERF MSR reads appear to work\n */\n static bool is_supported() {\n uint64_t dummy;\n return read_msr_cur_cpu(MSR_IA32_MPERF, &dummy) == 0\n && read_msr_cur_cpu(MSR_IA32_APERF, &dummy) == 0;\n }\n\n virtual void start() override {\n assert(state == STOPPED);\n state = STARTED;\n mperf_value = mperf();\n aperf_value = aperf();\n tsc_value = rdtsc();\n// printf(\"started timer m: %lu\\n\", mperf_value);\n// printf(\"started timer a: %lu\\n\", aperf_value);\n };\n\n virtual void stop() override {\n assert(state == STARTED);\n mperf_value = mperf() - mperf_value;\n aperf_value = aperf() - aperf_value;\n tsc_value = rdtsc() - tsc_value;\n state = STOPPED;\n// printf(\"stopped timer m: %lu (delta)\\n\", mperf_value);\n// printf(\"stopped timer a: %lu (delta)\\n\", aperf_value);\n };\n\n /** aperf / mperf ratio */\n double am_ratio() {\n assert(state == STOPPED);\n assert(mperf_value != 0 && aperf_value != 0);\n// printf(\"timer ratio m: %lu (delta)\\n\", mperf_value);\n// printf(\"timer ratio a: %lu (delta)\\n\", aperf_value);\n return (double)aperf_value / mperf_value;\n }\n\n /** mperf / tsc ratio, i.e., the % of the time the core was unhalted */\n double mt_ratio() {\n assert(state == STOPPED);\n assert(mperf_value != 0 && tsc_value != 0);\n// printf(\"timer ratio m: %lu (delta)\\n\", mperf_value);\n// printf(\"timer ratio a: %lu (delta)\\n\", aperf_value);\n return (double)mperf_value / tsc_value;\n }\n\n\n};\n\n/*\n * The result of the run_test method, with only the stuff\n * that can be calculated from within that method.\n */\nstruct inner_result {\n /* calculated Mops value */\n double mops;\n uint64_t ostart_ts, oend_ts;\n uint64_t istart_ts, iend_ts; // start and end timestamps for the \"critical\" benchmark portion\n};\n\n/*\n * Calculate the frequency of the CPU based on timing a tight loop that we expect to\n * take one iteration per cycle.\n *\n * ITERS is the base number of iterations to use: the calibration routine is actually\n * run twice, once with ITERS iterations and once with 2*ITERS, and a delta is used to\n * remove measurement overhead.\n */\nstruct hot_barrier {\n size_t break_count;\n std::atomic current;\n hot_barrier(size_t count) : break_count(count), current{0} {}\n\n /* increment the arrived count of the barrier (do this once per thread generally) */\n void increment() {\n current++;\n }\n\n /* return true if all the threads have arrived, never blocks */\n bool is_broken() {\n return current.load() == break_count;\n }\n\n /* increment and hot spin on the waiter count until it hits the break point, returns the spin count in case you care */\n long wait() {\n increment();\n long count = 0;\n while (!is_broken()) {\n count++;\n }\n return count;\n }\n};\n\n// dirties zmm15 upper bits\nextern \"C\" void dirty_it();\n// dirties zmm15 upper bits\nextern \"C\" void dirty_it16();\n\ntemplate \ninner_result run_test(cal_f* func, size_t iters, outer_timer& outer, hot_barrier *barrier) {\n assert(iters % 100 == 0);\n\n std::array results;\n\n inner_result result;\n\n if (arg_dirty) {\n dirty_it();\n }\n\n if (arg_dirty16) {\n dirty_it16();\n }\n\n result.ostart_ts = RdtscClock::now();\n for (size_t w = 0; w < WARMUP + 1; w++) {\n result.istart_ts = RdtscClock::now();\n outer.start();\n for (size_t r = 0; r < TRIES; r++) {\n auto t0 = CLOCK::now();\n func(iters);\n auto t1 = CLOCK::now();\n func(iters * 2);\n auto t2 = CLOCK::now();\n results[r] = (t2 - t1) - (t1 - t0);\n }\n outer.stop();\n result.iend_ts = RdtscClock::now();\n }\n\n for (barrier->increment(); !barrier->is_broken();) {\n func(iters);\n }\n result.oend_ts = RdtscClock::now();\n\n std::array nanos = {};\n std::transform(results.begin(), results.end(), nanos.begin(), CLOCK::to_nanos);\n DescriptiveStats stats = get_stats(nanos.begin(), nanos.end());\n\n result.mops = ((double)iters / stats.getMedian());\n return result;\n}\n\nISA get_isas() {\n int ret = BASE;\n ret |= psnip_cpu_feature_check(PSNIP_CPU_FEATURE_X86_AVX2 ) ? AVX2 : 0;\n ret |= psnip_cpu_feature_check(PSNIP_CPU_FEATURE_X86_AVX512F ) ? AVX512F : 0;\n ret |= psnip_cpu_feature_check(PSNIP_CPU_FEATURE_X86_AVX512VL) ? AVX512VL : 0;\n ret |= psnip_cpu_feature_check(PSNIP_CPU_FEATURE_X86_AVX512CD) ? AVX512CD : 0;\n ret |= psnip_cpu_feature_check(PSNIP_CPU_FEATURE_X86_AVX512BW) ? AVX512BW : 0;\n return (ISA)ret;\n}\n\nbool should_run(const test_func& t, ISA isas_supported) {\n return (t.isa & isas_supported) == t.isa;\n}\n\n/*\n * A test_spec contains the information needed to run one test. It is composed of\n * a list of test_funcs, which should be run in parallel on separate threads.\n */\nstruct test_spec {\n std::string name;\n std::string description;\n std::vector thread_funcs;\n\n test_spec(std::string name, std::string description) : name{name}, description{description} {}\n\n /** how many threads/funcs in this test */\n size_t count() const { return thread_funcs.size(); }\n\n std::string to_string() const {\n std::string ret;\n for (auto& t : thread_funcs) {\n ret += t.id;\n ret += ',';\n }\n return ret;\n }\n};\n\n\n/* find the test that exactly matches the given ID or return nullptr if not found */\nconst test_func *find_one_test(const std::string& id) {\n for (const auto& t : ALL_FUNCS) {\n if (id == t.id) {\n return &t;\n }\n }\n return nullptr;\n}\n\n/**\n * If the user didn't specify any particular test spec, just create for every thread count\n * value T and runnable func, a spec with T copies of func.\n */\nstd::vector make_default_tests(ISA isas_supported, std::vector cpus) {\n std::vector ret;\n\n size_t maxcpus;\n if (arg_max_threads) {\n auto max = arg_max_threads.Get();\n if (max > (int)cpus.size()) {\n printf(\"WARNING: can't run the requested number of threads (%d) because there are only %d available logical CPUs.\\n\",\n max, (int)cpus.size());\n maxcpus = (int)cpus.size();\n } else {\n maxcpus = max;\n }\n } else {\n maxcpus = cpus.size();\n }\n\n printf(\"Will test up to %lu CPUs\\n\", maxcpus);\n\n auto try_add = [&ret](const test_func& t, size_t thread_count) {\n test_spec spec(t.id, t.description);\n spec.thread_funcs.resize(thread_count, t); // fill with thread_count copies of t\n ret.push_back(std::move(spec));\n };\n\n std::vector funcs; // the selected test functions\n if (arg_focus) {\n for (auto& focus : split(arg_focus.Get(), \",\")) {\n auto t = find_one_test(focus);\n if (!t) {\n printf(\"WARNING: Can't find specified test: %s\\n\", focus.c_str());\n } else {\n funcs.push_back(*t);\n }\n }\n } else {\n funcs.insert(funcs.begin(), std::begin(ALL_FUNCS), std::end(ALL_FUNCS));\n }\n\n for (size_t thread_count = arg_min_threads.Get(); thread_count <= maxcpus; thread_count++) {\n for (const auto& t : funcs) {\n if (should_run(t, isas_supported)) {\n try_add(t, thread_count);\n }\n }\n }\n\n return ret;\n}\n\n\nstd::vector make_from_spec(ISA, std::vector cpus) {\n std::string str = arg_spec.Get();\n if (verbose) printf(\"Making tests from spec string: %s\\n\", str.c_str());\n\n test_spec spec{str, \"\"};\n for (auto& elem : split(str,\",\")) {\n if (verbose) printf(\"Elem: %s\\n\", elem.c_str());\n std::vector halves = split(elem,\"/\");\n assert(halves.size() > 0);\n if (halves.size() > 2) {\n throw std::runtime_error(std::string(\"bad spec syntax in element: '\" + elem + \"'\"));\n }\n int count = (halves.size() == 1 ? 1 : std::atoi(halves[1].c_str()));\n const test_func* test = find_one_test(halves[0]);\n if (!test) {\n throw std::runtime_error(\"couldn't find test: '\" + halves[0] + \"'\");\n }\n\n spec.thread_funcs.insert(spec.thread_funcs.end(), count, *test);\n }\n\n if (spec.count() > cpus.size()) {\n printf(\"ERROR: this spec requires %d CPUs but only %d are available.\\n\", (int)spec.count(), (int)cpus.size());\n exit(EXIT_FAILURE);\n }\n\n return {spec};\n}\n\nstd::vector filter_tests(ISA isas_supported, std::vector cpus) {\n if (!arg_spec) {\n return make_default_tests(isas_supported, cpus);\n } else {\n return make_from_spec(isas_supported, cpus);\n }\n}\n\nstruct result {\n static constexpr double nan = std::numeric_limits::quiet_NaN();\n inner_result inner;\n\n uint64_t start_ts; // start timestamp\n uint64_t end_ts; // end timestamp\n\n /* optional stuff associated with outer_timer */\n double aperf_am = nan;\n double aperf_mt = nan;\n};\n\nstruct result_holder {\n const test_spec* spec;\n std::vector results; // will have spec.count() elements\n\n result_holder(const test_spec* spec) : spec(spec) {}\n\n /** calculate the overlap ratio based on the start/end timestamps */\n double get_overlap1() const {\n std::vector> ranges = transformv(results, [](const result& r){ return std::make_pair(r.start_ts, r.end_ts);} );\n return conc_ratio(ranges.begin(), ranges.end());\n }\n\n /** calculate the overlap ratio based on the start/end timestamps */\n double get_overlap2() const {\n std::vector> ranges = transformv(results, [](const result& r){ return std::make_pair(r.inner.istart_ts, r.inner.iend_ts);} );\n return conc_ratio(ranges.begin(), ranges.end());\n }\n\n /** calculate the inner overlap ratio based on the start/end timestamps */\n double get_overlap3() const {\n auto orange = transformv(results, [](const result& r){ return std::make_pair(r.inner.ostart_ts, r.inner.oend_ts);} );\n auto irange = transformv(results, [](const result& r){ return std::make_pair(r.inner.istart_ts, r.inner.iend_ts);} );\n return nconc_ratio(orange.begin(), orange.end(), irange.begin(), irange.end());\n }\n};\n\nstruct warmup {\n uint64_t millis;\n warmup(uint64_t millis) : millis{millis} {}\n\n long warm() {\n int64_t start = (int64_t)RdtscClock::now();\n long iters = 0;\n while (RdtscClock::to_nanos(RdtscClock::now() - start) < 1000000u * millis) {\n iters++;\n }\n return iters;\n }\n};\n\nstruct test_thread {\n size_t id;\n hot_barrier* start_barrier;\n hot_barrier* stop_barrier;\n\n /* output */\n result res;\n\n /* input */\n const test_func* test;\n size_t iters;\n bool use_aperf;\n\n std::thread thread;\n\n test_thread(size_t id, hot_barrier& start_barrier, hot_barrier& stop_barrier, const test_func *test, size_t iters, bool use_aperf) :\n id{id}, start_barrier{&start_barrier}, stop_barrier{&stop_barrier}, test{test},\n iters{iters}, use_aperf{use_aperf}, thread{std::ref(*this)}\n {\n // if (verbose) printf(\"Constructed test in thread %lu, this = %p\\n\", id, this);\n }\n\n test_thread(const test_thread&) = delete;\n test_thread(test_thread&&) = delete;\n void operator=(const test_thread&) = delete;\n\n void operator()() {\n // if (verbose) printf(\"Running test in thread %lu, this = %p\\n\", id, this);\n if (!arg_no_pin) {\n pin_to_cpu(id);\n }\n aperf_ghz aperf_timer;\n outer_timer& outer = use_aperf ? static_cast(aperf_timer) : dummy_outer::dummy;\n warmup w{arg_warm_ms.Get()};\n long warms = w.warm();\n if (verbose) printf(\"[%2lu] Warmup iters %lu\\n\", id, warms);\n if (!arg_nobarrier) {\n long count = start_barrier->wait();\n if (verbose) printf(\"[%2lu] Thread loop count: %ld\\n\", id, count);\n }\n res.start_ts = RdtscClock::now();\n res.inner = run_test(test->func, iters, outer, stop_barrier);\n res.end_ts = RdtscClock::now();\n res.aperf_am = use_aperf ? aperf_timer.am_ratio() : 0.0;\n res.aperf_mt = use_aperf ? aperf_timer.mt_ratio() : 0.0;\n }\n};\n\ntemplate \nstd::string result_string(const std::vector& results, const char* format, E e) {\n std::string s;\n for (const auto& result : results) {\n if (!s.empty()) s += \", \";\n s += table::string_format(format, e(result));\n }\n return s;\n}\n\nvoid report_results(const std::vector& results_list, bool use_aperf) {\n // report\n table::Table table;\n table.setColColumnSeparator(\" | \");\n\n auto& header = table.newRow();\n\n using table::ColInfo;\n\n auto adder = [&header, &table](const char* s, ColInfo::Justification just = ColInfo::LEFT) {\n header.add(s);\n table.colInfo(header.size() - 1).justify = just;\n };\n\n adder(\"Cores\");\n adder(\"ID\");\n adder(\"Description\");\n // adder(\"OVRLP1\", ColInfo::RIGHT);\n // adder(\"OVRLP2\", ColInfo::RIGHT);\n adder(\"OVRLP3\", ColInfo::RIGHT);\n adder(\"Mops\", ColInfo::RIGHT);\n\n if (use_aperf) {\n adder(\"A/M-ratio\", ColInfo::RIGHT);\n adder(\"A/M-MHz\", ColInfo::RIGHT);\n adder(\"M/tsc-ratio\", ColInfo::RIGHT);\n }\n\n for (const result_holder& holder : results_list) {\n auto spec = holder.spec;\n auto &row = table.newRow()\n .add(spec->count())\n .add(spec->name)\n .add(spec->description)\n // .addf(\"%5.3f\", holder.get_overlap1())\n // .addf(\"%5.3f\", holder.get_overlap2())\n .addf(\"%5.3f\", holder.get_overlap3());\n\n auto& results = holder.results;\n row.add(result_string(results, \"%5.0f\", [](const result& r){ return r.inner.mops * 1000; }));\n if (use_aperf) {\n row.add(result_string(results, \"%4.2f\", [](const result& r){ return r.aperf_am; }));\n row.add(result_string(results, \"%.0f\", [](const result& r){ return r.aperf_am / 1000000.0 * RdtscClock::tsc_freq(); }));\n row.add(result_string(results, \"%4.2f\", [](const result& r){ return r.aperf_mt; }));\n }\n }\n\n printf(\"%s\\n\", table.str().c_str());\n}\n\nvoid list_tests() {\n table::Table table;\n table.newRow().add(\"ID\").add(\"Description\");\n for (auto& t : ALL_FUNCS) {\n table.newRow().add(t.id).add(t.description);\n }\n printf(\"Available tests:\\n\\n%s\\n\", table.str().c_str());\n}\n\nstd::vector get_cpus() {\n if (arg_num_cpus) {\n auto cpu_num = arg_num_cpus.Get();\n std::vector ret;\n for (int cpu = 0; cpu < cpu_num; ++cpu) {\n ret.push_back(cpu);\n }\n return ret;\n }\n cpu_set_t cpu_set;\n if (sched_getaffinity(0, sizeof(cpu_set), &cpu_set)) {\n err(EXIT_FAILURE, \"failed while getting cpu affinity\");\n }\n std::vector ret;\n for (int cpu = 0; cpu < CPU_SETSIZE; cpu++) {\n if (CPU_ISSET(cpu, &cpu_set)) {\n ret.push_back(cpu);\n }\n }\n return ret;\n}\n\n/* try to filter the CPU list to return only physical CPUs */\nstd::vector filter_cpus(std::vector cpus) {\n int shift = get_smt_shift();\n if (shift == -1) {\n printf(\"Can't use cpuid leaf 0xb to filter out hyperthreads, CPU too old or AMD\\n\");\n return cpus;\n }\n cpu_set_t original_set;\n if (sched_getaffinity(0, sizeof(original_set), &original_set)) {\n err(EXIT_FAILURE, \"failed while getting cpu affinity\");\n }\n std::vector filtered_cpus;\n std::set coreid_set;\n for (int cpu : cpus) {\n cpu_set_t cpuset;\n CPU_ZERO(&cpuset);\n CPU_SET(cpu, &cpuset);\n if (sched_setaffinity(0, sizeof(cpu_set_t), &cpuset)) {\n err(EXIT_FAILURE, \"failed to sched_setaffinity in filter_cpus\");\n }\n cpuid_result leafb = cpuid(0xb);\n uint32_t apicid = leafb.edx, coreid = apicid >> shift;\n if (verbose) printf(\"cpu %d has x2apic ID %u, coreid %u\\n\", cpu, apicid, coreid);\n if (coreid_set.insert(coreid).second) {\n filtered_cpus.push_back(cpu);\n }\n }\n // restore original affinity\n sched_setaffinity(0, sizeof(cpu_set_t), &original_set);\n return filtered_cpus;\n}\n\nint main(int argc, char** argv) {\n\n try {\n parser.ParseCLI(argc, argv);\n if (arg_iters.Get() % 100 != 0) {\n printf(\"ITERS must be a multiple of 100\\n\");\n exit(EXIT_FAILURE);\n }\n } catch (args::Help& help) {\n printf(\"%s\\n\", parser.Help().c_str());\n exit(EXIT_SUCCESS);\n } catch (const args::ParseError& e) {\n printf(\"ERROR while parsing arguments: %s\\n\", e.what());\n printf(\"\\nUsage:\\n%s\\n\", parser.Help().c_str());\n exit(EXIT_FAILURE);\n }\n\n if (arg_list) {\n list_tests();\n exit(EXIT_SUCCESS);\n }\n\n verbose = arg_verbose;\n bool is_root = (geteuid() == 0);\n bool use_aperf = aperf_ghz::is_supported();\n printf(\"CPUID highest leaf : [%2xh]\\n\", cpuid_highest_leaf());\n printf(\"Running as root : [%s]\\n\", is_root ? \"YES\" : \"NO \");\n printf(\"MSR reads supported : [%s]\\n\", use_aperf ? \"YES\" : \"NO \");\n printf(\"CPU pinning enabled : [%s]\\n\", !arg_no_pin ? \"YES\" : \"NO \");\n\n ISA isas_supported = get_isas();\n zeroupper_allowed = isas_supported & AVX2;\n printf(\"CPU supports zeroupper: [%s]\\n\", zeroupper_allowed ? \"YES\" : \"NO \");\n printf(\"CPU supports AVX2 : [%s]\\n\", isas_supported & AVX2 ? \"YES\" : \"NO \");\n printf(\"CPU supports AVX-512F : [%s]\\n\", isas_supported & AVX512F ? \"YES\" : \"NO \");\n printf(\"CPU supports AVX-512VL: [%s]\\n\", isas_supported & AVX512VL ? \"YES\" : \"NO \");\n printf(\"CPU supports AVX-512BW: [%s]\\n\", isas_supported & AVX512BW ? \"YES\" : \"NO \");\n printf(\"CPU supports AVX-512CD: [%s]\\n\", isas_supported & AVX512CD ? \"YES\" : \"NO \");\n printf(\"tsc_freq = %.1f MHz (%s)\\n\", RdtscClock::tsc_freq() / 1000000.0, get_tsc_cal_info(arg_force_tsc_cal));\n std::vector cpus = get_cpus();\n printf(\"CPU brand string: %s\\n\", get_brand_string().c_str());\n printf(\"%lu available CPUs: [%s]\\n\", cpus.size(), join(cpus, \", \").c_str());\n if (!arg_hyperthreads) {\n cpus = filter_cpus(cpus);\n printf(\"%lu physical cores: [%s]\\n\", cpus.size(), join(cpus, \", \").c_str());\n }\n\n if (arg_dirty && !(isas_supported & AVX512VL)) {\n printf(\"ERROR: --dirty-upper only supported on AVX-512 hardware\\n\");\n exit(EXIT_FAILURE);\n }\n\n auto iters = arg_iters.Get();\n zeroupper();\n auto specs = filter_tests(isas_supported, cpus);\n\n size_t last_thread_count = -1u;\n std::vector results_list;\n for (auto& spec : specs) {\n // if we changed the number of threads, spit out the accumulated output\n if (last_thread_count != -1u && last_thread_count != spec.count()) {\n // time to print results\n report_results(results_list, use_aperf);\n results_list.clear();\n }\n last_thread_count = spec.count();\n\n assert(!spec.thread_funcs.empty());\n if (verbose) printf(\"Running test spec: %s\\n\", spec.to_string().c_str());\n\n // run\n std::deque threads;\n hot_barrier start{spec.count()}, stop{spec.count()};\n for (auto& test : spec.thread_funcs) {\n threads.emplace_back(threads.size(), start, stop, &test, iters, use_aperf);\n }\n\n results_list.emplace_back(&spec);\n for (auto& t : threads) {\n t.thread.join();\n results_list.back().results.push_back(t.res);\n }\n }\n\n report_results(results_list, use_aperf);\n\n return EXIT_SUCCESS;\n}\n\n\n\n\n" }, { "path": "check-uarch.sh", "content": "#!/bin/bash\nset -e\n\n# runs Intel SDE to check that ./avx-turbo works for every arch\nall_arch=( \\\n p4p \\\n mrm \\\n pnr \\\n nhm \\\n wsm \\\n snb \\\n ivb \\\n hsw \\\n bdw \\\n slt \\\n slm \\\n glm \\\n tnt \\\n skl \\\n clx \\\n skx \\\n cnl \\\n icl \\\n icx \\\n knl \\\n knm \\\n future \\\n)\n\nfor arch in \"${all_arch[@]}\"; do\n echo \"Testing arch=$arch with SDE\"\n sde64 -${arch} -- ./avx-turbo --max-threads=1\ndone" }, { "path": "config.mk", "content": "-include local.mk\n\n# set DEBUG to 1 to enable various debugging checks\nDEBUG ?= 0\n\n# The assembler to use. Defaults to nasm, but can also be set to yasm which has better\n# debug info handling.\nASM ?= ./nasm-2.13.03/nasm\n\nifeq ($(DEBUG),1)\nO_LEVEL ?= -O0\nNASM_DEBUG ?= 1\nelse\nO_LEVEL ?= -O2\nNASM_DEBUG ?= 0\nendif\n" }, { "path": "cpu.c", "content": "/* CPU Information (v1)\n * Portable Snippets - https://gitub.com/nemequ/portable-snippets\n * Created by Evan Nemerson \n *\n * To the extent possible under law, the authors have waived all\n * copyright and related or neighboring rights to this code. For\n * details, see the Creative Commons Zero 1.0 Universal license at\n * https://creativecommons.org/publicdomain/zero/1.0/\n */\n\n#include \"cpu.h\"\n\n#include \"once.h\"\n\n#include \n\n#if defined(_WIN32)\n# include \n# define PSNIP_CPU__IMPL_WIN32\n#elif defined(unix) || defined(__unix__) || defined(__unix)\n# include \n# if defined(_SC_NPROCESSORS_ONLN) || defined(_SC_NPROC_ONLN)\n# define PSNIP_CPU__IMPL_SYSCONF\n# else\n# include \n# endif\n#endif\n\n#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64)\n# if defined(_MSC_VER)\nstatic void psnip_cpu_getid(int func, int* data) {\n __cpuid(data, func);\n}\n# else\nstatic void psnip_cpu_getid(int func, int* data) {\n __asm__ (\"cpuid\"\n\t : \"=a\" (data[0]), \"=b\" (data[1]), \"=c\" (data[2]), \"=d\" (data[3])\n\t : \"0\" (func), \"2\" (0));\n}\n# endif\n#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM64)\n# if (defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 16)))\n# define PSNIP_CPU__IMPL_GETAUXVAL\n# include \n# endif\n#endif\n\nstatic psnip_once psnip_cpu_once = PSNIP_ONCE_INIT;\n\n#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64)\nstatic unsigned int psnip_cpuinfo[8 * 4] = { 0, };\n#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64)\nstatic unsigned long psnip_cpuinfo[2] = { 0, };\n#endif\n\nstatic void psnip_cpu_init(void) {\n#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64)\n int i;\n for (i = 0 ; i < 8 ; i++) {\n psnip_cpu_getid(i, (int*) &(psnip_cpuinfo[i * 4]));\n }\n#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64)\n psnip_cpuinfo[0] = getauxval (AT_HWCAP);\n psnip_cpuinfo[1] = getauxval (AT_HWCAP2);\n#endif\n}\n\nint\npsnip_cpu_feature_check (enum PSnipCPUFeature feature) {\n#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64)\n unsigned int i, r, b;\n#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64)\n unsigned long b, i;\n#endif\n\n#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64)\n if ((feature & PSNIP_CPU_FEATURE_CPU_MASK) != PSNIP_CPU_FEATURE_X86)\n return 0;\n#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64)\n if ((feature & PSNIP_CPU_FEATURE_CPU_MASK) != PSNIP_CPU_FEATURE_ARM)\n return 0;\n#else\n return 0;\n#endif\n\n feature &= (enum PSnipCPUFeature) ~PSNIP_CPU_FEATURE_CPU_MASK;\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warning(disable:4152)\n#endif\n psnip_once_call (&psnip_cpu_once, psnip_cpu_init);\n#if defined(_MSC_VER)\n#pragma warning(pop)\n#endif\n\n#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64)\n i = (feature >> 16) & 0xff;\n r = (feature >> 8) & 0xff;\n b = (feature ) & 0xff;\n\n if (i > 7 || r > 3 || b > 31)\n return 0;\n\n return (psnip_cpuinfo[(i * 4) + r] >> b) & 1;\n#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64)\n b = 1 << ((feature & 0xff) - 1);\n i = psnip_cpuinfo[(feature >> 0x08) & 0xff];\n return (psnip_cpuinfo[(feature >> 0x08) & 0xff] & b) == b;\n#endif\n}\n\nint\npsnip_cpu_feature_check_many (enum PSnipCPUFeature* feature) {\n int n;\n\n for (n = 0 ; feature[n] != PSNIP_CPU_FEATURE_NONE ; n++)\n if (!psnip_cpu_feature_check(feature[n]))\n return 0;\n\n return 1;\n}\n\nint\npsnip_cpu_count (void) {\n static int count = 0;\n int c;\n\n#if defined(_WIN32)\n DWORD_PTR lpProcessAffinityMask;\n DWORD_PTR lpSystemAffinityMask;\n int i;\n#elif defined(PSNIP_CPU__IMPL_SYSCONF) && defined(HW_NCPU)\n int mib[2];\n size_t len;\n#endif\n\n if (count != 0)\n return count;\n\n#if defined(_WIN32)\n if (!GetProcessAffinityMask(GetCurrentProcess(), &lpProcessAffinityMask, &lpSystemAffinityMask)) {\n c = -1;\n } else {\n c = 0;\n for (i = 0 ; lpProcessAffinityMask != 0 ; lpProcessAffinityMask >>= 1)\n c += lpProcessAffinityMask & 1;\n }\n#elif defined(_SC_NPROCESSORS_ONLN)\n c = sysconf (_SC_NPROCESSORS_ONLN);\n#elif defined(_SC_NPROC_ONLN)\n c = sysconf (_SC_NPROC_ONLN);\n#elif defined(_hpux)\n c = mpctl(MPC_GETNUMSPUS, NULL, NULL);\n#elif defined(HW_NCPU)\n c = 0;\n mib[0] = CTL_HW;\n mib[1] = HW_NCPU;\n len = sizeof(c);\n sysctl (mib, 2, &c, &len, NULL, 0);\n#endif\n\n count = (c > 0) ? c : -1;\n\n return count;\n}\n" }, { "path": "cpu.h", "content": "/* CPU Information (v1)\n * Portable Snippets - https://gitub.com/nemequ/portable-snippets\n * Created by Evan Nemerson \n *\n * To the extent possible under law, the authors have waived all\n * copyright and related or neighboring rights to this code. For\n * details, see the Creative Commons Zero 1.0 Universal license at\n * https://creativecommons.org/publicdomain/zero/1.0/\n */\n\n#if !defined(PSNIP_CPU__H)\n#define PSNIP_CPU__H\n\n#if defined(__x86_64__) || defined(_M_AMD64) || defined(_M_X64)\n# define PSNIP_CPU_ARCH_X86_64\n#elif defined(__i686__) || defined(__i586__) || defined(__i486__) || defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(_X86_) || defined(__THW_INTEL__)\n# define PSNIP_CPU_ARCH_X86\n#elif defined(__arm__) || defined(_M_ARM)\n# define PSNIP_CPU_ARCH_ARM\n#elif defined(__aarch64__)\n# define PSNIP_CPU_ARCH_ARM64\n#endif\n\n#if defined(__cplusplus)\nextern \"C\" {\n#endif\n\nenum PSnipCPUFeature {\n PSNIP_CPU_FEATURE_NONE = 0,\n\n PSNIP_CPU_FEATURE_CPU_MASK = 0x1f000000,\n PSNIP_CPU_FEATURE_X86 = 0x01000000,\n PSNIP_CPU_FEATURE_ARM = 0x04000000,\n\n /* x86 CPU features are constructed as:\n *\n * (PSNIP_CPU_FEATURE_X86 | (eax << 16) | (ret_reg << 8) | (bit_position)\n *\n * For example, SSE3 is determined by the fist bit in the ECX\n * register for a CPUID call with EAX=1, so we get:\n *\n * PSNIP_CPU_FEATURE_X86 | (1 << 16) | (2 << 8) | (0) = 0x01010200\n *\n * We should have information for inputs of EAX=0-7 w/ ECX=0.\n */\n PSNIP_CPU_FEATURE_X86_FPU = 0x01010300,\n PSNIP_CPU_FEATURE_X86_VME = 0x01010301,\n PSNIP_CPU_FEATURE_X86_DE = 0x01010302,\n PSNIP_CPU_FEATURE_X86_PSE = 0x01010303,\n PSNIP_CPU_FEATURE_X86_TSC = 0x01010304,\n PSNIP_CPU_FEATURE_X86_MSR = 0x01010305,\n PSNIP_CPU_FEATURE_X86_PAE = 0x01010306,\n PSNIP_CPU_FEATURE_X86_MCE = 0x01010307,\n PSNIP_CPU_FEATURE_X86_CX8 = 0x01010308,\n PSNIP_CPU_FEATURE_X86_APIC = 0x01010309,\n PSNIP_CPU_FEATURE_X86_SEP = 0x0101030b,\n PSNIP_CPU_FEATURE_X86_MTRR = 0x0101030c,\n PSNIP_CPU_FEATURE_X86_PGE = 0x0101030d,\n PSNIP_CPU_FEATURE_X86_MCA = 0x0101030e,\n PSNIP_CPU_FEATURE_X86_CMOV = 0x0101030f,\n PSNIP_CPU_FEATURE_X86_PAT = 0x01010310,\n PSNIP_CPU_FEATURE_X86_PSE_36 = 0x01010311,\n PSNIP_CPU_FEATURE_X86_PSN = 0x01010312,\n PSNIP_CPU_FEATURE_X86_CLFSH = 0x01010313,\n PSNIP_CPU_FEATURE_X86_DS = 0x01010314,\n PSNIP_CPU_FEATURE_X86_ACPI = 0x01010316,\n PSNIP_CPU_FEATURE_X86_MMX = 0x01010317,\n PSNIP_CPU_FEATURE_X86_FXSR = 0x01010318,\n PSNIP_CPU_FEATURE_X86_SSE = 0x01010319,\n PSNIP_CPU_FEATURE_X86_SSE2 = 0x0101031a,\n PSNIP_CPU_FEATURE_X86_SS = 0x0101031b,\n PSNIP_CPU_FEATURE_X86_HTT = 0x0101031c,\n PSNIP_CPU_FEATURE_X86_TM = 0x0101031d,\n PSNIP_CPU_FEATURE_X86_IA64 = 0x0101031e,\n PSNIP_CPU_FEATURE_X86_PBE = 0x0101031f,\n\n PSNIP_CPU_FEATURE_X86_SSE3 = 0x01010200,\n PSNIP_CPU_FEATURE_X86_PCLMULQDQ = 0x01010201,\n PSNIP_CPU_FEATURE_X86_DTES64 = 0x01010202,\n PSNIP_CPU_FEATURE_X86_MONITOR = 0x01010203,\n PSNIP_CPU_FEATURE_X86_DS_CPL = 0x01010204,\n PSNIP_CPU_FEATURE_X86_VMX = 0x01010205,\n PSNIP_CPU_FEATURE_X86_SMX = 0x01010206,\n PSNIP_CPU_FEATURE_X86_EST = 0x01010207,\n PSNIP_CPU_FEATURE_X86_TM2 = 0x01010208,\n PSNIP_CPU_FEATURE_X86_SSSE3 = 0x01010209,\n PSNIP_CPU_FEATURE_X86_CNXT_ID = 0x0101020a,\n PSNIP_CPU_FEATURE_X86_SDBG = 0x0101020b,\n PSNIP_CPU_FEATURE_X86_FMA = 0x0101020c,\n PSNIP_CPU_FEATURE_X86_CX16 = 0x0101020d,\n PSNIP_CPU_FEATURE_X86_XTPR = 0x0101020e,\n PSNIP_CPU_FEATURE_X86_PDCM = 0x0101020f,\n PSNIP_CPU_FEATURE_X86_PCID = 0x01010211,\n PSNIP_CPU_FEATURE_X86_DCA = 0x01010212,\n PSNIP_CPU_FEATURE_X86_SSE4_1 = 0x01010213,\n PSNIP_CPU_FEATURE_X86_SSE4_2 = 0x01010214,\n PSNIP_CPU_FEATURE_X86_X2APIC = 0x01010215,\n PSNIP_CPU_FEATURE_X86_MOVBE = 0x01010216,\n PSNIP_CPU_FEATURE_X86_POPCNT = 0x01010217,\n PSNIP_CPU_FEATURE_X86_TSC_DEADLINE = 0x01010218,\n PSNIP_CPU_FEATURE_X86_AES = 0x01010219,\n PSNIP_CPU_FEATURE_X86_XSAVE = 0x0101021a,\n PSNIP_CPU_FEATURE_X86_OSXSAVE = 0x0101021b,\n PSNIP_CPU_FEATURE_X86_AVX = 0x0101021c,\n PSNIP_CPU_FEATURE_X86_F16C = 0x0101021d,\n PSNIP_CPU_FEATURE_X86_RDRND = 0x0101021e,\n PSNIP_CPU_FEATURE_X86_HYPERVISOR = 0x0101021f,\n\n PSNIP_CPU_FEATURE_X86_FSGSBASE = 0x01070100,\n PSNIP_CPU_FEATURE_X86_TSC_ADJ = 0x01070101,\n PSNIP_CPU_FEATURE_X86_SGX = 0x01070102,\n PSNIP_CPU_FEATURE_X86_BMI1 = 0x01070103,\n PSNIP_CPU_FEATURE_X86_HLE = 0x01070104,\n PSNIP_CPU_FEATURE_X86_AVX2 = 0x01070105,\n PSNIP_CPU_FEATURE_X86_SMEP = 0x01070107,\n PSNIP_CPU_FEATURE_X86_BMI2 = 0x01070108,\n PSNIP_CPU_FEATURE_X86_ERMS = 0x01070109,\n PSNIP_CPU_FEATURE_X86_INVPCID = 0x0107010a,\n PSNIP_CPU_FEATURE_X86_RTM = 0x0107010b,\n PSNIP_CPU_FEATURE_X86_PQM = 0x0107010c,\n PSNIP_CPU_FEATURE_X86_MPX = 0x0107010e,\n PSNIP_CPU_FEATURE_X86_PQE = 0x0107010f,\n PSNIP_CPU_FEATURE_X86_AVX512F = 0x01070110,\n PSNIP_CPU_FEATURE_X86_AVX512DQ = 0x01070111,\n PSNIP_CPU_FEATURE_X86_RDSEED = 0x01070112,\n PSNIP_CPU_FEATURE_X86_ADX = 0x01070113,\n PSNIP_CPU_FEATURE_X86_SMAP = 0x01070114,\n PSNIP_CPU_FEATURE_X86_AVX512IFMA = 0x01070115,\n PSNIP_CPU_FEATURE_X86_PCOMMIT = 0x01070116,\n PSNIP_CPU_FEATURE_X86_CLFLUSHOPT = 0x01070117,\n PSNIP_CPU_FEATURE_X86_CLWB = 0x01070118,\n PSNIP_CPU_FEATURE_X86_INTEL_PT = 0x01070119,\n PSNIP_CPU_FEATURE_X86_AVX512PF = 0x0107011a,\n PSNIP_CPU_FEATURE_X86_AVX512ER = 0x0107011b,\n PSNIP_CPU_FEATURE_X86_AVX512CD = 0x0107011c,\n PSNIP_CPU_FEATURE_X86_SHA = 0x0107011d,\n PSNIP_CPU_FEATURE_X86_AVX512BW = 0x0107011e,\n PSNIP_CPU_FEATURE_X86_AVX512VL = 0x0107011f,\n\n PSNIP_CPU_FEATURE_X86_PREFETCHWT1 = 0x01070200,\n PSNIP_CPU_FEATURE_X86_AVX512VBMI = 0x01070201,\n PSNIP_CPU_FEATURE_X86_UMIP = 0x01070202,\n PSNIP_CPU_FEATURE_X86_PKU = 0x01070203,\n PSNIP_CPU_FEATURE_X86_OSPKE = 0x01070204,\n PSNIP_CPU_FEATURE_X86_AVX512VPOPCNTDQ = 0x0107020e,\n PSNIP_CPU_FEATURE_X86_RDPID = 0x01070215,\n PSNIP_CPU_FEATURE_X86_SGX_LC = 0x0107021e,\n\n PSNIP_CPU_FEATURE_X86_AVX512_4VNNIW = 0x01070302,\n PSNIP_CPU_FEATURE_X86_AVX512_4FMAPS = 0x01070303,\n\n PSNIP_CPU_FEATURE_ARM_SWP = PSNIP_CPU_FEATURE_ARM | 1,\n PSNIP_CPU_FEATURE_ARM_HALF = PSNIP_CPU_FEATURE_ARM | 2,\n PSNIP_CPU_FEATURE_ARM_THUMB = PSNIP_CPU_FEATURE_ARM | 3,\n PSNIP_CPU_FEATURE_ARM_26BIT = PSNIP_CPU_FEATURE_ARM | 4,\n PSNIP_CPU_FEATURE_ARM_FAST_MULT = PSNIP_CPU_FEATURE_ARM | 5,\n PSNIP_CPU_FEATURE_ARM_FPA = PSNIP_CPU_FEATURE_ARM | 6,\n PSNIP_CPU_FEATURE_ARM_VFP = PSNIP_CPU_FEATURE_ARM | 7,\n PSNIP_CPU_FEATURE_ARM_EDSP = PSNIP_CPU_FEATURE_ARM | 8,\n PSNIP_CPU_FEATURE_ARM_JAVA = PSNIP_CPU_FEATURE_ARM | 9,\n PSNIP_CPU_FEATURE_ARM_IWMMXT = PSNIP_CPU_FEATURE_ARM | 10,\n PSNIP_CPU_FEATURE_ARM_CRUNCH = PSNIP_CPU_FEATURE_ARM | 11,\n PSNIP_CPU_FEATURE_ARM_THUMBEE = PSNIP_CPU_FEATURE_ARM | 12,\n PSNIP_CPU_FEATURE_ARM_NEON = PSNIP_CPU_FEATURE_ARM | 13,\n PSNIP_CPU_FEATURE_ARM_VFPV3 = PSNIP_CPU_FEATURE_ARM | 14,\n PSNIP_CPU_FEATURE_ARM_VFPV3D16 = PSNIP_CPU_FEATURE_ARM | 15,\n PSNIP_CPU_FEATURE_ARM_TLS = PSNIP_CPU_FEATURE_ARM | 16,\n PSNIP_CPU_FEATURE_ARM_VFPV4 = PSNIP_CPU_FEATURE_ARM | 17,\n PSNIP_CPU_FEATURE_ARM_IDIVA = PSNIP_CPU_FEATURE_ARM | 18,\n PSNIP_CPU_FEATURE_ARM_IDIVT = PSNIP_CPU_FEATURE_ARM | 19,\n PSNIP_CPU_FEATURE_ARM_VFPD32 = PSNIP_CPU_FEATURE_ARM | 20,\n PSNIP_CPU_FEATURE_ARM_LPAE = PSNIP_CPU_FEATURE_ARM | 21,\n PSNIP_CPU_FEATURE_ARM_EVTSTRM = PSNIP_CPU_FEATURE_ARM | 22,\n\n PSNIP_CPU_FEATURE_ARM_AES = PSNIP_CPU_FEATURE_ARM | 0x0100 | 1,\n PSNIP_CPU_FEATURE_ARM_PMULL = PSNIP_CPU_FEATURE_ARM | 0x0100 | 2,\n PSNIP_CPU_FEATURE_ARM_SHA1 = PSNIP_CPU_FEATURE_ARM | 0x0100 | 3,\n PSNIP_CPU_FEATURE_ARM_SHA2 = PSNIP_CPU_FEATURE_ARM | 0x0100 | 4,\n PSNIP_CPU_FEATURE_ARM_CRC32 = PSNIP_CPU_FEATURE_ARM | 0x0100 | 5\n};\n\nint psnip_cpu_count (void);\nint psnip_cpu_feature_check (enum PSnipCPUFeature feature);\nint psnip_cpu_feature_check_many (enum PSnipCPUFeature* feature);\n\n#if defined(__cplusplus)\n}\n#endif\n\n#endif /* PSNIP_CPU__H */\n" }, { "path": "cpuid.cpp", "content": "/*\n * cpuid.cpp\n */\n\n#include \"cpuid.hpp\"\n\n#include \n\nusing std::uint8_t;\nusing std::uint32_t;\n\n\nstd::string cpuid_result::to_string() {\n std::string s;\n s += \"eax = \" + std::to_string(eax) + \", \";\n s += \"ebx = \" + std::to_string(ebx) + \", \";\n s += \"ecx = \" + std::to_string(ecx) + \", \";\n s += \"edx = \" + std::to_string(edx);\n return s;\n}\n\nuint32_t cpuid_highest_leaf_inner() {\n return cpuid(0).eax;\n}\n\nuint32_t cpuid_highest_leaf() {\n static uint32_t cached = cpuid_highest_leaf_inner();\n return cached;\n}\n\ncpuid_result cpuid(int leaf, int subleaf) {\n cpuid_result ret = {};\n asm (\"cpuid\"\n :\n \"=a\" (ret.eax),\n \"=b\" (ret.ebx),\n \"=c\" (ret.ecx),\n \"=d\" (ret.edx)\n :\n \"a\" (leaf),\n \"c\" (subleaf)\n );\n return ret;\n}\n\ncpuid_result cpuid(int leaf) {\n return cpuid(leaf, 0);\n}\n\nfamily_model gfm_inner() {\n auto cpuid1 = cpuid(1);\n family_model ret;\n ret.family = (cpuid1.eax >> 8) & 0xF;\n ret.model = (cpuid1.eax >> 4) & 0xF;\n ret.stepping = (cpuid1.eax ) & 0xF;\n if (ret.family == 15) {\n ret.family += (cpuid1.eax >> 20) & 0xFF; // extended family\n }\n if (ret.family == 15 || ret.family == 6) {\n ret.model += ((cpuid1.eax >> 16) & 0xF) << 4; // extended model\n }\n return ret;\n}\n\nfamily_model get_family_model() {\n static family_model cached_family_model = gfm_inner();\n return cached_family_model;\n}\n\nstd::string get_brand_string() {\n auto check = cpuid(0x80000000);\n if (check.eax < 0x80000004) {\n return std::string(\"unkown (eax =\") + std::to_string(check.eax) +\")\";\n }\n std::string ret;\n for (uint32_t eax : {0x80000002, 0x80000003, 0x80000004}) {\n char buf[17];\n auto fourchars = cpuid(eax);\n memcpy(buf + 0, &fourchars.eax, 4);\n memcpy(buf + 4, &fourchars.ebx, 4);\n memcpy(buf + 8, &fourchars.ecx, 4);\n memcpy(buf + 12, &fourchars.edx, 4);\n buf[16] = '\\0';\n ret += buf;\n }\n return ret;\n}\n\n/* get bits [start:end] inclusive of the given value */\nuint32_t get_bits(uint32_t value, int start, int end) {\n value >>= start;\n uint32_t mask = ((uint64_t)-1) << (end - start + 1);\n return value & ~mask;\n}\n\n/**\n * Get the shift amount for unique physical core IDs\n */\nint get_smt_shift()\n{\n if (cpuid_highest_leaf() < 0xb) {\n return -1;\n }\n uint32_t smtShift = -1u;\n for (uint32_t subleaf = 0; ; subleaf++) {\n cpuid_result leafb = cpuid(0xb, subleaf);\n uint32_t type = get_bits(leafb.ecx, 8 ,15);\n if (!get_bits(leafb.ebx,0,15) || type == 0) {\n // done\n break;\n }\n if (type == 1) {\n // here's the value we are after: make sure we don't have more than one entry for\n // this type though!\n if (smtShift != -1u) {\n fprintf(stderr, \"Warning: more than one level of type 1 in the x2APIC hierarchy\");\n }\n smtShift = get_bits(leafb.eax, 0, 4);\n }\n }\n return smtShift;\n}\n\n" }, { "path": "cpuid.hpp", "content": "/*\n * cpuid.hpp\n */\n\n#ifndef CPUID_HPP_\n#define CPUID_HPP_\n\n#include \n#include \n\nstruct cpuid_result {\n std::uint32_t eax, ebx, ecx, edx;\n std::string to_string();\n};\n\nstruct family_model {\n uint8_t family;\n uint8_t model;\n uint8_t stepping;\n std::string to_string() {\n std::string s;\n s += \"family = \" + std::to_string(family) + \", \";\n s += \"model = \" + std::to_string(model) + \", \";\n s += \"stepping = \" + std::to_string(stepping);\n return s;\n }\n};\n\n\n/** the highest supported leaf value */\nuint32_t cpuid_highest_leaf();\n\n/* return the CPUID result for querying the given leaf (EAX) and no subleaf (ECX=0) */\ncpuid_result cpuid(int leaf);\n\n/* return the CPUID result for querying the given leaf (EAX) and subleaf (ECX) */\ncpuid_result cpuid(int leaf, int subleaf);\n\nfamily_model get_family_model();\n\nstd::string get_brand_string();\n\nint get_smt_shift();\n\n/* get bits [start:end] inclusive of the given value */\nuint32_t get_bits(uint32_t value, int start, int end);\n\n#endif /* CPUID_HPP_ */\n" }, { "path": "exact-int.h", "content": "/* Exact-width integer types\n * Portable Snippets - https://gitub.com/nemequ/portable-snippets\n * Created by Evan Nemerson \n *\n * To the extent possible under law, the authors have waived all\n * copyright and related or neighboring rights to this code. For\n * details, see the Creative Commons Zero 1.0 Universal license at\n * https://creativecommons.org/publicdomain/zero/1.0/\n *\n * This header tries to define psnip_(u)int(8|16|32|64)_t to\n * appropriate types given your system. For most systems this means\n * including and adding a few preprocessor definitions.\n *\n * If you prefer, you can define any necessary types yourself.\n * Snippets in this repository which rely on these types will not\n * attempt to include this header if you have already defined the\n * types it uses.\n */\n\n#if !defined(PSNIP_EXACT_INT_H)\n# define PSNIP_EXACT_INT_H\n# if !defined(PSNIP_EXACT_INT_HAVE_STDINT)\n# if defined(_STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)\n# define PSNIP_EXACT_INT_HAVE_STDINT\n# elif defined(__has_include)\n# if __has_include()\n# define PSNIP_EXACT_INT_HAVE_STDINT\n# endif\n# elif \\\n defined(HAVE_STDINT_H) || \\\n defined(_STDINT_H_INCLUDED) || \\\n defined(_STDINT_H) || \\\n defined(_STDINT_H_)\n# define PSNIP_EXACT_INT_HAVE_STDINT\n# elif \\\n (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))) || \\\n (defined(_MSC_VER) && (_MSC_VER >= 1600)) || \\\n (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x570)) || \\\n (defined(__WATCOMC__) && (__WATCOMC__ >= 1250))\n# define PSNIP_EXACT_INT_HAVE_STDINT\n# endif\n# endif\n\n# if \\\n defined(__INT8_TYPE__) && defined(__INT16_TYPE__) && defined(__INT32_TYPE__) && defined(__INT64_TYPE__) && \\\n defined(__UINT8_TYPE__) && defined(__UINT16_TYPE__) && defined(__UINT32_TYPE__) && defined(__UINT64_TYPE__)\n# define psnip_int8_t __INT8_TYPE__\n# define psnip_int16_t __INT16_TYPE__\n# define psnip_int32_t __INT32_TYPE__\n# define psnip_int64_t __INT64_TYPE__\n# define psnip_uint8_t __UINT8_TYPE__\n# define psnip_uint16_t __UINT16_TYPE__\n# define psnip_uint32_t __UINT32_TYPE__\n# define psnip_uint64_t __UINT64_TYPE__\n# elif defined(PSNIP_EXACT_INT_HAVE_STDINT)\n# include \n# if !defined(psnip_int8_t)\n# define psnip_int8_t int8_t\n# endif\n# if !defined(psnip_uint8_t)\n# define psnip_uint8_t uint8_t\n# endif\n# if !defined(psnip_int16_t)\n# define psnip_int16_t int16_t\n# endif\n# if !defined(psnip_uint16_t)\n# define psnip_uint16_t uint16_t\n# endif\n# if !defined(psnip_int32_t)\n# define psnip_int32_t int32_t\n# endif\n# if !defined(psnip_uint32_t)\n# define psnip_uint32_t uint32_t\n# endif\n# if !defined(psnip_int64_t)\n# define psnip_int64_t int64_t\n# endif\n# if !defined(psnip_uint64_t)\n# define psnip_uint64_t uint64_t\n# endif\n# elif defined(_MSC_VER)\n# if !defined(psnip_int8_t)\n# define psnip_int8_t __int8\n# endif\n# if !defined(psnip_uint8_t)\n# define psnip_uint8_t unsigned __int8\n# endif\n# if !defined(psnip_int16_t)\n# define psnip_int16_t __int16\n# endif\n# if !defined(psnip_uint16_t)\n# define psnip_uint16_t unsigned __int16\n# endif\n# if !defined(psnip_int32_t)\n# define psnip_int32_t __int32\n# endif\n# if !defined(psnip_uint32_t)\n# define psnip_uint32_t unsigned __int32\n# endif\n# if !defined(psnip_int64_t)\n# define psnip_int64_t __int64\n# endif\n# if !defined(psnip_uint64_t)\n# define psnip_uint64_t unsigned __int64\n# endif\n# else\n# include \n# if !defined(psnip_int8_t)\n# if defined(CHAR_MIN) && defined(CHAR_MAX) && (CHAR_MIN == (-127-1)) && (CHAR_MAX == 127)\n# define psnip_int8_t char\n# elif defined(SHRT_MIN) && defined(SHRT_MAX) && (SHRT_MIN == (-127-1)) && (SHRT_MAX == 127)\n# define psnip_int8_t short\n# elif defined(INT_MIN) && defined(INT_MAX) && (INT_MIN == (-127-1)) && (INT_MAX == 127)\n# define psnip_int8_t int\n# elif defined(LONG_MIN) && defined(LONG_MAX) && (LONG_MIN == (-127-1)) && (LONG_MAX == 127)\n# define psnip_int8_t long\n# elif defined(LLONG_MIN) && defined(LLONG_MAX) && (LLONG_MIN == (-127-1)) && (LLONG_MAX == 127)\n# define psnip_int8_t long long\n# else\n# error Unable to locate 8-bit signed integer type.\n# endif\n# endif\n# if !defined(psnip_uint8_t)\n# if defined(UCHAR_MAX) && (UCHAR_MAX == 255)\n# define psnip_uint8_t unsigned char\n# elif defined(USHRT_MAX) && (USHRT_MAX == 255)\n# define psnip_uint8_t unsigned short\n# elif defined(UINT_MAX) && (UINT_MAX == 255)\n# define psnip_uint8_t unsigned int\n# elif defined(ULONG_MAX) && (ULONG_MAX == 255)\n# define psnip_uint8_t unsigned long\n# elif defined(ULLONG_MAX) && (ULLONG_MAX == 255)\n# define psnip_uint8_t unsigned long long\n# else\n# error Unable to locate 8-bit unsigned integer type.\n# endif\n# endif\n# if !defined(psnip_int16_t)\n# if defined(CHAR_MIN) && defined(CHAR_MAX) && (CHAR_MIN == (-32767-1)) && (CHAR_MAX == 32767)\n# define psnip_int16_t char\n# elif defined(SHRT_MIN) && defined(SHRT_MAX) && (SHRT_MIN == (-32767-1)) && (SHRT_MAX == 32767)\n# define psnip_int16_t short\n# elif defined(INT_MIN) && defined(INT_MAX) && (INT_MIN == (-32767-1)) && (INT_MAX == 32767)\n# define psnip_int16_t int\n# elif defined(LONG_MIN) && defined(LONG_MAX) && (LONG_MIN == (-32767-1)) && (LONG_MAX == 32767)\n# define psnip_int16_t long\n# elif defined(LLONG_MIN) && defined(LLONG_MAX) && (LLONG_MIN == (-32767-1)) && (LLONG_MAX == 32767)\n# define psnip_int16_t long long\n# else\n# error Unable to locate 16-bit signed integer type.\n# endif\n# endif\n# if !defined(psnip_uint16_t)\n# if defined(UCHAR_MAX) && (UCHAR_MAX == 65535)\n# define psnip_uint16_t unsigned char\n# elif defined(USHRT_MAX) && (USHRT_MAX == 65535)\n# define psnip_uint16_t unsigned short\n# elif defined(UINT_MAX) && (UINT_MAX == 65535)\n# define psnip_uint16_t unsigned int\n# elif defined(ULONG_MAX) && (ULONG_MAX == 65535)\n# define psnip_uint16_t unsigned long\n# elif defined(ULLONG_MAX) && (ULLONG_MAX == 65535)\n# define psnip_uint16_t unsigned long long\n# else\n# error Unable to locate 16-bit unsigned integer type.\n# endif\n# endif\n# if !defined(psnip_int32_t)\n# if defined(CHAR_MIN) && defined(CHAR_MAX) && (CHAR_MIN == (-2147483647-1)) && (CHAR_MAX == 2147483647)\n# define psnip_int32_t char\n# elif defined(SHRT_MIN) && defined(SHRT_MAX) && (SHRT_MIN == (-2147483647-1)) && (SHRT_MAX == 2147483647)\n# define psnip_int32_t short\n# elif defined(INT_MIN) && defined(INT_MAX) && (INT_MIN == (-2147483647-1)) && (INT_MAX == 2147483647)\n# define psnip_int32_t int\n# elif defined(LONG_MIN) && defined(LONG_MAX) && (LONG_MIN == (-2147483647-1)) && (LONG_MAX == 2147483647)\n# define psnip_int32_t long\n# elif defined(LLONG_MIN) && defined(LLONG_MAX) && (LLONG_MIN == (-2147483647-1)) && (LLONG_MAX == 2147483647)\n# define psnip_int32_t long long\n# else\n# error Unable to locate 32-bit signed integer type.\n# endif\n# endif\n# if !defined(psnip_uint32_t)\n# if defined(UCHAR_MAX) && (UCHAR_MAX == 4294967295)\n# define psnip_uint32_t unsigned char\n# elif defined(USHRT_MAX) && (USHRT_MAX == 4294967295)\n# define psnip_uint32_t unsigned short\n# elif defined(UINT_MAX) && (UINT_MAX == 4294967295)\n# define psnip_uint32_t unsigned int\n# elif defined(ULONG_MAX) && (ULONG_MAX == 4294967295)\n# define psnip_uint32_t unsigned long\n# elif defined(ULLONG_MAX) && (ULLONG_MAX == 4294967295)\n# define psnip_uint32_t unsigned long long\n# else\n# error Unable to locate 32-bit unsigned integer type.\n# endif\n# endif\n# if !defined(psnip_int64_t)\n# if defined(CHAR_MIN) && defined(CHAR_MAX) && (CHAR_MIN == (-9223372036854775807LL-1)) && (CHAR_MAX == 9223372036854775807LL)\n# define psnip_int64_t char\n# elif defined(SHRT_MIN) && defined(SHRT_MAX) && (SHRT_MIN == (-9223372036854775807LL-1)) && (SHRT_MAX == 9223372036854775807LL)\n# define psnip_int64_t short\n# elif defined(INT_MIN) && defined(INT_MAX) && (INT_MIN == (-9223372036854775807LL-1)) && (INT_MAX == 9223372036854775807LL)\n# define psnip_int64_t int\n# elif defined(LONG_MIN) && defined(LONG_MAX) && (LONG_MIN == (-9223372036854775807LL-1)) && (LONG_MAX == 9223372036854775807LL)\n# define psnip_int64_t long\n# elif defined(LLONG_MIN) && defined(LLONG_MAX) && (LLONG_MIN == (-9223372036854775807LL-1)) && (LLONG_MAX == 9223372036854775807LL)\n# define psnip_int64_t long long\n# else\n# error Unable to locate 64-bit signed integer type.\n# endif\n# endif\n# if !defined(psnip_uint64_t)\n# if defined(UCHAR_MAX) && (UCHAR_MAX == 18446744073709551615ULL)\n# define psnip_uint64_t unsigned char\n# elif defined(USHRT_MAX) && (USHRT_MAX == 18446744073709551615ULL)\n# define psnip_uint64_t unsigned short\n# elif defined(UINT_MAX) && (UINT_MAX == 18446744073709551615ULL)\n# define psnip_uint64_t unsigned int\n# elif defined(ULONG_MAX) && (ULONG_MAX == 18446744073709551615ULL)\n# define psnip_uint64_t unsigned long\n# elif defined(ULLONG_MAX) && (ULLONG_MAX == 18446744073709551615ULL)\n# define psnip_uint64_t unsigned long long\n# else\n# error Unable to locate 64-bit unsigned integer type.\n# endif\n# endif\n# endif\n#endif\n" }, { "path": "msr-access.c", "content": "/*\n * msr-access.c\n */\n\n// for pread() and sched_getcpu()\n#define _GNU_SOURCE\n\n#include \"msr-access.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/** if there are this many CPUs or less, we'll never allocate memory */\n#define STATIC_ARRAY_SIZE 32\n\n#ifndef MSR_USE_PTHREADS\n// thread-safe by default\n#define MSR_USE_PTHREADS 1\n#endif\n\n#if MSR_USE_PTHREADS\n#include \nstatic pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;\nvoid lock() {\n pthread_mutex_lock(&mutex);\n}\nvoid unlock() {\n pthread_mutex_unlock(&mutex);\n}\n#else\nvoid lock() {}\nvoid unlock(){}\n#endif\n\n\n\n/* size of the rfile array */\nint rfile_static[STATIC_ARRAY_SIZE] = {};\nint rfile_size = STATIC_ARRAY_SIZE;\nint *rfile_array = rfile_static;\n//int rfile_error;\n\n/** get the read-only file associated with the given cpu */\nint get_rfile(int cpu) {\n assert(cpu >= 0);\n\n lock();\n\n if (cpu >= rfile_size) {\n // expand array\n size_t new_size = rfile_size * 2 > cpu ? rfile_size * 2 : cpu;\n int *new_array = calloc(new_size, sizeof(int));\n memcpy(new_array, rfile_array, rfile_size * sizeof(int));\n if (rfile_array != rfile_static) {\n free(rfile_array);\n }\n rfile_array = new_array;\n rfile_size = new_size;\n }\n\n if (rfile_array[cpu] == 0) {\n char filename[64] = {};\n int ret = snprintf(filename, 64, \"/dev/cpu/%d/msr\", cpu);\n assert(ret > 0);\n rfile_array[cpu] = open(filename, O_RDONLY);\n if (rfile_array[cpu] == -1) {\n rfile_array[cpu] = -errno;\n }\n }\n\n int ret = rfile_array[cpu];\n\n unlock();\n\n return ret;\n}\n\nint read_msr(int cpu, uint32_t msr_index, uint64_t* value) {\n int file = get_rfile(cpu);\n assert(file);\n if (file < 0) {\n // file open failes are stored as negative errno\n return file;\n }\n int read = pread(file, value, 8, msr_index);\n return read == -1 ? errno : 0;\n}\n\nint read_msr_cur_cpu(uint32_t msr_index, uint64_t* value) {\n return read_msr(sched_getcpu(), msr_index, value);\n}\n\n\n// rename this to main to build an exe that can be run as ./a.out CPU MSR\n// to read MSR from CPU (like a really simple rdmsr)\nint test(int argc, char** argv) {\n assert(argc == 3);\n int cpu = atoi(argv[1]);\n uint32_t msr = atoi(argv[2]);\n printf(\"reading msr %u from cpu %d\\n\", msr, cpu);\n uint64_t value = -1;\n\n int res = read_msr(cpu, msr, &value);\n if (res) {\n printf(\"error %d\\n\", res);\n } else {\n printf(\"value %lx\\n\", value);\n }\n\n res = read_msr_cur_cpu(msr, &value);\n if (res) {\n printf(\"error %d\\n\", res);\n } else {\n printf(\"value %lx\\n\", value);\n }\n\n return EXIT_SUCCESS;\n}\n\n\n" }, { "path": "msr-access.h", "content": "/*\n * msr-access.h\n *\n * Simple API to access the x86 MSR registers exposed on linux with through the /dev/cpu/N/msr file system.\n *\n * Unless you've changed the msr permissions, only root can do this. The msr filesystem may not exist until\n * 'modprobe msr' is executed to load the msr module.\n */\n\n#ifndef MSR_ACCESS_H_\n#define MSR_ACCESS_H_\n\n#include \n// you could get the MSR index values from the following header, although it isn't exported to user-space\n// in kernels after 4.12, but you can grab it from the linux source\n// #include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n\n/**\n * Read the MSR given by msr_index on the given cpu, storing the result into\n * result, which must point to at least 8 bytes of storage.\n *\n * Returns zero on success, non-zero on failure.\n *\n * Negative values indicate errors\n * opening the underlying MSR file: the value returned is the negative of the errno\n * returned by the kernel when trying to open the file. These file errors is cached\n * so once a negative value has been returned for a given cpu, subsequent calls will\n * always return the same value.\n *\n * Positive values indicate failures during the pread call performed to actually read\n * the msr from the open file. The value is the errno returned by the kernel after the\n * read. The most common value is 5 (EIO) which indicates that you can't read that MSR\n * on this hardware (e.g., if may not exist).\n */\nint read_msr(int cpu, uint32_t msr_index, uint64_t* value);\n\n/**\n * Reads the given MSR on the current CPU. This is just a shortcut for calling\n * read_msr(sched_getcpu(), ...), and the result and error handling is the same as that function.\n *\n * Of course, unless the thread affinity has been restricted for the current thread,\n * the result doesn't help the calling code know the true value on the current CPU since\n * a context switch can happen at any time (the same caveat applies to getcpu()).\n */\nint read_msr_cur_cpu(uint32_t msr_index, uint64_t* value);\n\n\n#ifdef __cplusplus\n} // extern \"C\" {\n#endif\n\n#endif // #ifdef MSR_ACCESS_H_\n" }, { "path": "nasm-2.13.03/LICENSE", "content": "NASM is now licensed under the 2-clause BSD license, also known as the\nsimplified BSD license.\n\n Copyright 1996-2010 the NASM Authors - All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following\n conditions are met:\n\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\n copyright notice, this list of conditions and the following\n disclaimer in the documentation and/or other materials provided\n with the distribution.\n \n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND\n CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES,\n INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR\n CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\n OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,\n EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" }, { "path": "nasm-2.13.03/NOTE", "content": "This stable version of the nasm binary is here in avx-turbo since many version of nasm included in distributions are\ncapable of compiling AVX-512 (2.11 is required at a minimum). So we include the binary here along with the LICENSE\n(which allows such binary distribution). \n" }, { "path": "nasm-utils-helper.c", "content": "/*\n * nasm-utils-helper.c\n *\n * C helper functions for some macros in nasm-utils-inc.asm.\n *\n * If you use any macros that require functionality defined here, just include this C file in\n * your project (linked against the same object that contains the assembly generated with the\n * help of nasm-utils-inc.asm).\n */\n\n#include \n#include \n#include \n#include \n\n\n// mapping from reg_id to register name\nstatic const char *reg_names[] = {\n \"rbp\",\n \"rbx\",\n \"r12\",\n \"r13\",\n \"r14\",\n \"r15\"\n};\n\n/* called when a function using abi_checked_function detects an illegally clobbered register */\nvoid nasm_util_die_on_reg_clobber(const char *fname, unsigned reg_id) {\n reg_id--; // reg ids are 1-based\n if (reg_id >= sizeof(sizeof(reg_names)/sizeof(reg_names[0]))) {\n fprintf(stderr, \"FATAL: function %s clobbered a callee-saved register (thunk returned an invalid reg_id %d)\\n\",\n fname, reg_id);\n } else {\n fprintf(stderr, \"FATAL: function %s clobbered callee-saved register %s\\n\", fname, reg_names[reg_id]);\n }\n abort();\n}\n\nvoid nasm_util_assert_failed(const char *left, const char *right, const char *filename, int64_t line) {\n fprintf(stderr, \"%s:%ld : Assertion failed: %s == %s\\n\", filename, (long)line, left, right);\n fflush(stderr);\n abort();\n}\n" }, { "path": "nasm-utils-inc.asm", "content": ";; potentially useful macros for asm development\n\n;; long-nop instructions: nopX inserts a nop of X bytes\n;; see \"Table 4-12. Recommended Multi-Byte Sequence of NOP Instruction\" in\n;; \"Intelยฎ 64 and IA-32 Architectures Software Developerโ€™s Manual\" (325383-061US)\n%define nop1 nop ; just a nop, included for completeness\n%define nop2 db 0x66, 0x90 ; 66 NOP\n%define nop3 db 0x0F, 0x1F, 0x00 ; NOP DWORD ptr [EAX]\n%define nop4 db 0x0F, 0x1F, 0x40, 0x00 ; NOP DWORD ptr [EAX + 00H]\n%define nop5 db 0x0F, 0x1F, 0x44, 0x00, 0x00 ; NOP DWORD ptr [EAX + EAX*1 + 00H]\n%define nop6 db 0x66, 0x0F, 0x1F, 0x44, 0x00, 0x00 ; 66 NOP DWORD ptr [EAX + EAX*1 + 00H]\n%define nop7 db 0x0F, 0x1F, 0x80, 0x00, 0x00, 0x00, 0x00 ; NOP DWORD ptr [EAX + 00000000H]\n%define nop8 db 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 ; NOP DWORD ptr [EAX + EAX*1 + 00000000H]\n%define nop9 db 0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 ; 66 NOP DWORD ptr [EAX + EAX*1 + 00000000H]\n\n;; push the 6 callee-saved registers defined in the the SysV C ABI\n%macro push_callee_saved 0\npush rbp\npush rbx\npush r12\npush r13\npush r14\npush r15\n%endmacro\n\n;; pop the 6 callee-saved registers in the order compatible with push_callee_saved\n%macro pop_callee_saved 0\npop r15\npop r14\npop r13\npop r12\npop rbx\npop rbp\n%endmacro\n\nEXTERN nasm_util_assert_failed\n\n; place the string value of a tken in .rodata using %defstr\n; arg1 - the token to make into a string\n; arg2 - label which will point to the string\n%macro make_string_tok 2\n%ifdef __YASM_MAJOR__\n; yasm has no support for defstr so we just use a fixed string for now\n; see https://github.com/travisdowns/nasm-utils/issues/1\nmake_string 'make_string_tok yasm bug', %2\n%else\n%defstr make_string_temp %1\nmake_string make_string_temp, %2\n%endif\n%endmacro\n\n%macro make_string 2\n[section .rodata]\n%2:\ndb %1,0\n; restore the previous section\n__SECT__\n%endmacro\n\n%macro nasm_util_assert_boilerplate 0\nmake_string __FILE__, parent_filename\n%define ASSERT_BOILERPLATE 1\n%endmacro\n\n%macro check_assert_boilerplate 0\n%ifndef ASSERT_BOILERPLATE\n%error \"To use asserts, you must include a call to nasm_util_assert_boilerplate once in each file\"\n%endif\n%endmacro\n\n;; assembly level asserts\n;; if the assert occurs, termination is assumed so control never passes back to the caller\n;; and registers are not preserved\n%macro assert_eq 2\ncheck_assert_boilerplate\ncmp %1, %2\nje %%assert_ok\nmake_string_tok %1, %%assert_string1\nmake_string_tok %2, %%assert_string2\nlea rdi, [%%assert_string1]\nlea rsi, [%%assert_string2]\nlea rdx, [parent_filename]\nmov rcx, __LINE__\njmp nasm_util_assert_failed\n%%assert_ok:\n%endmacro\n\n;; boilerplate needed once when abi_checked_function is used\n%macro thunk_boilerplate 0\n; this function is defined by the C helper code\nEXTERN nasm_util_die_on_reg_clobber\n\nboil1 rbp, 1\nboil1 rbx, 2\nboil1 r12, 3\nboil1 r13, 4\nboil1 r14, 5\nboil1 r15, 6\n%endmacro\n\n;; By default, the \"assert-like\" features that can be conditionally enabled key off the value of the\n;; NDEBUG macro: if it is defined, the slower, more heavily checked paths are enabled, otherwise they\n;; are omitted (usually resulting in zero additional cost).\n;;\n;; If you don't want to rely on NDEBUG can specifically enable or disable the debug mode with the\n;; NASM_ENABLE_DEBUG set to 0 (equivalent to NDEBUG set) or 1 (equivalent to NDEBUG not set)\n%ifndef NASM_ENABLE_DEBUG\n %ifdef NDEBUG\n %define NASM_ENABLE_DEBUG 0\n %else\n %define NASM_ENABLE_DEBUG 1\n %endif\n%elif (NASM_ENABLE_DEBUG != 0) && (NASM_ENABLE_DEBUG != 1)\n %error bad value for 'NASM_ENABLE_DEBUG': should be 0 or 1 but was NASM_ENABLE_DEBUG\n%endif\n\n\n\n\n;; This macro supports declaring a \"ABI-checked\" function in asm\n;; An ABI-checked function will checked at each invocation for compliance with the SysV ABI\n;; rules about callee saved registers. In particular, from the ABI cocument we have the following:\n;;\n;; Registers %rbp, %rbx and %r12 through %r15 โ€œbelongโ€ to the calling function\n;; and the called function is required to preserve their values.\n;; (from \"System V Application Binary Interface, AMD64 Architecture Processor Supplement\")\n;;\n;;\n%macro abi_checked_function 1\nGLOBAL %1:function\n\n%1:\n\n%if NASM_ENABLE_DEBUG != 0\n\n;%warning compiling ABI checks\n\n; save all the callee-saved regs\npush_callee_saved\npush rax ; dummy push to align the stack (before we have rsp % 16 == 8)\ncall %1_inner\nadd rsp, 8 ; undo dummy push\n\n; load the function name (ok to clobber rdi since it's callee-saved)\nmov rdi, %1_thunk_fn_name\n\n; now check whether any regs were clobbered\ncmp rbp, [rsp + 40]\njne bad_rbp\ncmp rbx, [rsp + 32]\njne bad_rbx\ncmp r12, [rsp + 24]\njne bad_r12\ncmp r13, [rsp + 16]\njne bad_r13\ncmp r14, [rsp + 8]\njne bad_r14\ncmp r15, [rsp]\njne bad_r15\n\nadd rsp, 6 * 8\nret\n\n\n; here we store strings needed by the failure cases, in the .rodata section\n[section .rodata]\n%1_thunk_fn_name:\n%ifdef __YASM_MAJOR__\n; yasm doesn't support defstr, so for now just use an unknown name\ndb \"unknown (see yasm issue #95)\",0\n%else\n%defstr fname %1\ndb fname,0\n%endif\n\n; restore the previous section\n__SECT__\n\n%1_inner:\n%endif ; debug off, just assemble the function as-is without any checks\n\n%endmacro\n\n\n;;;;;;;;;;;;;;;;;;;;;;;;;;;\n;; IMPLEMENTATION FOLLOWS\n;; below you find internal macros needed for the implementation of the above macros\n;;;;;;;;;;;;;;;;;;;;;;;;;;;\n\n; generate the stubs for the bad_reg functions called from the check-abi thunk\n%macro boil1 2\nbad_%1:\n; A thunk has determined that a reg was clobbered\n; each reg has their own bad_ function which moves the function name (in rdx) into\n; rdi and loads a constant indicating which reg was involved and calls a C routine\n; that will do the rest (abort the program generall). We follow up with an ud2 in case\n; the C routine returns, since this mechanism is not designed for recovery.\nmov rsi, %2\n; here we set up a stack frame - this gives a meaningful backtrace in any core file produced by the abort\n; first we need to pop the saved regs off the stack so the rbp chain is consistent\nadd rsp, 6 * 8\npush rbp\nmov rbp, rsp\ncall nasm_util_die_on_reg_clobber\nud2\n%endmacro\n\n\n\n\n" }, { "path": "once.h", "content": "/* Once (v1)\n * Portable Snippets - https://gitub.com/nemequ/portable-snippets\n * Created by Evan Nemerson \n *\n * To the extent possible under law, the authors have waived all\n * copyright and related or neighboring rights to this code. For\n * details, see the Creative Commons Zero 1.0 Universal license at\n * https://creativecommons.org/publicdomain/zero/1.0/\n */\n\n#if !defined(PSNIP_ONCE__H)\n#define PSNIP_ONCE__H\n\n#define PSNIP_ONCE__BACKEND_ATOMIC 1\n#define PSNIP_ONCE__BACKEND_PTHREAD 2\n#define PSNIP_ONCE__BACKEND_NONE 3\n#define PSNIP_ONCE__BACKEND_C11 11\n#define PSNIP_ONCE__BACKEND_WIN32 32\n\n#if !defined(PSNIP_ONCE_BACKEND)\n# if defined(__STDC_NO_THREADS__) && __STDC_NO_THREADS__\n# elif defined(__EMSCRIPTEN__)\n# elif defined(__has_include)\n# if __has_include()\n# include \n# define PSNIP_ONCE_BACKEND PSNIP_ONCE__BACKEND_C11\n# endif\n# elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201102L) && !defined(__STDC_NO_THREADS__)\n# include \n# if defined(__STDC_NO_THREADS__) || (defined(__GNUC__) && (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 16)))\n/* stdc-predef.h didn't include __STDC_NO_THREADS__ until 2.16. icc\n doesn't include stdc-predef.h until we pull in limits.h, so the\n first check doesn't work. */\n# else\n# include \n# define PSNIP_ONCE_BACKEND PSNIP_ONCE__BACKEND_C11\n# endif\n# endif\n#endif\n\n#if !defined(PSNIP_ONCE_BACKEND) && defined(_WIN32) && (!defined(WINVER) || (defined(WINVER) && (WINVER >= 0x0600)))\n# include \n# define PSNIP_ONCE_BACKEND PSNIP_ONCE__BACKEND_WIN32\n#endif\n\n#if !defined(PSNIP_ONCE_BACKEND) && defined(PTHREAD_ONCE_INIT)\n# define PSNIP_ONCE_BACKEND PSNIP_ONCE__BACKEND_PTHREAD\n#endif\n\n#if !defined(PSNIP_ONCE_BACKEND)\n# include \"atomic.h\"\n# if !defined(PSNIP_ATOMIC_NOT_FOUND)\n# define PSNIP_ONCE_BACKEND PSNIP_ONCE__BACKEND_ATOMIC\n# endif\n#endif\n\n#if !defined(PSNIP_ONCE_BACKEND)\n# error No once backend found.\n#endif\n\n#if defined(__GNUC__) && (__GNUC__ >= 3)\n# define PSNIP_ONCE__UNLIKELY(expr) __builtin_expect(!!(expr), !!0)\n#else\n# define PSNIP_ONCE__UNLIKELY(expr) (!!(expr))\n#endif\n\n#if PSNIP_ONCE_BACKEND == PSNIP_ONCE__BACKEND_C11\n# define PSNIP_ONCE_INIT ONCE_FLAG_INIT\ntypedef once_flag psnip_once;\n# define psnip_once_call(flag, func) call_once(flag, func)\n#elif PSNIP_ONCE_BACKEND == PSNIP_ONCE__BACKEND_PTHREAD\n# define PSNIP_ONCE_INIT PTHREAD_ONCE_INIT\ntypedef pthread_once_t psnip_once;\n# define psnip_once_call(flag, func) pthread_once(flag, func)\n#elif PSNIP_ONCE_BACKEND == PSNIP_ONCE__BACKEND_WIN32\n# define PSNIP_ONCE_INIT INIT_ONCE_STATIC_INIT\ntypedef INIT_ONCE psnip_once;\nstatic BOOL CALLBACK psnip_once__callback_wrap(INIT_ONCE* InitOnce, void* Parameter, void** Context) {\n (void) Context;\n (void) InitOnce;\n#if defined(_MSC_VER)\n# pragma warning(push)\n# pragma warning(disable:4055)\n#endif\n ((void (*)(void)) Parameter)();\n#if defined(_MSC_VER)\n# pragma warning(pop)\n#endif\n return !0;\n}\n# if defined(_MSC_VER) && (_MSC_VER >= 1500)\n# define psnip_once_call(flag, func) \\\n __pragma(warning(push)) \\\n __pragma(warning(disable:4152)) \\\n InitOnceExecuteOnce(flag, &psnip_once__callback_wrap, func, NULL) \\\n __pragma(warning(pop))\n# else\n# define psnip_once_call(flag, func) InitOnceExecuteOnce(flag, &psnip_once__callback_wrap, func, NULL)\n# endif\n#elif PSNIP_ONCE_BACKEND == PSNIP_ONCE__BACKEND_ATOMIC\n# define PSNIP_ONCE_INIT PSNIP_ATOMIC_VAR_INIT(0)\ntypedef psnip_atomic_int32 psnip_once;\nstatic void psnip_once_call(psnip_once* flag, void (*func)(void)) {\n psnip_int32_t state = psnip_atomic_int32_load(flag);\n if (PSNIP_ONCE__UNLIKELY(state == 0)) {\n if (psnip_atomic_int32_compare_exchange(flag, &state, 1)) {\n func();\n psnip_atomic_int32_store(flag, 2);\n } else {\n do {\n\t/* Spin; another thread is calling the initialization\n\t function. */\n } while (psnip_atomic_int32_load(flag) == 1);\n }\n }\n}\n#elif PSNIP_ONCE_BACKEND == PSNIP_ONCE__BACKEND_NONE\n# define PSNIP_ONCE_INIT 0\ntypedef int psnip_once;\nstatic void psnip_once_call(psnip_once* flag, void (*func)(void)) {\n if (*flag == 0) {\n func();\n *flag = 1;\n }\n}\n#endif\n\n#endif /* !defined(PSNIP_ONCE__H) */\n" }, { "path": "stats.hpp", "content": "/*\n * Really simple descriptive stats.\n *\n * stats.hpp\n */\n\n#ifndef STATS_HPP_\n#define STATS_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace Stats {\n\nclass DescriptiveStats {\n\tdouble min_, max_, avg_, median_;\n\tsize_t count_;\npublic:\n\tDescriptiveStats(double min, double max, double avg, double median, size_t count) :\n\t\tmin_(min), max_(max), avg_(avg), median_(median), count_(count) {}\n\n\tdouble getAvg() const {\n\t\treturn avg_;\n\t}\n\n\tsize_t getCount() const {\n\t\treturn count_;\n\t}\n\n\tdouble getMax() const {\n\t\treturn max_;\n\t}\n\n\tdouble getMin() const {\n\t\treturn min_;\n\t}\n\n\tdouble getMedian() const {\n\t\treturn median_;\n\t}\n\n\t/*\n\t * Return a string with the values of min/median/avg/max at the specified precision.\n\t * Note that the count is not included.\n\t */\n\tstd::string getString4(int width, int precision) const {\n\t\tstd::ostringstream os;\n\t\tos << std::fixed << std::setprecision(precision) <<\n\t\t\t\tstd::setw(width) << getMin() << \"/\" <<\n\t\t\t\tstd::setw(width) << getMedian() << \"/\" <<\n\t\t\t\tstd::setw(width) << getAvg() << \"/\" <<\n\t\t\t\tstd::setw(width) << getMax();\n\n\t\treturn os.str();\n\t}\n};\n\ntemplate \ntypename std::iterator_traits::value_type median(iter_type first, iter_type last, LESS comp) {\n\tif (first == last) {\n\t\tthrow std::logic_error(\"can't get median of empty range\");\n\t}\n\tusing T = typename std::iterator_traits::value_type;\n\tstd::vector copy(first, last);\n\tstd::sort(copy.begin(), copy.end(), comp);\n\tsize_t sz = copy.size(), half_sz = sz / 2;\n\treturn sz % 2 ? copy[half_sz] : (copy[half_sz - 1] + copy[half_sz]) / 2;\n}\n\n/**\n * Like median above, except that with an even number of elements, where there are two middle elements with\n * equal claim to the throne, the lesser of the two elements is returned rather trying to average them. This\n * method is more generally applicable since it always returns on of the elements of the input range directly\n * and doesn't require the elements to expose the operations required to calculate an average.\n */\ntemplate \ntypename std::iterator_traits::value_type medianf(iter_type first, iter_type last, LESS comp) {\n if (first == last) {\n throw std::logic_error(\"can't get median of empty range\");\n }\n using T = typename std::iterator_traits::value_type;\n std::vector copy(first, last);\n std::sort(copy.begin(), copy.end(), comp);\n assert(!copy.empty());\n return copy[(copy.size() - 1) / 2];\n}\n\ntemplate \ntypename std::iterator_traits::value_type median(iter_type first, iter_type last) {\n auto p = std::less::value_type>();\n return Stats::median(first, last, p);\n}\n\n\ntemplate \nDescriptiveStats get_stats(iter_type first, iter_type last) {\n\tusing dlimits = std::numeric_limits;\n\tdouble min = dlimits::max(), max = dlimits::min(), total = 0;\n\tsize_t count = 0;\n\tfor (iter_type itr = first; itr != last; itr++) {\n\t\tauto val = *itr;\n\t\tdouble vald = val;\n\t\tif (vald < min) min = vald;\n\t\tif (vald > max) max = vald;\n\t\ttotal += vald;\n\t\tcount++;\n\t}\n\n\treturn DescriptiveStats(min, max, total / count, median(first, last), count);\n}\n\n\n\ninline std::ostream& operator<<(std::ostream &os, const DescriptiveStats &stats) {\n\tos << \"min=\" << stats.getMin() << \", median=\" << stats.getMedian() << \", avg=\" << stats.getAvg()\n\t\t\t<< \", max=\" << stats.getMax() << \", n=\" << stats.getCount();\n\treturn os;\n}\n\n} // namepsace Stats\n\n#endif /* STATS_HPP_ */\n" }, { "path": "table.hpp", "content": "/*\n * table.hpp\n *\n * Simple tabular output.\n */\n\n#ifndef TABLE_HPP_\n#define TABLE_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace table {\n\n/*\n * Given a printf-style format and args, return the formatted string as a std::string.\n *\n * See https://stackoverflow.com/a/26221725/149138.\n */\ntemplate\nstd::string string_format(const std::string& format, Args ... args) {\n size_t size = snprintf( nullptr, 0, format.c_str(), args ... ) + 1; // Extra space for '\\0'\n std::unique_ptr buf( new char[ size ] );\n snprintf( buf.get(), size, format.c_str(), args ... );\n return std::string( buf.get(), buf.get() + size - 1 ); // We don't want the '\\0' inside\n}\n\nclass Table;\n\nstruct ColInfo {\n enum Justification { LEFT, RIGHT } justify;\n ColInfo() : justify(LEFT) {}\n};\n\nclass Row {\n friend Table;\n using row_t = std::vector;\n\n const Table* table_;\n row_t elems_;\n\n Row(const Table& table) : table_(&table) {}\n\n /** return a vector of sizes for each element */\n std::vector getSizes() const {\n std::vector sizes;\n for (const auto& e : elems_) {\n sizes.push_back(e.size());\n }\n return sizes;\n }\n\n inline void str(std::ostream& os, const std::vector sizes) const;\n\n std::string justify(const ColInfo& cinfo, const std::string& e, size_t w) const {\n // left pad\n std::stringstream ss;\n ss << std::setw(w) << (cinfo.justify == ColInfo::LEFT ? std::left : std::right) << e;\n auto s = ss.str();\n assert(s.size() == w);\n return s;\n }\n\npublic:\n /** add a cell to this row with the given element, returns a reference to this row */\n template \n Row& add(const T& elem) {\n std::stringstream ss;\n ss << elem;\n elems_.push_back(ss.str());\n return *this;\n }\n\n /**\n * Add a formatted cell to this row with the given element.\n * The format is a printf-style format string and any additional arguments are the format arguments.\n * Returns a reference to this row.\n */\n template \n Row& addf(const char* format, Args ... args) {\n elems_.push_back(string_format(format, args...));\n return *this;\n }\n\n /** the number of elements currently in the row */\n size_t size() {\n return elems_.size();\n }\n};\n\nclass Table {\n friend Row;\n using table_t = std::vector;\n using colinfo_t = std::vector;\n\n table_t rows_;\n colinfo_t colinfo_;\n std::string sep;\n\npublic:\n\n Table() : sep(\" \") {}\n\n /**\n * Get a reference to the ColInfo object for the given column, which lets you\n * set column-global info such as the justification.\n */\n ColInfo& colInfo(size_t col) {\n if (col >= colinfo_.size()) {\n colinfo_.resize(col + 1);\n }\n return colinfo_.at(col);\n }\n\n /* in the cost case, return a default ColInfo if it doesn't exist */\n ColInfo colInfo(size_t col) const {\n return col < colinfo_.size() ? colinfo_.at(col) : ColInfo{};\n }\n\n Row& newRow() {\n rows_.push_back(Row{*this});\n return rows_.back();\n }\n\n /** return the current representation of the table as a string */\n std::string str() const {\n\n // calculate max row sizes\n std::vector max_sizes;\n for (const auto& r : rows_) {\n std::vector sizes = r.getSizes();\n for (size_t c = 0; c < sizes.size(); c++) {\n size_t row_size = sizes[c];\n if (c >= max_sizes.size()) {\n assert(max_sizes.size() == c);\n max_sizes.push_back(row_size);\n } else {\n max_sizes[c] = std::max(max_sizes[c], row_size);\n }\n }\n }\n\n std::stringstream ss;\n for (const auto& r : rows_) {\n r.str(ss, max_sizes);\n ss << \"\\n\";\n }\n\n return ss.str();\n }\n\n void setColColumnSeparator(std::string s) {\n sep = s;\n }\n\n};\n\ninline void Row::str(std::ostream& os, const std::vector sizes) const\n{\n bool first = true;\n for (size_t c = 0; c < elems_.size(); c++) {\n const auto& e = elems_[c];\n assert(c < sizes.size());\n if (!first) os << table_->sep; // inter-cell padding\n first = false;\n os << justify(table_->colInfo(c), e, sizes[c]);\n }\n}\n\n}\n\n\n#endif /* TABLE_HPP_ */\n" }, { "path": "test/catch.hpp", "content": "/*\n * Catch v2.13.7\n * Generated: 2021-07-28 20:29:27.753164\n * ----------------------------------------------------------\n * This file has been merged from multiple headers. Please don't edit it directly\n * Copyright (c) 2021 Two Blue Cubes Ltd. All rights reserved.\n *\n * Distributed under the Boost Software License, Version 1.0. (See accompanying\n * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n */\n#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED\n#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED\n// start catch.hpp\n\n\n#define CATCH_VERSION_MAJOR 2\n#define CATCH_VERSION_MINOR 13\n#define CATCH_VERSION_PATCH 7\n\n#ifdef __clang__\n# pragma clang system_header\n#elif defined __GNUC__\n# pragma GCC system_header\n#endif\n\n// start catch_suppress_warnings.h\n\n#ifdef __clang__\n# ifdef __ICC // icpc defines the __clang__ macro\n# pragma warning(push)\n# pragma warning(disable: 161 1682)\n# else // __ICC\n# pragma clang diagnostic push\n# pragma clang diagnostic ignored \"-Wpadded\"\n# pragma clang diagnostic ignored \"-Wswitch-enum\"\n# pragma clang diagnostic ignored \"-Wcovered-switch-default\"\n# endif\n#elif defined __GNUC__\n // Because REQUIREs trigger GCC's -Wparentheses, and because still\n // supported version of g++ have only buggy support for _Pragmas,\n // Wparentheses have to be suppressed globally.\n# pragma GCC diagnostic ignored \"-Wparentheses\" // See #674 for details\n\n# pragma GCC diagnostic push\n# pragma GCC diagnostic ignored \"-Wunused-variable\"\n# pragma GCC diagnostic ignored \"-Wpadded\"\n#endif\n// end catch_suppress_warnings.h\n#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)\n# define CATCH_IMPL\n# define CATCH_CONFIG_ALL_PARTS\n#endif\n\n// In the impl file, we want to have access to all parts of the headers\n// Can also be used to sanely support PCHs\n#if defined(CATCH_CONFIG_ALL_PARTS)\n# define CATCH_CONFIG_EXTERNAL_INTERFACES\n# if defined(CATCH_CONFIG_DISABLE_MATCHERS)\n# undef CATCH_CONFIG_DISABLE_MATCHERS\n# endif\n# if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)\n# define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER\n# endif\n#endif\n\n#if !defined(CATCH_CONFIG_IMPL_ONLY)\n// start catch_platform.h\n\n// See e.g.:\n// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html\n#ifdef __APPLE__\n# include \n# if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \\\n (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)\n# define CATCH_PLATFORM_MAC\n# elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)\n# define CATCH_PLATFORM_IPHONE\n# endif\n\n#elif defined(linux) || defined(__linux) || defined(__linux__)\n# define CATCH_PLATFORM_LINUX\n\n#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)\n# define CATCH_PLATFORM_WINDOWS\n#endif\n\n// end catch_platform.h\n\n#ifdef CATCH_IMPL\n# ifndef CLARA_CONFIG_MAIN\n# define CLARA_CONFIG_MAIN_NOT_DEFINED\n# define CLARA_CONFIG_MAIN\n# endif\n#endif\n\n// start catch_user_interfaces.h\n\nnamespace Catch {\n unsigned int rngSeed();\n}\n\n// end catch_user_interfaces.h\n// start catch_tag_alias_autoregistrar.h\n\n// start catch_common.h\n\n// start catch_compiler_capabilities.h\n\n// Detect a number of compiler features - by compiler\n// The following features are defined:\n//\n// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?\n// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?\n// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?\n// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?\n// ****************\n// Note to maintainers: if new toggles are added please document them\n// in configuration.md, too\n// ****************\n\n// In general each macro has a _NO_ form\n// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.\n// Many features, at point of detection, define an _INTERNAL_ macro, so they\n// can be combined, en-mass, with the _NO_ forms later.\n\n#ifdef __cplusplus\n\n# if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)\n# define CATCH_CPP14_OR_GREATER\n# endif\n\n# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)\n# define CATCH_CPP17_OR_GREATER\n# endif\n\n#endif\n\n// Only GCC compiler should be used in this block, so other compilers trying to\n// mask themselves as GCC should be ignored.\n#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__)\n# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( \"GCC diagnostic push\" )\n# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( \"GCC diagnostic pop\" )\n\n# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)\n\n#endif\n\n#if defined(__clang__)\n\n# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( \"clang diagnostic push\" )\n# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( \"clang diagnostic pop\" )\n\n// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug\n// which results in calls to destructors being emitted for each temporary,\n// without a matching initialization. In practice, this can result in something\n// like `std::string::~string` being called on an uninitialized value.\n//\n// For example, this code will likely segfault under IBM XL:\n// ```\n// REQUIRE(std::string(\"12\") + \"34\" == \"1234\")\n// ```\n//\n// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.\n# if !defined(__ibmxl__) && !defined(__CUDACC__)\n# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */\n# endif\n\n# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \\\n _Pragma( \"clang diagnostic ignored \\\"-Wexit-time-destructors\\\"\" ) \\\n _Pragma( \"clang diagnostic ignored \\\"-Wglobal-constructors\\\"\")\n\n# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \\\n _Pragma( \"clang diagnostic ignored \\\"-Wparentheses\\\"\" )\n\n# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \\\n _Pragma( \"clang diagnostic ignored \\\"-Wunused-variable\\\"\" )\n\n# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \\\n _Pragma( \"clang diagnostic ignored \\\"-Wgnu-zero-variadic-macro-arguments\\\"\" )\n\n# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \\\n _Pragma( \"clang diagnostic ignored \\\"-Wunused-template\\\"\" )\n\n#endif // __clang__\n\n////////////////////////////////////////////////////////////////////////////////\n// Assume that non-Windows platforms support posix signals by default\n#if !defined(CATCH_PLATFORM_WINDOWS)\n #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n// We know some environments not to support full POSIX signals\n#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)\n #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS\n#endif\n\n#ifdef __OS400__\n# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS\n# define CATCH_CONFIG_COLOUR_NONE\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n// Android somehow still does not support std::to_string\n#if defined(__ANDROID__)\n# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING\n# define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n// Not all Windows environments support SEH properly\n#if defined(__MINGW32__)\n# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n// PS4\n#if defined(__ORBIS__)\n# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n// Cygwin\n#ifdef __CYGWIN__\n\n// Required for some versions of Cygwin to declare gettimeofday\n// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin\n# define _BSD_SOURCE\n// some versions of cygwin (most) do not support std::to_string. Use the libstd check.\n// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813\n# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \\\n && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))\n\n# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING\n\n# endif\n#endif // __CYGWIN__\n\n////////////////////////////////////////////////////////////////////////////////\n// Visual C++\n#if defined(_MSC_VER)\n\n# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )\n# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION __pragma( warning(pop) )\n\n// Universal Windows platform does not support SEH\n// Or console colours (or console at all...)\n# if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)\n# define CATCH_CONFIG_COLOUR_NONE\n# else\n# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH\n# endif\n\n// MSVC traditional preprocessor needs some workaround for __VA_ARGS__\n// _MSVC_TRADITIONAL == 0 means new conformant preprocessor\n// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor\n# if !defined(__clang__) // Handle Clang masquerading for msvc\n# if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)\n# define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR\n# endif // MSVC_TRADITIONAL\n# endif // __clang__\n\n#endif // _MSC_VER\n\n#if defined(_REENTRANT) || defined(_MSC_VER)\n// Enable async processing, as -pthread is specified or no additional linking is required\n# define CATCH_INTERNAL_CONFIG_USE_ASYNC\n#endif // _MSC_VER\n\n////////////////////////////////////////////////////////////////////////////////\n// Check if we are compiled with -fno-exceptions or equivalent\n#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)\n# define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n// DJGPP\n#ifdef __DJGPP__\n# define CATCH_INTERNAL_CONFIG_NO_WCHAR\n#endif // __DJGPP__\n\n////////////////////////////////////////////////////////////////////////////////\n// Embarcadero C++Build\n#if defined(__BORLANDC__)\n #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n\n// Use of __COUNTER__ is suppressed during code analysis in\n// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly\n// handled by it.\n// Otherwise all supported compilers support COUNTER macro,\n// but user still might want to turn it off\n#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )\n #define CATCH_INTERNAL_CONFIG_COUNTER\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n\n// RTX is a special version of Windows that is real time.\n// This means that it is detected as Windows, but does not provide\n// the same set of capabilities as real Windows does.\n#if defined(UNDER_RTSS) || defined(RTX64_BUILD)\n #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH\n #define CATCH_INTERNAL_CONFIG_NO_ASYNC\n #define CATCH_CONFIG_COLOUR_NONE\n#endif\n\n#if !defined(_GLIBCXX_USE_C99_MATH_TR1)\n#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER\n#endif\n\n// Various stdlib support checks that require __has_include\n#if defined(__has_include)\n // Check if string_view is available and usable\n #if __has_include() && defined(CATCH_CPP17_OR_GREATER)\n # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW\n #endif\n\n // Check if optional is available and usable\n # if __has_include() && defined(CATCH_CPP17_OR_GREATER)\n # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL\n # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER)\n\n // Check if byte is available and usable\n # if __has_include() && defined(CATCH_CPP17_OR_GREATER)\n # include \n # if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)\n # define CATCH_INTERNAL_CONFIG_CPP17_BYTE\n # endif\n # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER)\n\n // Check if variant is available and usable\n # if __has_include() && defined(CATCH_CPP17_OR_GREATER)\n # if defined(__clang__) && (__clang_major__ < 8)\n // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852\n // fix should be in clang 8, workaround in libstdc++ 8.2\n # include \n # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)\n # define CATCH_CONFIG_NO_CPP17_VARIANT\n # else\n # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT\n # endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)\n # else\n # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT\n # endif // defined(__clang__) && (__clang_major__ < 8)\n # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER)\n#endif // defined(__has_include)\n\n#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)\n# define CATCH_CONFIG_COUNTER\n#endif\n#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)\n# define CATCH_CONFIG_WINDOWS_SEH\n#endif\n// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.\n#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)\n# define CATCH_CONFIG_POSIX_SIGNALS\n#endif\n// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.\n#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)\n# define CATCH_CONFIG_WCHAR\n#endif\n\n#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)\n# define CATCH_CONFIG_CPP11_TO_STRING\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)\n# define CATCH_CONFIG_CPP17_OPTIONAL\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)\n# define CATCH_CONFIG_CPP17_STRING_VIEW\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)\n# define CATCH_CONFIG_CPP17_VARIANT\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)\n# define CATCH_CONFIG_CPP17_BYTE\n#endif\n\n#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)\n# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE\n#endif\n\n#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)\n# define CATCH_CONFIG_NEW_CAPTURE\n#endif\n\n#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)\n# define CATCH_CONFIG_DISABLE_EXCEPTIONS\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)\n# define CATCH_CONFIG_POLYFILL_ISNAN\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)\n# define CATCH_CONFIG_USE_ASYNC\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)\n# define CATCH_CONFIG_ANDROID_LOGWRITE\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)\n# define CATCH_CONFIG_GLOBAL_NEXTAFTER\n#endif\n\n// Even if we do not think the compiler has that warning, we still have\n// to provide a macro that can be used by the code.\n#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)\n# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION\n#endif\n#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)\n# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION\n#endif\n#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)\n# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS\n#endif\n#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)\n# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS\n#endif\n#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)\n# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS\n#endif\n#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)\n# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS\n#endif\n\n// The goal of this macro is to avoid evaluation of the arguments, but\n// still have the compiler warn on problems inside...\n#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)\n# define CATCH_INTERNAL_IGNORE_BUT_WARN(...)\n#endif\n\n#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)\n# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS\n#elif defined(__clang__) && (__clang_major__ < 5)\n# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS\n#endif\n\n#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)\n# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS\n#endif\n\n#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)\n#define CATCH_TRY if ((true))\n#define CATCH_CATCH_ALL if ((false))\n#define CATCH_CATCH_ANON(type) if ((false))\n#else\n#define CATCH_TRY try\n#define CATCH_CATCH_ALL catch (...)\n#define CATCH_CATCH_ANON(type) catch (type)\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)\n#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR\n#endif\n\n// end catch_compiler_capabilities.h\n#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line\n#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )\n#ifdef CATCH_CONFIG_COUNTER\n# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )\n#else\n# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )\n#endif\n\n#include \n#include \n#include \n\n// We need a dummy global operator<< so we can bring it into Catch namespace later\nstruct Catch_global_namespace_dummy {};\nstd::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);\n\nnamespace Catch {\n\n struct CaseSensitive { enum Choice {\n Yes,\n No\n }; };\n\n class NonCopyable {\n NonCopyable( NonCopyable const& ) = delete;\n NonCopyable( NonCopyable && ) = delete;\n NonCopyable& operator = ( NonCopyable const& ) = delete;\n NonCopyable& operator = ( NonCopyable && ) = delete;\n\n protected:\n NonCopyable();\n virtual ~NonCopyable();\n };\n\n struct SourceLineInfo {\n\n SourceLineInfo() = delete;\n SourceLineInfo( char const* _file, std::size_t _line ) noexcept\n : file( _file ),\n line( _line )\n {}\n\n SourceLineInfo( SourceLineInfo const& other ) = default;\n SourceLineInfo& operator = ( SourceLineInfo const& ) = default;\n SourceLineInfo( SourceLineInfo&& ) noexcept = default;\n SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;\n\n bool empty() const noexcept { return file[0] == '\\0'; }\n bool operator == ( SourceLineInfo const& other ) const noexcept;\n bool operator < ( SourceLineInfo const& other ) const noexcept;\n\n char const* file;\n std::size_t line;\n };\n\n std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );\n\n // Bring in operator<< from global namespace into Catch namespace\n // This is necessary because the overload of operator<< above makes\n // lookup stop at namespace Catch\n using ::operator<<;\n\n // Use this in variadic streaming macros to allow\n // >> +StreamEndStop\n // as well as\n // >> stuff +StreamEndStop\n struct StreamEndStop {\n std::string operator+() const;\n };\n template\n T const& operator + ( T const& value, StreamEndStop ) {\n return value;\n }\n}\n\n#define CATCH_INTERNAL_LINEINFO \\\n ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) )\n\n// end catch_common.h\nnamespace Catch {\n\n struct RegistrarForTagAliases {\n RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );\n };\n\n} // end namespace Catch\n\n#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \\\n CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \\\n CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \\\n namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \\\n CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION\n\n// end catch_tag_alias_autoregistrar.h\n// start catch_test_registry.h\n\n// start catch_interfaces_testcase.h\n\n#include \n\nnamespace Catch {\n\n class TestSpec;\n\n struct ITestInvoker {\n virtual void invoke () const = 0;\n virtual ~ITestInvoker();\n };\n\n class TestCase;\n struct IConfig;\n\n struct ITestCaseRegistry {\n virtual ~ITestCaseRegistry();\n virtual std::vector const& getAllTests() const = 0;\n virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0;\n };\n\n bool isThrowSafe( TestCase const& testCase, IConfig const& config );\n bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );\n std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config );\n std::vector const& getAllTestCasesSorted( IConfig const& config );\n\n}\n\n// end catch_interfaces_testcase.h\n// start catch_stringref.h\n\n#include \n#include \n#include \n#include \n\nnamespace Catch {\n\n /// A non-owning string class (similar to the forthcoming std::string_view)\n /// Note that, because a StringRef may be a substring of another string,\n /// it may not be null terminated.\n class StringRef {\n public:\n using size_type = std::size_t;\n using const_iterator = const char*;\n\n private:\n static constexpr char const* const s_empty = \"\";\n\n char const* m_start = s_empty;\n size_type m_size = 0;\n\n public: // construction\n constexpr StringRef() noexcept = default;\n\n StringRef( char const* rawChars ) noexcept;\n\n constexpr StringRef( char const* rawChars, size_type size ) noexcept\n : m_start( rawChars ),\n m_size( size )\n {}\n\n StringRef( std::string const& stdString ) noexcept\n : m_start( stdString.c_str() ),\n m_size( stdString.size() )\n {}\n\n explicit operator std::string() const {\n return std::string(m_start, m_size);\n }\n\n public: // operators\n auto operator == ( StringRef const& other ) const noexcept -> bool;\n auto operator != (StringRef const& other) const noexcept -> bool {\n return !(*this == other);\n }\n\n auto operator[] ( size_type index ) const noexcept -> char {\n assert(index < m_size);\n return m_start[index];\n }\n\n public: // named queries\n constexpr auto empty() const noexcept -> bool {\n return m_size == 0;\n }\n constexpr auto size() const noexcept -> size_type {\n return m_size;\n }\n\n // Returns the current start pointer. If the StringRef is not\n // null-terminated, throws std::domain_exception\n auto c_str() const -> char const*;\n\n public: // substrings and searches\n // Returns a substring of [start, start + length).\n // If start + length > size(), then the substring is [start, size()).\n // If start > size(), then the substring is empty.\n auto substr( size_type start, size_type length ) const noexcept -> StringRef;\n\n // Returns the current start pointer. May not be null-terminated.\n auto data() const noexcept -> char const*;\n\n constexpr auto isNullTerminated() const noexcept -> bool {\n return m_start[m_size] == '\\0';\n }\n\n public: // iterators\n constexpr const_iterator begin() const { return m_start; }\n constexpr const_iterator end() const { return m_start + m_size; }\n };\n\n auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;\n auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;\n\n constexpr auto operator \"\" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {\n return StringRef( rawChars, size );\n }\n} // namespace Catch\n\nconstexpr auto operator \"\" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {\n return Catch::StringRef( rawChars, size );\n}\n\n// end catch_stringref.h\n// start catch_preprocessor.hpp\n\n\n#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__\n#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))\n#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))\n#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))\n#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))\n#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))\n\n#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR\n#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__\n// MSVC needs more evaluations\n#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))\n#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))\n#else\n#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__)\n#endif\n\n#define CATCH_REC_END(...)\n#define CATCH_REC_OUT\n\n#define CATCH_EMPTY()\n#define CATCH_DEFER(id) id CATCH_EMPTY()\n\n#define CATCH_REC_GET_END2() 0, CATCH_REC_END\n#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2\n#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1\n#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT\n#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)\n#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)\n\n#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )\n#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )\n#define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )\n\n#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__ )\n#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__ )\n#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__ )\n\n// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,\n// and passes userdata as the first parameter to each invocation,\n// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)\n#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))\n\n#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))\n\n#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)\n#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__\n#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__\n#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF\n#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)\n#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR\n#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__\n#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))\n#else\n// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF\n#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)\n#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__\n#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)\n#endif\n\n#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__\n#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)\n\n#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)\n\n#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR\n#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper())\n#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))\n#else\n#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper()))\n#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))\n#endif\n\n#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\\\n CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)\n\n#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)\n#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)\n#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)\n#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)\n#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)\n#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)\n#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)\n#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)\n#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)\n#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)\n#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)\n\n#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N\n\n#define INTERNAL_CATCH_TYPE_GEN\\\n template struct TypeList {};\\\n template\\\n constexpr auto get_wrapper() noexcept -> TypeList { return {}; }\\\n template class...> struct TemplateTypeList{};\\\n template class...Cs>\\\n constexpr auto get_wrapper() noexcept -> TemplateTypeList { return {}; }\\\n template\\\n struct append;\\\n template\\\n struct rewrap;\\\n template class, typename...>\\\n struct create;\\\n template class, typename>\\\n struct convert;\\\n \\\n template \\\n struct append { using type = T; };\\\n template< template class L1, typename...E1, template class L2, typename...E2, typename...Rest>\\\n struct append, L2, Rest...> { using type = typename append, Rest...>::type; };\\\n template< template class L1, typename...E1, typename...Rest>\\\n struct append, TypeList, Rest...> { using type = L1; };\\\n \\\n template< template class Container, template class List, typename...elems>\\\n struct rewrap, List> { using type = TypeList>; };\\\n template< template class Container, template class List, class...Elems, typename...Elements>\\\n struct rewrap, List, Elements...> { using type = typename append>, typename rewrap, Elements...>::type>::type; };\\\n \\\n template