├── HotPatch
    ├── CMakeLists.txt
    └── hotpatch.cpp
├── AsmExecute
    ├── CMakeLists.txt
    └── asmexecute.cpp
├── Cordic
    ├── benchmark.png
    ├── CMakeLists.txt
    ├── bit_test.cpp
    ├── functions.h
    ├── benchmark.cpp
    └── functions.cpp
├── FieldExtract
    ├── CMakeLists.txt
    ├── README.md
    ├── AsmCopyGen.h
    ├── AsmUtils.cpp
    ├── AsmUtils.h
    ├── AsmCopyGen.cpp
    └── selectfields.cpp
├── DivTests
    ├── CMakeLists.txt
    ├── libdiv.cpp
    └── testdiv.cpp
├── Calculator
    ├── CMakeLists.txt
    ├── Node.h
    ├── Writer.h
    ├── Predicates.h
    ├── calculator.cpp
    ├── FunctionOps.h
    ├── Pointer.h
    ├── TreeNodes.h
    ├── Lexer.h
    └── Calculator.h
├── CMakeLists.txt
├── CompileTimeSwitch
    ├── functions.h
    ├── caller_trivial.cpp
    ├── codegen.py
    ├── functions.cpp
    ├── Codegen.cmake
    ├── utils.h
    ├── switch.mako.cpp
    ├── caller_fred2.cpp
    ├── caller_caleth.cpp
    ├── caller_fred.cpp
    ├── CMakeLists.txt
    └── main.cpp
├── .clang-tidy
├── .clang-format
├── Target
    ├── main.cpp
    ├── README.md
    ├── functions.cpp
    ├── CMakeLists.txt
    ├── simple.cpp
    └── bench.cpp
├── .gitignore
├── README.md
├── CacheCheck
    ├── CMakeLists.txt
    ├── testcopy.cpp
    ├── testCycles.cpp
    └── testTrash.cpp
├── BenchmarkPatch
    ├── main.cpp
    ├── CMakeLists.txt
    └── compile_benchmark_results.py
└── LICENSE


/HotPatch/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | add_executable( hotpatch hotpatch.cpp )


--------------------------------------------------------------------------------
/AsmExecute/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | add_executable( asmexecute asmexecute.cpp )


--------------------------------------------------------------------------------
/Cordic/benchmark.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HFTrader/AssemblyTales/HEAD/Cordic/benchmark.png


--------------------------------------------------------------------------------
/FieldExtract/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | add_executable( selectfields selectfields.cpp AsmCopyGen.cpp AsmUtils.cpp )


--------------------------------------------------------------------------------
/DivTests/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | add_library( libdiv SHARED libdiv.cpp )
2 | add_executable( testdiv testdiv.cpp )
3 | target_link_libraries( testdiv libdiv )


--------------------------------------------------------------------------------
/Calculator/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | cmake_minimum_required( VERSION 3.12 )
2 | project(calculator)
3 | 
4 | set( CMAKE_CXX_STANDARD 17 )
5 | 
6 | add_executable( calculator calculator.cpp )


--------------------------------------------------------------------------------
/FieldExtract/README.md:
--------------------------------------------------------------------------------
1 | Documentation for this project is covered in these articles:
2 | 
3 | http://www.vitorian.com/archives/2186
4 | 
5 | http://www.vitorian.com/archives/2208
6 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | project(AssemblyTales)
2 | cmake_minimum_required(VERSION 3.2)
3 | 
4 | add_subdirectory( FieldExtract )
5 | add_subdirectory( HotPatch )
6 | add_subdirectory( DivTests )
7 | add_subdirectory( AsmExecute )
8 | 


--------------------------------------------------------------------------------
/CompileTimeSwitch/functions.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <cstdint>
 3 | #include <cstddef>
 4 | #include <vector>
 5 | 
 6 | struct Function {
 7 |     void* fnptr;
 8 |     size_t numargs;
 9 | };
10 | 
11 | extern std::vector<Function> fntable;


--------------------------------------------------------------------------------
/Cordic/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | cmake_minimum_required( VERSION 3.0 )
2 | project( cordic )
3 | 
4 | find_package( benchmark REQUIRED )
5 | add_executable( bit_test bit_test.cpp functions.cpp )
6 | 
7 | add_executable( benchmark benchmark.cpp functions.cpp )
8 | target_link_libraries( benchmark benchmark::benchmark )
9 | 


--------------------------------------------------------------------------------
/CompileTimeSwitch/caller_trivial.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdint>
 2 | #include <cstddef>
 3 | #include <vector>
 4 | #include <array>
 5 | #include <iostream>
 6 | #include <memory>
 7 | #include <limits>
 8 | 
 9 | #include "functions.h"
10 | 
11 | namespace trivial {
12 | 
13 | struct trivial {
14 |     static double callfn(void* fn, const std::vector<double>& args);
15 | };
16 | 
17 | }


--------------------------------------------------------------------------------
/.clang-tidy:
--------------------------------------------------------------------------------
1 | ---
2 | Checks:          '-*,clang-diagnostic-*,-clang-diagnostic-unused-value,clang-analyzer-*,-*,bugprone-*,performance-*,readability-*,-readability-magic-numbers,-readability-braces-around-statements,-readability-inconsistent-declaration-parameter-name,-readability-named-parameter'
3 | HeaderFilterRegex: ''
4 | WarningsAsErrors: '*'
5 | AnalyzeTemporaryDtors: false
6 | ...
7 | 


--------------------------------------------------------------------------------
/CompileTimeSwitch/codegen.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | import sys, os
 3 | from mako.template import Template
 4 | 
 5 | if len(sys.argv)<2: 
 6 |     print( "Usage: codegen.py <template> [args...]")
 7 |     sys.exit(0)
 8 | 
 9 | template = sys.argv[1]
10 | argv = sys.argv[2:]
11 | contents = open( template ).read()
12 | print(Template(contents).render(argv=argv,template=template))
13 | 


--------------------------------------------------------------------------------
/.clang-format:
--------------------------------------------------------------------------------
 1 | ---
 2 | Language:        Cpp
 3 | BasedOnStyle:  Google
 4 | AccessModifierOffset: -4
 5 | AllowShortBlocksOnASingleLine: false
 6 | AllowShortFunctionsOnASingleLine: false
 7 | AllowShortCaseLabelsOnASingleLine: true
 8 | AlwaysBreakTemplateDeclarations: true
 9 | ColumnLimit:     120
10 | IndentWidth:     4
11 | SortIncludes:    false
12 | TabWidth:        4
13 | UseTab:          Never
14 | ...
15 | 
16 | 


--------------------------------------------------------------------------------
/FieldExtract/AsmCopyGen.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <vector>
 3 | #include <cstdint>
 4 | 
 5 | class AsmCopyGen
 6 | {
 7 | public:
 8 |     using Bytes = std::vector<uint8_t>;
 9 |     void copyField(uint32_t source, uint32_t target, uint32_t size);
10 |     Bytes getBytes();
11 | 
12 | private:
13 |     Bytes bytes;
14 |     void insert(const std::initializer_list<uint8_t> &v)
15 |     {
16 |         bytes.insert(bytes.end(), v.begin(), v.end());
17 |     }
18 | };
19 | 


--------------------------------------------------------------------------------
/CompileTimeSwitch/functions.cpp:
--------------------------------------------------------------------------------
 1 | #include "functions.h"
 2 | 
 3 | double sum1(double a, double b, double c) {
 4 |     return a + b + c;
 5 | }
 6 | 
 7 | double sum2(double a, double b, double c, double d) {
 8 |     return a + b + c + d;
 9 | }
10 | 
11 | double sum3(double a, double b) {
12 |     return a + b;
13 | }
14 | 
15 | double sum4() {
16 |     return 10;
17 | }
18 | 
19 | std::vector<Function> fntable = {
20 |     {(void*)&sum1, 3}, {(void*)&sum2, 4}, {(void*)&sum3, 2}, {(void*)&sum4, 0}};
21 | 


--------------------------------------------------------------------------------
/Calculator/Node.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Pointer.h"
 4 | 
 5 | namespace Interpreter {
 6 | 
 7 | struct Node;
 8 | 
 9 | struct Visitor : public RefCounted {
10 |     virtual void visit(Node*) = 0;
11 | };
12 | 
13 | struct Node : public RefCounted {
14 |     using RefCounted::RefCounted;
15 |     virtual ~Node() {
16 |     }
17 |     virtual double calc() = 0;
18 |     virtual void visit(Visitor& visitor) {
19 |         visitor.visit(this);
20 |     }
21 | };
22 | 
23 | }  // namespace Interpreter


--------------------------------------------------------------------------------
/Target/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <array>
 2 | #include <cstdio>
 3 | 
 4 | using Vector = std::array<float, 2>;
 5 | using Matrix = std::array<float, 4>;
 6 | 
 7 | __attribute__((target_clones("default", "arch=core2", "arch=sandybridge", "arch=haswell", "arch=cascadelake",
 8 |                              "arch=znver1", "arch=znver2"))) Vector
 9 | multiply(const Matrix& m, const Vector& v);
10 | 
11 | int main() {
12 |     Vector v{1, 2};
13 |     Matrix m{3, 4, 5, 6};
14 |     Vector r = multiply(m, v);
15 |     printf("%f %f\n", r[0], r[1]);
16 | }


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | #emacs
 5 | *~
 6 | 
 7 | # dummy out
 8 | x.x
 9 | x.y
10 | x.z
11 | 
12 | # Compiled Object files
13 | *.slo
14 | *.lo
15 | *.o
16 | *.obj
17 | 
18 | # Precompiled Headers
19 | *.gch
20 | *.pch
21 | 
22 | # Compiled Dynamic libraries
23 | *.so
24 | *.dylib
25 | *.dll
26 | 
27 | # Fortran module files
28 | *.mod
29 | *.smod
30 | 
31 | # Compiled Static libraries
32 | *.lai
33 | *.la
34 | *.a
35 | *.lib
36 | 
37 | # Executables
38 | *.exe
39 | *.out
40 | *.app
41 | 
42 | # cmake
43 | build
44 | install
45 | .vscode
46 | 


--------------------------------------------------------------------------------
/FieldExtract/AsmUtils.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstddef>
 2 | #include <cstdint>
 3 | #include <unistd.h>
 4 | #include <sys/mman.h>
 5 | 
 6 | // Makes the memory pointed executable
 7 | void makeExecutable(void *code, size_t size)
 8 | {
 9 |     size_t pagesize = getpagesize();
10 |     uint64_t codeaddr = uint64_t(code);
11 |     uint64_t offset = codeaddr % pagesize;
12 |     codeaddr -= offset;
13 |     size += offset;
14 |     size_t codesize = ((size - 1) / pagesize + 1) * pagesize;
15 |     mprotect((void *)codeaddr, codesize, PROT_READ | PROT_WRITE | PROT_EXEC);
16 | }
17 | 


--------------------------------------------------------------------------------
/CompileTimeSwitch/Codegen.cmake:
--------------------------------------------------------------------------------
 1 | macro( codegen input_file output_file args )
 2 | file(REAL_PATH ${input_file} infile BASE_DIRECTORY ${CMAKE_SOURCE_DIR} )
 3 | file(REAL_PATH ${output_file} outfile BASE_DIRECTORY ${CMAKE_BINARY_DIR} )
 4 | message( "Writing rules to expand ${infile} to ${outfile}")
 5 | set( GENCOMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/codegen.py  
 6 |                 ${infile} ${args} > ${outfile} )
 7 | add_custom_command(
 8 |         COMMAND ${GENCOMMAND}
 9 |         DEPENDS ${CMAKE_SOURCE_DIR}/codegen.py ${infile}
10 |         OUTPUT  ${outfile} 
11 |         COMMENT "Expanding Mako template ${infile} to ${outfile}" )
12 | endmacro()


--------------------------------------------------------------------------------
/Calculator/Writer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TreeNodes.h"
 3 | #include <vector>
 4 | #include <cstring>
 5 | #include <cstdio>
 6 | 
 7 | namespace Interpreter {
 8 | 
 9 | struct Writer : public Visitor {
10 |     std::vector<char> data;
11 |     void visit(Node*) override {
12 |     }
13 |     void write(double value) {
14 |         char buf[64];
15 |         ::snprintf(buf, sizeof(buf), "%f", value);
16 |         write(buf);
17 |     }
18 |     void write(std::string_view sv) {
19 |         size_t size = data.size();
20 |         data.resize(size + sv.size());
21 |         memcpy(&data[size], sv.data(), sv.size());
22 |     }
23 | };
24 | 
25 | }  // namespace Interpreter


--------------------------------------------------------------------------------
/Cordic/bit_test.cpp:
--------------------------------------------------------------------------------
 1 | #include "functions.h"
 2 | #include <vector>
 3 | #include <iostream>
 4 | 
 5 | int main() {
 6 |     int N = 512;
 7 |     int freq = 1;
 8 |     std::vector<int64_t> samples1(N);
 9 |     trivial(samples1.data(), freq, samples1.size());
10 |     std::vector<int64_t> samples2(N);
11 |     bitcalc(samples2.data(), freq, samples2.size());
12 |     std::vector<int64_t> samples3(N);
13 |     cordic(samples3.data(), freq, samples3.size());
14 | 
15 |     for (int j = 0; j < N; ++j) {
16 |         double phase = double(360 * j) / N;
17 |         printf("%-4d,%6.1f,%6ld,%6ld,%6ld\n", j, phase, samples1[j], samples2[j],
18 |                samples3[j]);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/CompileTimeSwitch/utils.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <cstdint>
 3 | 
 4 | static inline uint64_t tic() {
 5 |     uint64_t tsc;
 6 |     asm volatile(
 7 |         "MFENCE\n\t"
 8 |         "LFENCE\n\t"
 9 |         "RDTSC\n\t"
10 |         "salq $32,   %%rdx\n\t"
11 |         "orq  %%rdx, %%rax\n\t"
12 |         : "=a"(tsc)
13 |         :
14 |         : "%rdx");
15 |     return tsc;
16 | }
17 | 
18 | static inline uint64_t toc() {
19 |     uint64_t tsc;
20 |     asm volatile(
21 |         "LFENCE\n\t"
22 |         "RDTSC\n\t"
23 |         "salq $32, %%rdx\n\t"
24 |         "orq %%rdx,%%rax\n\t"
25 |         : "=a"(tsc)
26 |         :
27 |         : "%rdx", "%rcx");
28 |     return tsc;
29 | }
30 | 


--------------------------------------------------------------------------------
/Target/README.md:
--------------------------------------------------------------------------------
 1 | # Substack post
 2 | 
 3 | This repo refers to the following substack post
 4 | https://lucisqr.substack.com/p/clanggcc-target-attributes
 5 | 
 6 | # Compiling with cmake
 7 | 
 8 | ```
 9 | $ mkdir build && cd build
10 | $ cmake -DCMAKE_BUILD_TYPE=release \
11 |         -DCMAKE_CXX_COMPILER=clang++ \
12 |         -DCMAKE_CXX_RELEASE_FLAGS_INIT="-march=x86-64" \
13 |         ..
14 | $ make
15 | ```
16 | 
17 | # Compiling by hand
18 | ```
19 | $ clang++ -O3 -march=x86-64 simple.cpp -o simple
20 | $ clang++ -O3 -march=x86-64 main.cpp functions.cpp -o main
21 | $ clang++ -O3 -march=skylake bench.cpp functions.cpp -o bench
22 | ```
23 | 
24 | # Disassembling
25 | ```
26 | objdump -dC naive
27 | ```
28 | 


--------------------------------------------------------------------------------
/Target/functions.cpp:
--------------------------------------------------------------------------------
 1 | #include <array>
 2 | #include <cstdio>
 3 | 
 4 | using Vector = std::array<float, 2>;
 5 | using Matrix = std::array<float, 4>;
 6 | 
 7 | Vector multiply_standard(const Matrix& m, const Vector& v) {
 8 |     Vector r;
 9 |     r[0] = v[0] * m[0] + v[1] * m[2];
10 |     r[1] = v[0] * m[1] + v[1] * m[3];
11 |     return r;
12 | }
13 | 
14 | __attribute__((target_clones("default", "arch=core2", "arch=sandybridge", "arch=haswell", "arch=cascadelake",
15 |                              "arch=znver1", "arch=znver2"))) Vector
16 | multiply(const Matrix& m, const Vector& v) {
17 |     Vector r;
18 |     r[0] = v[0] * m[0] + v[1] * m[2];
19 |     r[1] = v[0] * m[1] + v[1] * m[3];
20 |     return r;
21 | }
22 | 


--------------------------------------------------------------------------------
/Cordic/functions.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <cstdint>
 3 | 
 4 | // Note that it is IMPERATIVE not to bring the
 5 | // implementation into the header otherwise
 6 | // the benchmark will be skewed with respect to
 7 | // inlining
 8 | 
 9 | void trivial(int64_t* samples, double freq, int N);
10 | void cordic(int64_t* samples, double freq, int N);
11 | void bitcalc(int64_t* samples, double freq, int N);
12 | 
13 | // The template versions are explicitly implemented
14 | // for 512, 32768 and 262144 in functions.cpp
15 | template <int N>
16 | void bitcalc(int64_t* samples, double freq);
17 | template <int N>
18 | void cordic(int64_t* samples, double freq);
19 | template <int N>
20 | void trivial(int64_t* samples, double freq);
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # AssemblyTales
 2 | 
 3 | Collection of random tidbits about assembly, mostly on x86_64 Linux. 
 4 | 
 5 | Tested on Ubuntu but should work with any modern compiler on Linux.
 6 | 
 7 | ## AsmExecute
 8 | 
 9 | Shows how to execute a custom assembly routine without compiling.
10 | 
11 | ## DivTests
12 | 
13 | (Still incomplete)
14 | 
15 | Several tests with optimizations for division and checking multiples
16 | 
17 | ## FieldExtract
18 | 
19 | (2022/01/01) Discuss on how generated assembly x86_64 can be used to improve access times to fields sparse within a large message
20 | 
21 | http://www.vitorian.com/archives/2186
22 | 
23 | http://www.vitorian.com/archives/2208
24 | 
25 | ## HotPatch
26 | 
27 | Shows how to perform "hotpatching"  on Linux x86_64
28 | 
29 | 


--------------------------------------------------------------------------------
/FieldExtract/AsmUtils.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <cstddef>
 3 | #include <cstdint>
 4 | 
 5 | static inline uint64_t now() {
 6 |     return __builtin_ia32_rdtsc();
 7 | }
 8 | 
 9 | static inline uint64_t tic() {
10 |     uint64_t ticks;
11 |     asm volatile(
12 |         "lfence\n\t"
13 |         "rdtsc\n\t"
14 |         "shl $32, %%rdx\n\t"
15 |         "or %%rdx, %0\n\t"
16 |         "lfence"
17 |         : "=a"(ticks)
18 |         :
19 |         : "rdx", "memory", "cc");
20 |     return ticks;
21 | }
22 | 
23 | static inline uint64_t toc() {
24 |     uint64_t ticks;
25 |     asm volatile(
26 |         "rdtscp\n\t"
27 |         "shl $32, %%rdx\n\t"
28 |         "or %%rdx, %0\n\t"
29 |         "lfence"
30 |         : "=a"(ticks)
31 |         :
32 |         : "rcx", "rdx", "memory", "cc");
33 |     return ticks;
34 | }
35 | 
36 | void makeExecutable(void *code, size_t size);
37 | 


--------------------------------------------------------------------------------
/CacheCheck/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required( VERSION 3.0 )
 2 | project( cache )
 3 | 
 4 | set( CMAKE_CXX_STANDARD 20 )
 5 | 
 6 | add_executable( testcopy testcopy.cpp )
 7 | 
 8 | 
 9 | include( FetchContent )
10 | set( TINYPERF_BUILD_TESTS OFF CACHE INTERNAL "")
11 | FetchContent_Declare( tinyperf GIT_REPOSITORY https://github.com/HFTrader/tiny-cpp-perf-stats.git )
12 | FetchContent_Declare( benchmark GIT_REPOSITORY https://github.com/google/benchmark.git GIT_TAG main )
13 | FetchContent_MakeAvailable( tinyperf benchmark )
14 | 
15 | find_package( Boost REQUIRED COMPONENTS thread )
16 | 
17 | #find_package( benchmark REQUIRED )
18 | 
19 | add_executable( testTrash testTrash.cpp )
20 | target_link_libraries( testTrash pthread benchmark::benchmark Boost::thread tinyperfstats )
21 | 
22 | add_executable( testCycles testCycles.cpp )
23 | target_link_libraries( testCycles  benchmark::benchmark)


--------------------------------------------------------------------------------
/Target/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | ################################################################################
 2 | # Substack post: 
 3 | #     https://lucisqr.substack.com/p/clanggcc-target-attributes
 4 | ################################################################################
 5 | 
 6 | cmake_minimum_required( VERSION 3.0 )
 7 | project( target )
 8 | enable_language( C CXX ASM )
 9 | 
10 | # we dont need all the benchmark internal testing
11 | set( BENCHMARK_ENABLE_TESTING OFF CACHE STRING "")
12 | include( FetchContent )
13 | FetchContent_Declare( benchmark 
14 |     GIT_REPOSITORY https://github.com/google/benchmark.git 
15 |     GIT_TAG main )
16 | FetchContent_MakeAvailable( benchmark )
17 | 
18 | add_library( functions SHARED functions.cpp )
19 | add_executable( main main.cpp)
20 | target_link_libraries( main functions )
21 | 
22 | add_executable( bench bench.cpp )
23 | target_link_libraries( bench functions benchmark )
24 | 
25 | add_executable( simple simple.cpp )
26 | 
27 | 


--------------------------------------------------------------------------------
/CompileTimeSwitch/switch.mako.cpp:
--------------------------------------------------------------------------------
 1 | <%
 2 | import os
 3 | from datetime import datetime
 4 | MAXARGS=int(argv[0])
 5 | today=datetime.strftime( datetime.now(), "%Y-%m-%d %H:%M:%S"  )
 6 | def genargs(n): 
 7 |     return ",".join([ "args[%d]" % j for j in range(n) ])
 8 | %>
 9 | 
10 | /** 
11 |  * Generated:  ${today}
12 |  * Arguments:  ${" ".join(argv)}
13 |  */
14 | 
15 | #include <vector>
16 | #include <limits>
17 | 
18 | namespace trivial {
19 | 
20 | template <size_t N, typename... Args>
21 | struct FnType {
22 |     using Call = typename FnType<N - 1, double, Args...>::Call;
23 | };
24 | 
25 | template <typename... Args>
26 | struct FnType<0, Args...> {
27 |     typedef double (*Call)(Args...);
28 | };
29 | 
30 | double callfn(void* fn, const std::vector<double>& args) {
31 |     switch (args.size()) {
32 | % for row in range(MAXARGS+1):
33 |         case ${row}: return FnType<${row}>::Call(fn)(${genargs(row)}); break;
34 | % endfor
35 |     }
36 |     return std::numeric_limits<double>::quiet_NaN();
37 | }
38 | 
39 | } // namespace trivial
40 | 


--------------------------------------------------------------------------------
/BenchmarkPatch/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <array>
 2 | #include <cstdio>
 3 | #include <random>
 4 | #include "benchmark/benchmark.h"
 5 | 
 6 | void Empty(benchmark::State& state) {
 7 |     for (auto _ : state) {
 8 |     }
 9 | }
10 | 
11 | void ClobberMemory(benchmark::State& state) {
12 |     for (auto _ : state) {
13 |         benchmark::ClobberMemory();
14 |     }
15 | }
16 | 
17 | std::random_device rd;
18 | std::mt19937 g(rd());
19 | std::uniform_int_distribution<int64_t> dist(1, 100);
20 | 
21 | using Vector = std::array<float, 2>;
22 | using Matrix = std::array<float, 4>;
23 | 
24 | Vector multiply(const Matrix& m, const Vector& v) {
25 |     Vector r;
26 |     r[0] = v[0] * m[0] + v[1] * m[2];
27 |     r[1] = v[0] * m[1] + v[1] * m[3];
28 |     return r;
29 | }
30 | 
31 | void VecMultiply(benchmark::State& state) {
32 |     Vector v;
33 |     Matrix m;
34 |     for (float& value : v) value = dist(g);
35 |     for (float& value : m) value = dist(g);
36 |     for (auto _ : state) {
37 |         Vector result = multiply(m, v);
38 |         benchmark::DoNotOptimize(result);
39 |     }
40 | }
41 | 
42 | BENCHMARK(Empty);
43 | BENCHMARK(ClobberMemory);
44 | BENCHMARK(VecMultiply);
45 | 
46 | BENCHMARK_MAIN();
47 | 


--------------------------------------------------------------------------------
/CompileTimeSwitch/caller_fred2.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdint>
 2 | #include <cstddef>
 3 | #include <vector>
 4 | #include <array>
 5 | #include <iostream>
 6 | #include <memory>
 7 | 
 8 | namespace fred2 {
 9 | 
10 | typedef double (*CallType)(void* fn, const double* ptr);
11 | 
12 | template <size_t>
13 | using double_t = double;
14 | 
15 | template <size_t... Is>
16 | double execute(void* fn, const double* args, std::index_sequence<Is...>) {
17 |     using CallTypeN = double (*)(double_t<Is>...);
18 |     return CallTypeN(fn)(args[Is]...);
19 | }
20 | 
21 | template< size_t N >
22 | double execute( void* fn, const double* args ) {
23 |     return execute( fn, args, std::make_index_sequence<N>{});
24 | }
25 | 
26 | template <std::size_t N>
27 | struct Switch {
28 |     std::array<CallType, N> fn;
29 |     template <std::size_t... Is>
30 |     static void init(std::index_sequence<Is...> s,
31 |                         std::array<CallType, N>& fn) {
32 |         ((fn[Is] = &execute<Is>), ...);
33 |     }
34 |     Switch() {
35 |         init(std::make_index_sequence<N>{}, fn);
36 |     }
37 | };
38 | 
39 | double callfn(void* fn, const std::vector<double>& args) {
40 |     static Switch<MAXARGS> sw;
41 |     return sw.fn[args.size()](fn, args.data());
42 | }
43 | 
44 | }  // namespace fred2
45 | 


--------------------------------------------------------------------------------
/HotPatch/hotpatch.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <string>
 4 | #include <iostream>
 5 | #include <stdlib.h>
 6 | #include <unistd.h>
 7 | #include <sys/mman.h>
 8 | #include <string.h>
 9 | 
10 | // Makes the memory pointed executable
11 | void makeWritable(void *code, size_t size)
12 | {
13 |     size_t pagesize = getpagesize();
14 |     uint64_t codeaddr = uint64_t(code);
15 |     uint64_t offset = codeaddr % pagesize;
16 |     codeaddr -= offset;
17 |     size += offset;
18 |     size_t codesize = ((size - 1) / pagesize + 1) * pagesize;
19 |     mprotect((void *)codeaddr, codesize, PROT_READ | PROT_WRITE | PROT_EXEC);
20 | }
21 | 
22 | extern "C"
23 | {
24 |     extern int mul2(int, int);
25 | };
26 | 
27 | asm(R"(
28 | .globl mul2
29 | .type mul2, @function
30 | mul2:
31 | .zero 8
32 | )");
33 | 
34 | int main()
35 | {
36 |     // Assembly
37 |     uint8_t code[] =
38 |         {
39 |             0x89, 0xf8,       // mov eax, edi
40 |             0x0f, 0xaf, 0xc6, // imul eax, esi
41 |             0xc3              // ret
42 |         };
43 | 
44 |     // Patch function
45 |     makeWritable((void *)mul2, sizeof(code));
46 |     memcpy((void *)mul2, code, sizeof(code));
47 | 
48 |     // Execute
49 |     std::cout << "Result of 2x3=" << mul2(2, 3) << std::endl;
50 |     return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/DivTests/libdiv.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdint>
 2 | 
 3 | bool empty( uint64_t j ) {
 4 |     return true;
 5 | }
 6 | 
 7 | bool is_multiple_of_3( uint64_t j ) {
 8 |     return ( uint32_t(j)%3==0 );
 9 | }
10 | 
11 | bool is_multiple_of_3_optimized( uint64_t j ) {
12 |     uint32_t i = (uint32_t)j;
13 |     return  (i * (-1u/3+1) <= -1u/3);
14 | }
15 | 
16 | uint64_t tsc_start()
17 | {
18 |     uint64_t cycles_high, cycles_low;
19 |     asm volatile ( "xor %%eax,%%eax\n\t"
20 |                    "CPUID\n\t"
21 |                    "RDTSC\n\t"
22 |                    "mov %%rdx, %0\n\t"
23 |                    "mov %%rax, %1\n\t":
24 |                    "=r" ( cycles_high ), "=r" ( cycles_low ):
25 |                    : "%rax", "%rbx", "%rcx", "%rdx" );
26 |     return ( ( ( uint64_t )cycles_high )<<32 )  | ( ( uint64_t )cycles_low );
27 | }
28 | 
29 | uint64_t tsc_stop()
30 | {
31 |     uint64_t cycles_high, cycles_low;
32 |     asm volatile( "RDTSCP\n\t"
33 |                   "mov %%rdx, %0\n\t"
34 |                   "mov %%rax, %1\n\t"
35 |                   "xor %%eax,%%eax\n\t"
36 |                   "CPUID\n\t": "=r" ( cycles_high ), "=r"
37 |                   ( cycles_low ):: "%rax", "%rbx", "%rcx", "%rdx" );
38 |     return ( ( ( uint64_t )cycles_high )<<32 )  | ( ( uint64_t )cycles_low );
39 | }
40 | 


--------------------------------------------------------------------------------
/AsmExecute/asmexecute.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | #include <string>
 4 | #include <iostream>
 5 | #include <stdlib.h>
 6 | #include <unistd.h>
 7 | #include <sys/mman.h>
 8 | #include <string.h>
 9 | 
10 | // Makes the memory pointed executable
11 | void makeExecutable(void *code, size_t size)
12 | {
13 |     size_t pagesize = getpagesize();
14 |     uint64_t codeaddr = uint64_t(code);
15 |     uint64_t offset = codeaddr % pagesize;
16 |     codeaddr -= offset;
17 |     size += offset;
18 |     size_t codesize = ((size - 1) / pagesize + 1) * pagesize;
19 |     mprotect((void *)codeaddr, codesize, PROT_READ | PROT_WRITE | PROT_EXEC);
20 | }
21 | 
22 | int main()
23 | {
24 |     // The "generated" assembly code
25 |     uint8_t code[] = {0x89, 0xf8,       // mov eax, edi
26 |                       0x0f, 0xaf, 0xc6, // imul eax, esi
27 |                       0xc3};            // ret
28 |     makeExecutable(code, sizeof(code));
29 | 
30 |     // Defines a pointer to a function that takes two integers
31 |     // and returns one integer
32 |     using multifn = int(int a, int b);
33 |     multifn *m = reinterpret_cast<multifn *>(code);
34 | 
35 |     // Execute code
36 |     std::cout << "Result:" << m(2, 3) << std::endl;
37 | 
38 |     return 0;
39 | }
40 | /*
41 | $ gcc mkexec.cpp -o mkexec
42 | 
43 | $ ./mkexec
44 | Result:6
45 | */


--------------------------------------------------------------------------------
/Calculator/Predicates.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstddef>
 4 | #include <string_view>
 5 | 
 6 | namespace Interpreter {
 7 | 
 8 | struct isidentifier {
 9 |     bool operator()(char ch) {
10 |         if (counter++ == 0) return (ch == '_') || (std::isalpha(ch) != 0);
11 |         return (ch == '_') || (std::isalnum(ch) != 0);
12 |     }
13 |     int counter = 0;
14 | };
15 | 
16 | struct isalpha {
17 |     bool operator()(char ch) {
18 |         return (std::isalpha(ch) != 0);
19 |     }
20 | };
21 | 
22 | struct isdigit {
23 |     bool operator()(char ch) {
24 |         return (std::isdigit(ch) != 0);
25 |     }
26 | };
27 | struct isalnum {
28 |     bool operator()(char ch) {
29 |         return (std::isalnum(ch) != 0);
30 |     }
31 | };
32 | struct isspace {
33 |     bool operator()(char ch) {
34 |         return (std::isspace(ch) != 0);
35 |     }
36 | };
37 | 
38 | struct ischar {
39 |     ischar(char ch) : c(ch) {
40 |     }
41 |     bool operator()(char ch) const {
42 |         return (ch == c);
43 |     }
44 |     char c;
45 | };
46 | 
47 | struct isany {
48 |     isany(std::string_view sv) : _sv(sv) {
49 |     }
50 |     bool operator()(char ch) const {
51 |         for (char c : _sv) {
52 |             if (c == ch) return true;
53 |         }
54 |         return false;
55 |     }
56 |     std::string_view _sv;
57 | };
58 | 
59 | }  // namespace Interpreter
60 | 


--------------------------------------------------------------------------------
/DivTests/testdiv.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdint>
 2 | #include <stdio.h>
 3 | 
 4 | uint64_t tsc_start();
 5 | uint64_t tsc_stop();
 6 | 
 7 | 
 8 | template< typename Fn >
 9 | void test( const char* msg, const uint64_t count, const Fn&& fn ) {
10 |     uint64_t sum = 0;
11 |     for ( uint64_t j=0; j<count; ++j ) {
12 |         uint64_t t0 = tsc_start();
13 |         fn( j );
14 |         uint64_t t1 = tsc_stop();
15 |         uint64_t elap = t1>=t0 ? t1-t0 : 0;
16 |         sum += elap;
17 |     }
18 |     printf( "%s average: %ld cycles\n", msg, sum/count );
19 | }
20 | 
21 | bool is_multiple_of_3( uint64_t j );
22 | bool is_multiple_of_3_optimized( uint64_t j );
23 | bool empty( uint64_t j );
24 | 
25 | constexpr uint64_t numloops = 50000000;
26 | 
27 | int main()
28 | {
29 |     uint64_t emptycount = 0;
30 |     uint64_t mult3count = 0;
31 |     uint64_t nonmult3count = 0;
32 |     test( "Empty", numloops, [&]( uint64_t j ) {
33 |             if ( empty(j) ) ++mult3count;
34 |             else nonmult3count++;
35 |         });
36 |     test( "Standard", numloops, [&]( uint64_t j ) {
37 |             if ( is_multiple_of_3(j) ) mult3count++;
38 |             else nonmult3count++;
39 |         });
40 |     test( "Optimized", numloops, [&]( uint64_t j ) {
41 |             uint32_t i = (uint32_t)j;
42 |             if ( is_multiple_of_3_optimized(j) ) mult3count++;
43 |             else nonmult3count++;
44 |         });
45 | 
46 |     printf( "%ld %ld %ld\n", emptycount, mult3count, nonmult3count );
47 | }
48 | 


--------------------------------------------------------------------------------
/Calculator/calculator.cpp:
--------------------------------------------------------------------------------
 1 | #include "Calculator.h"
 2 | 
 3 | // Stolen from Google Benchmarks for the quick benchmark below
 4 | template <typename Tp>
 5 | static inline void DoNotOptimize(Tp const& value) {
 6 |     asm volatile("" : : "r,m"(value) : "memory");
 7 | }
 8 | 
 9 | // Our main namespace
10 | using namespace Interpreter;
11 | 
12 | // Quick cycles gathering
13 | uint64_t now() {
14 |     return __builtin_ia32_rdtsc();
15 | }
16 | 
17 | int main(int argc, char* argv[]) {
18 |     // Usage
19 |     if (argc < 2) {
20 |         printf("Usage: calc <expression>\n");
21 |         return 0;
22 |     }
23 | 
24 |     // Create the main class
25 |     Calculator calc;
26 | 
27 |     // Run through every argument as expressions
28 |     for (int j = 1; j < argc; ++j) {
29 |         std::string cmd = argv[j];
30 |         printf("Solving %s\n", cmd.c_str());
31 | 
32 |         // The resulting value from expression
33 |         double value;
34 | 
35 |         // Start counting time
36 |         uint64_t t0 = now();
37 |         for (int j = 0; j < 10000; ++j) {
38 |             // Parse the expression
39 |             Pointer<Node> ast = calc.parse(cmd);
40 | 
41 |             // Compute the expression in the AST tree
42 |             value = ast->calc();
43 | 
44 |             // This so the above does not get optimized away from compiler
45 |             DoNotOptimize(value);
46 |         }
47 | 
48 |         // Compute elapsed time in CPU ticks
49 |         uint64_t t1 = now();
50 |         double elapsed = (t1 - t0) / 10000.;
51 |         printf("Result: %f Avg:%f cycles\n", value, elapsed);
52 |     }
53 | }


--------------------------------------------------------------------------------
/Calculator/FunctionOps.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Pointer.h"
 4 | #include "Node.h"
 5 | 
 6 | #include <string_view>
 7 | 
 8 | namespace Interpreter {
 9 | 
10 | template <size_t>
11 | using double_t = double;
12 | 
13 | //! Creates the function call type and unpacks the vector inside it
14 | template <std::size_t... I>
15 | double callfn_impl(void* fn, const double* values, std::index_sequence<I...>) {
16 |     using CallType = double (*)(double_t<I>...);
17 |     return CallType(fn)(values[I]...);
18 | }
19 | 
20 | //! Builds the call for a given number of arguments. Relies on callfn_impl
21 | template <std::size_t N>
22 | double callfn(void* fn, const double* values) {
23 |     using Indices = std::make_index_sequence<N>;
24 |     return callfn_impl(fn, values, Indices{});
25 | }
26 | 
27 | //! Dispatches the call to one of our templated functions using
28 | //! a big switch statement
29 | double callfn(void* fn, const double* args, size_t size) {
30 |     switch (size) {
31 |         case 0: return callfn<0>(fn, args); break;
32 |         case 1: return callfn<1>(fn, args); break;
33 |         case 2: return callfn<2>(fn, args); break;
34 |         case 3: return callfn<3>(fn, args); break;
35 |         case 4: return callfn<4>(fn, args); break;
36 |         case 5: return callfn<5>(fn, args); break;
37 |         case 6: return callfn<6>(fn, args); break;
38 |         case 7: return callfn<7>(fn, args); break;
39 |         case 8: return callfn<8>(fn, args); break;
40 |         case 9: return callfn<9>(fn, args); break;
41 |         case 10: return callfn<10>(fn, args); break;
42 |     };
43 |     return std::numeric_limits<double>::quiet_NaN();
44 | }
45 | 
46 | }  // namespace Interpreter
47 | 


--------------------------------------------------------------------------------
/Calculator/Pointer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <boost/smart_ptr/intrusive_ref_counter.hpp>
 4 | #include <boost/smart_ptr/intrusive_ptr.hpp>
 5 | 
 6 | namespace Interpreter {
 7 | 
 8 | //--------------------------------------------------
 9 | // Pointers
10 | //--------------------------------------------------
11 | template <typename T>
12 | using IntrusivePointer = boost::intrusive_ptr<T>;
13 | 
14 | //! Your basic intrusive pointer plus hashmap ability
15 | template <typename T>
16 | class Pointer : public IntrusivePointer<T> {
17 | public:
18 |     using IntrusivePointer<T>::IntrusivePointer;
19 |     template <typename U>
20 |     Pointer<U> as() const {
21 |         U* ptr = dynamic_cast<U*>(this->get());
22 |         if (ptr != nullptr) return Pointer<U>(ptr);
23 |         return Pointer<U>();
24 |     }
25 | 
26 |     //! Allows intrusive pointers to be used in hashmaps and hashsets
27 |     bool operator==(const Pointer<T>& rhs) {
28 |         return this->get() == rhs.get();
29 |     }
30 | };
31 | 
32 | // Base class for intrusive pointers
33 | // Handles the counter and deleting of objects
34 | struct RefCounted {
35 |     RefCounted() {
36 |         _counter = 0;
37 |     }
38 |     virtual ~RefCounted() {
39 |     }
40 |     RefCounted(const RefCounted&) = delete;
41 |     RefCounted(RefCounted&&) = delete;
42 |     friend inline void intrusive_ptr_add_ref(RefCounted* p) {
43 |         p->_counter += 1;
44 |     }
45 | 
46 |     friend inline void intrusive_ptr_release(RefCounted* p) {
47 |         if (p->_counter > 1) {
48 |             p->_counter--;
49 |             return;
50 |         }
51 |         delete p;
52 |     }
53 |     int _counter = 0;
54 | };
55 | 
56 | }  // namespace Interpreter
57 | 


--------------------------------------------------------------------------------
/CacheCheck/testcopy.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <iostream>
 3 | #include <cstdlib>
 4 | #include <cstring>
 5 | 
 6 | using LARGE_INTEGER = uint64_t;
 7 | 
 8 | LARGE_INTEGER getTimeStamp(void)
 9 | {
10 |     return __builtin_ia32_rdtsc();
11 | }
12 | 
13 | unsigned int getElapsedMicroseconds(LARGE_INTEGER start)
14 | {
15 |     LARGE_INTEGER end = getTimeStamp();
16 |     LARGE_INTEGER freq = 3300;
17 | 
18 |     double t = (double)(end - start) * 1000000.0 / (double)freq;
19 |     return (unsigned int)(t + 0.5);
20 | }
21 | 
22 | int main(int argc, char **argv)
23 | {
24 |     static const size_t singleBuffSize = 36ULL * 1024 * 1024;
25 |     static const size_t nrOfBuffers = 6;
26 | 
27 |     volatile unsigned char *srcBuff = new unsigned char[singleBuffSize];
28 |     volatile unsigned char *dstBuff = new unsigned char[singleBuffSize * nrOfBuffers];
29 | 
30 |     for (size_t j = 0; j < singleBuffSize; ++j)
31 |     {
32 |         srcBuff[j] = j;
33 |     }
34 | 
35 |     for (int i = 0; i < (nrOfBuffers * 3); i++)
36 |     {
37 |         size_t buffIdx = (i % nrOfBuffers) * singleBuffSize;
38 | 
39 |         LARGE_INTEGER start = getTimeStamp();
40 |         std::memcpy((void *)&dstBuff[buffIdx], (void *)srcBuff, singleBuffSize);
41 |         unsigned int elapsedMicroseconds = getElapsedMicroseconds(start);
42 | 
43 |         printf("Loop %2d: buffer nr %2lu, elapsed time = %6u microseconds\n", i + 1, ((i % nrOfBuffers) + 1), elapsedMicroseconds);
44 |     }
45 | 
46 |     size_t sum = 0;
47 |     for (size_t j = 0; j < singleBuffSize * nrOfBuffers; ++j)
48 |     {
49 |         sum += dstBuff[j];
50 |     }
51 |     std::cout << "Sum:" << sum << std::endl;
52 | 
53 |     delete[] srcBuff;
54 |     delete[] dstBuff;
55 | 
56 |     return 0;
57 | }


--------------------------------------------------------------------------------
/Target/simple.cpp:
--------------------------------------------------------------------------------
 1 | #include <array>
 2 | #include <cstdio>
 3 | 
 4 | using Vector = std::array<float, 2>;
 5 | using Matrix = std::array<float, 4>;
 6 | 
 7 | namespace detail {
 8 | inline Vector multiply(const Matrix& m, const Vector& v) {
 9 |     Vector r;
10 |     r[0] = v[0] * m[0] + v[1] * m[2];
11 |     r[1] = v[0] * m[1] + v[1] * m[3];
12 |     return r;
13 | }
14 | }  // namespace detail
15 | 
16 | __attribute__((target("default"))) Vector multiply(const Matrix& m, const Vector& v) {
17 |     printf("default\n");
18 |     return detail::multiply(m, v);
19 | }
20 | 
21 | __attribute__((target("arch=core2"))) Vector multiply(const Matrix& m, const Vector& v) {
22 |     printf("core2\n");
23 |     return detail::multiply(m, v);
24 | }
25 | 
26 | __attribute__((target("arch=sandybridge"))) Vector multiply(const Matrix& m, const Vector& v) {
27 |     printf("sandybridge\n");
28 |     return detail::multiply(m, v);
29 | }
30 | 
31 | __attribute__((target("arch=haswell"))) Vector multiply(const Matrix& m, const Vector& v) {
32 |     printf("haswell\n");
33 |     return detail::multiply(m, v);
34 | }
35 | 
36 | __attribute__((target("arch=cascadelake"))) Vector multiply(const Matrix& m, const Vector& v) {
37 |     printf("cascadelake\n");
38 |     return detail::multiply(m, v);
39 | }
40 | 
41 | __attribute__((target("arch=znver1"))) Vector multiply(const Matrix& m, const Vector& v) {
42 |     printf("znver1\n");
43 |     return detail::multiply(m, v);
44 | }
45 | 
46 | __attribute__((target("arch=znver2"))) Vector multiply(const Matrix& m, const Vector& v) {
47 |     printf("znver2\n");
48 |     return detail::multiply(m, v);
49 | }
50 | 
51 | int main() {
52 |     Vector v{1, 2};
53 |     Matrix m{3, 4, 5, 6};
54 |     Vector r = multiply(m, v);
55 |     printf("%f %f\n", r[0], r[1]);
56 | }


--------------------------------------------------------------------------------
/CacheCheck/testCycles.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdint>
 2 | #include <vector>
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | #include <random>
 6 | #include <cassert>
 7 | #include "benchmark/benchmark.h"
 8 | 
 9 | std::random_device rd;
10 | std::mt19937 g(rd());
11 | 
12 | template <typename IntType>
13 | std::ostream& operator<<(std::ostream& out, const std::vector<IntType>& values) {
14 |     for (IntType val : values) {
15 |         std::cout << val << " ";
16 |     }
17 |     return out;
18 | }
19 | 
20 | template <typename IntType>
21 | std::vector<IntType> createCycle(size_t size) {
22 |     std::vector<IntType> indices(size), shuffled(size);
23 |     for (size_t j = 0; j < size; ++j) indices[j] = j;
24 |     std::shuffle(indices.begin(), indices.end(), g);
25 |     size_t pos = indices[0];
26 |     for (size_t j = 1; j < size; ++j) {
27 |         size_t next = indices[j];
28 |         shuffled[pos] = next;
29 |         pos = next;
30 |     }
31 |     size_t next = indices[0];
32 |     shuffled[pos] = next;
33 |     return shuffled;
34 | }
35 | 
36 | uint64_t now() {
37 |     return __builtin_ia32_rdtsc();
38 | }
39 | 
40 | template <typename IntType>
41 | void TestCycle(benchmark::State& state) {
42 |     size_t size = state.range(0);
43 |     const size_t max_ticks = 10000;
44 |     std::vector<IntType> indices = createCycle<IntType>(size);
45 |     size_t pos = 0;
46 |     size_t counter = 0;
47 |     for (auto _ : state) {
48 |         for (size_t j = 0; j < size; ++j) {
49 |             pos = indices[pos];
50 |         }
51 |         benchmark::DoNotOptimize(pos);
52 |     }
53 |     state.counters["Rate"] = benchmark::Counter(
54 |         size, benchmark::Counter::kIsIterationInvariantRate | benchmark::Counter::kInvert,
55 |         benchmark::Counter::OneK::kIs1024);
56 | }
57 | 
58 | BENCHMARK(TestCycle<uint64_t>)->RangeMultiplier(2)->Range(4, 1ULL << 28);
59 | BENCHMARK_MAIN();


--------------------------------------------------------------------------------
/Target/bench.cpp:
--------------------------------------------------------------------------------
 1 | #include <array>
 2 | #include <cstdio>
 3 | #include "benchmark/benchmark.h"
 4 | 
 5 | using Vector = std::array<float, 2>;
 6 | using Matrix = std::array<float, 4>;
 7 | 
 8 | namespace detail {
 9 | inline Vector multiply(const Matrix& m, const Vector& v) {
10 |     Vector r;
11 |     r[0] = v[0] * m[0] + v[1] * m[2];
12 |     r[1] = v[0] * m[1] + v[1] * m[3];
13 |     return r;
14 | }
15 | }  // namespace detail
16 | 
17 | Vector v{1, 2};
18 | Matrix m{3, 4, 5, 6};
19 | 
20 | void Inlined(benchmark::State& state) {
21 |     for (auto _ : state) {
22 |         v = detail::multiply(m, v);
23 |         benchmark::DoNotOptimize(v);
24 |     }
25 | }
26 | 
27 | void InlinedReuse(benchmark::State& state) {
28 |     for (auto _ : state) {
29 |         v = detail::multiply(m, v);
30 |     }
31 | }
32 | 
33 | Vector multiply_standard(const Matrix& m, const Vector& v);
34 | 
35 | void Standard(benchmark::State& state) {
36 |     for (auto _ : state) {
37 |         v = multiply_standard(m, v);
38 |         benchmark::DoNotOptimize(v);
39 |     }
40 | }
41 | 
42 | void StandardReuse(benchmark::State& state) {
43 |     for (auto _ : state) {
44 |         v = multiply_standard(m, v);
45 |     }
46 | }
47 | 
48 | __attribute__((target_clones("default", "arch=core2", "arch=sandybridge", "arch=haswell", "arch=cascadelake",
49 |                              "arch=znver1", "arch=znver2"))) Vector
50 | multiply(const Matrix& m, const Vector& v);
51 | 
52 | void Encoded(benchmark::State& state) {
53 |     for (auto _ : state) {
54 |         v = multiply(m, v);
55 |         benchmark::DoNotOptimize(v);
56 |     }
57 | }
58 | 
59 | void EncodedReuse(benchmark::State& state) {
60 |     for (auto _ : state) {
61 |         v = multiply(m, v);
62 |     }
63 | }
64 | 
65 | BENCHMARK(Inlined);
66 | BENCHMARK(InlinedReuse);
67 | BENCHMARK(Standard);
68 | BENCHMARK(StandardReuse);
69 | BENCHMARK(Encoded);
70 | BENCHMARK(EncodedReuse);
71 | 
72 | BENCHMARK_MAIN();
73 | 


--------------------------------------------------------------------------------
/CompileTimeSwitch/caller_caleth.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <memory>
 3 | #include <vector>
 4 | #include <functional>
 5 | 
 6 | namespace caleth {
 7 | 
 8 | class Function {
 9 |     struct BaseCaller {
10 |         virtual ~BaseCaller() {
11 |         }
12 |         virtual double call(std::vector<double>) const = 0;
13 |     };
14 | 
15 |     template <typename... Args>
16 |     class Caller : public BaseCaller {
17 |         double (*func)(Args...);
18 | 
19 |     public:
20 |         explicit Caller(double (*func)(Args...)) : func(func) {
21 |         }
22 |         double call(std::vector<double> args) const {
23 |             return [&]<size_t... Is>(std::index_sequence<Is...>) {
24 |                 return func(args[Is]...);
25 |             }
26 |             (std::index_sequence_for<Args...>{});
27 |         }
28 |     };
29 | 
30 |     std::unique_ptr<BaseCaller> caller;
31 | 
32 | public:
33 |     template <typename... Args>
34 |     Function(double (*func)(Args...)) : caller(std::make_unique<Caller<Args...>>(func)) {
35 |     }
36 | 
37 |     double operator()(const std::vector<double>& args) {
38 |         return caller->call(args);
39 |     }
40 | };
41 | 
42 | constexpr size_t MaxArgs = MAXARGS;
43 | 
44 | template <size_t>
45 | using double_t = double;
46 | 
47 | template <size_t... Is>
48 | using RawFunction = double (*)(double_t<Is>...);
49 | 
50 | static const auto myarray = []<size_t... Is>(std::index_sequence<Is...>)
51 |                                 -> std::array<std::function<Function(void*)>, MaxArgs> {
52 |     auto cast = []<size_t... Js>(std::index_sequence<Js...>, void* f) {
53 |         return Function(reinterpret_cast<RawFunction<Js...>>(f));
54 |     };
55 |     return {[=](void* f) { return cast(std::make_index_sequence<Is>{}, f); }...};
56 | }
57 | (std::make_index_sequence<MaxArgs>{});
58 | 
59 | Function from_void(void* f, size_t numargs) {
60 |     return myarray[numargs](f);
61 | }
62 | 
63 | double callfn(void* fn, const std::vector<double>& args) {
64 |     return from_void(fn, args.size())(args);
65 | }
66 | 
67 | }  // namespace caleth
68 | 


--------------------------------------------------------------------------------
/Cordic/benchmark.cpp:
--------------------------------------------------------------------------------
 1 | #include "functions.h"
 2 | #include <benchmark/benchmark.h>
 3 | #include <vector>
 4 | #include <iostream>
 5 | 
 6 | struct TrivialFn {
 7 |     void operator()(int64_t* ptr, double freq, int N) {
 8 |         trivial(ptr, freq, N);
 9 |     }
10 | };
11 | 
12 | struct CordicFn {
13 |     void operator()(int64_t* ptr, double freq, int N) {
14 |         cordic(ptr, freq, N);
15 |     }
16 | };
17 | struct BitCalcFn {
18 |     void operator()(int64_t* ptr, double freq, int N) {
19 |         bitcalc(ptr, freq, N);
20 |     }
21 | };
22 | 
23 | template <int N>
24 | struct TrivialT {
25 |     void operator()(int64_t* ptr, double freq, int) {
26 |         trivial<N>(ptr, freq);
27 |     }
28 | };
29 | 
30 | template <int N>
31 | struct CordicT {
32 |     void operator()(int64_t* ptr, double freq, int) {
33 |         cordic<N>(ptr, freq);
34 |     }
35 | };
36 | 
37 | template <int N>
38 | struct BitCalcT {
39 |     void operator()(int64_t* ptr, double freq, int) {
40 |         bitcalc<N>(ptr, freq);
41 |     }
42 | };
43 | 
44 | template <typename Fn, int N>
45 | static void Benchmark(benchmark::State& state) {
46 |     Fn fn;
47 |     std::vector<int64_t> samples1(N);
48 |     for (auto _ : state) {
49 |         fn(samples1.data(), 1, samples1.size());
50 |     }
51 | }
52 | 
53 | BENCHMARK(Benchmark<TrivialFn, 512>);
54 | BENCHMARK(Benchmark<CordicFn, 512>);
55 | BENCHMARK(Benchmark<BitCalcFn, 512>);
56 | BENCHMARK(Benchmark<TrivialT<512>, 512>);
57 | BENCHMARK(Benchmark<CordicT<512>, 512>);
58 | BENCHMARK(Benchmark<BitCalcT<512>, 512>);
59 | 
60 | BENCHMARK(Benchmark<TrivialFn, 32768>);
61 | BENCHMARK(Benchmark<CordicFn, 32768>);
62 | BENCHMARK(Benchmark<BitCalcFn, 32768>);
63 | BENCHMARK(Benchmark<TrivialT<32768>, 32768>);
64 | BENCHMARK(Benchmark<BitCalcT<32768>, 32768>);
65 | BENCHMARK(Benchmark<CordicT<32768>, 32768>);
66 | 
67 | BENCHMARK(Benchmark<TrivialFn, 262144>);
68 | BENCHMARK(Benchmark<CordicFn, 262144>);
69 | BENCHMARK(Benchmark<BitCalcFn, 262144>);
70 | BENCHMARK(Benchmark<TrivialT<262144>, 262144>);
71 | BENCHMARK(Benchmark<BitCalcT<262144>, 262144>);
72 | BENCHMARK(Benchmark<CordicT<262144>, 262144>);
73 | 
74 | BENCHMARK_MAIN();
75 | 


--------------------------------------------------------------------------------
/CompileTimeSwitch/caller_fred.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdint>
 2 | #include <cstddef>
 3 | #include <vector>
 4 | #include <array>
 5 | #include <iostream>
 6 | #include <memory>
 7 | 
 8 | namespace fred {
 9 | struct CallerBase {
10 |     virtual ~CallerBase(){};
11 |     virtual double call(void* fn, const double* ptr) = 0;
12 | };
13 | 
14 | template <size_t N, size_t J, typename... Args>
15 | struct Execute {
16 |     using CallType = typename Execute<N, J - 1, double, Args...>::CallType;
17 |     double exec(void* fn, const double* val, Args... args) {
18 |         return Execute<N, J - 1, double, Args...>().exec(fn, val + 1, args..., val[0]);
19 |     }
20 | };
21 | 
22 | template <size_t N, typename... Args>
23 | struct Execute<N, 0, Args...> {
24 |     typedef double (*CallType)(Args...);
25 |     double exec(void* fn, const double* ptr, Args... args) {
26 |         return CallType(fn)(args...);
27 |     }
28 | };
29 | 
30 | template <size_t N>
31 | struct Caller : public CallerBase {
32 |     virtual double call(void* fn, const double* ptr) override {
33 |         return Execute<N, N>().exec(fn, ptr);
34 |     }
35 | };
36 | 
37 | template <size_t J>
38 | CallerBase* createCaller(size_t j) {
39 |     if (j == J) return new Caller<J>();
40 |     return createCaller<J - 1>(j);
41 | }
42 | 
43 | template <>
44 | CallerBase* createCaller<0>(size_t j) {
45 |     return new Caller<0>();
46 | }
47 | 
48 | template <size_t N, size_t J>
49 | struct SwitchImpl : public SwitchImpl<N, J - 1> {
50 |     double operator()(void* fn, const double* ptr, size_t size) {
51 |         return SwitchImpl<N, 0>::fn[size]->call(fn, ptr);
52 |     }
53 | };
54 | 
55 | template <size_t N>
56 | struct SwitchImpl<N, 0> {
57 |     std::array<std::unique_ptr<CallerBase>, N> fn;
58 |     SwitchImpl() {
59 |         for (size_t j = 0; j < N; ++j) {
60 |             fn[j].reset(createCaller<N>(j));
61 |         }
62 |     }
63 | };
64 | 
65 | template <size_t N>
66 | using Switch = SwitchImpl<N, N>;
67 | 
68 | double callfn(void* fn, const std::vector<double>& args) {
69 |     static Switch<MAXARGS> sw;
70 |     size_t size = args.size();
71 |     const double* ptr = args.data();
72 |     return sw(fn, ptr, size);
73 | }
74 | 
75 | }  // namespace fred
76 | 


--------------------------------------------------------------------------------
/CompileTimeSwitch/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required( VERSION 3.12 )
 2 | project( caller )
 3 | 
 4 | set( CMAKE_CXX_STANDARD 20 )
 5 | 
 6 | find_package(Python3 COMPONENTS Interpreter)
 7 | if (NOT ${Python3_FOUND})
 8 |     message(FATAL_ERROR "Python is needed to generate sources.")
 9 | endif ()
10 | 
11 | set( MAXARGS 250 )
12 | 
13 | set( EXTRA_OPTS "-ftemplate-depth=1000" )
14 | if ( CMAKE_CXX_COMPILER_ID STREQUAL "Clang" )
15 |     set( EXTRA_OPTS ${EXTRA_OPTS} "-fbracket-depth=1000" )
16 | endif()
17 | 
18 | 
19 | include( Codegen.cmake )
20 | codegen( switch.mako.cpp ${CMAKE_BINARY_DIR}/switch.cpp 250 )
21 | 
22 | add_library( functions SHARED functions.cpp )
23 | 
24 | set( SOURCES main.cpp caller_fred.cpp caller_fred2.cpp caller_trivial.cpp caller_caleth.cpp
25 |              ${CMAKE_BINARY_DIR}/switch.cpp )
26 | 
27 | add_executable( caller_caleth main.cpp caller_caleth.cpp )
28 | target_compile_definitions( caller_caleth PRIVATE MAXARGS=${MAXARGS} RUN_CALETH )
29 | target_compile_options(caller_caleth PRIVATE ${EXTRA_OPTS} )
30 | target_link_libraries( caller_caleth functions )
31 | 
32 | add_executable( caller_trivial main.cpp caller_trivial.cpp ${CMAKE_BINARY_DIR}/switch.cpp )
33 | target_compile_definitions( caller_trivial PRIVATE MAXARGS=${MAXARGS} RUN_TRIVIAL )
34 | target_compile_options(caller_trivial PRIVATE ${EXTRA_OPTS})
35 | target_link_libraries( caller_trivial functions )
36 | 
37 | add_executable( caller_fred main.cpp caller_fred.cpp )
38 | target_compile_definitions( caller_fred PRIVATE MAXARGS=${MAXARGS} RUN_FRED )
39 | target_compile_options(caller_fred PRIVATE ${EXTRA_OPTS})
40 | target_link_libraries( caller_fred functions )
41 | 
42 | add_executable( caller_fred2 main.cpp caller_fred2.cpp )
43 | target_compile_definitions( caller_fred2 PRIVATE MAXARGS=${MAXARGS} RUN_FRED2  )
44 | target_compile_options(caller_fred2 PRIVATE ${EXTRA_OPTS})
45 | target_link_libraries( caller_fred2 functions )
46 | 
47 | 
48 | add_executable( caller10  ${SOURCES} )
49 | target_compile_definitions( caller10 PRIVATE MAXARGS=10 RUN_ALL )
50 | target_compile_options(caller10 PRIVATE ${EXTRA_OPTS})
51 | target_link_libraries( caller10 functions )
52 | 
53 | add_executable( caller250  ${SOURCES} )
54 | target_compile_definitions( caller250 PRIVATE MAXARGS=250 RUN_ALL )
55 | target_compile_options(caller250 PRIVATE ${EXTRA_OPTS})
56 | target_link_libraries( caller250 functions )
57 | 
58 | 


--------------------------------------------------------------------------------
/Cordic/functions.cpp:
--------------------------------------------------------------------------------
 1 | #include "functions.h"
 2 | #include <cmath>
 3 | 
 4 | constexpr double pi = M_PI;
 5 | constexpr int64_t Q = 16;
 6 | 
 7 | void bitcalc(int64_t* samples, double freq, int N) {
 8 |     double cs = std::cos((2 * pi * freq) / N);
 9 |     int64_t coeff = (1LL << Q) * 2 * cs;
10 | 
11 |     int64_t Qn1 = (1LL << Q) * pi * freq;
12 |     int64_t Qn2 = 0;
13 | 
14 |     for (int j = 0; j < N; ++j) {
15 |         samples[j] = Qn2 / N;
16 |         int64_t Qn = ((coeff * Qn1) >> Q) - Qn2;
17 |         Qn2 = Qn1;
18 |         Qn1 = Qn;
19 |     }
20 | }
21 | 
22 | template <int N>
23 | void bitcalc(int64_t* samples, double freq) {
24 |     bitcalc(samples, freq, N);
25 | }
26 | template void bitcalc<512>(int64_t* samples, double freq);
27 | template void bitcalc<32768>(int64_t* samples, double freq);
28 | template void bitcalc<262144>(int64_t* samples, double freq);
29 | 
30 | void trivial(int64_t* samples, double freq, int N) {
31 |     double cs = (2 * pi * freq) / N;
32 |     double A = (1LL << Q) / 2;
33 |     for (int j = 0; j < N; ++j) {
34 |         samples[j] = A * sin(cs * j);
35 |     }
36 | }
37 | template <int N>
38 | void trivial(int64_t* samples, double freq) {
39 |     trivial(samples, freq, N);
40 | }
41 | template void trivial<512>(int64_t* samples, double freq);
42 | template void trivial<32768>(int64_t* samples, double freq);
43 | template void trivial<262144>(int64_t* samples, double freq);
44 | 
45 | void cordic(int64_t* samples, double freq, int N) {
46 |     double sn = std::sin(2 * pi * freq / N);
47 |     double cs = std::cos(2 * pi * freq / N);
48 |     double A = (1LL << Q) / 2;
49 |     double x = 0;
50 |     double y = 1;
51 |     for (int j = 0; j < N; ++j) {
52 |         double tx = x * cs + y * sn;
53 |         double ty = y * cs - x * sn;
54 |         samples[j] = A * x;
55 |         x = tx;
56 |         y = ty;
57 |     }
58 | }
59 | 
60 | template <int N>
61 | void cordic(int64_t* samples, double freq) {
62 |     cordic(samples, freq, N);
63 | }
64 | template void cordic<512>(int64_t* samples, double freq);
65 | template void cordic<32768>(int64_t* samples, double freq);
66 | template void cordic<262144>(int64_t* samples, double freq);
67 | 
68 | void icordic(int64_t* samples, double freq, int N) {
69 |     double sn = std::sin(2 * pi * freq / N);
70 |     double cs = std::cos(2 * pi * freq / N);
71 |     double A = (1LL << Q) / 2;
72 |     double x = 0;
73 |     double y = 1;
74 |     for (int j = 0; j < N; ++j) {
75 |         double tx = x * cs + y * sn;
76 |         double ty = y * cs - x * sn;
77 |         samples[j] = A * x;
78 |         x = tx;
79 |         y = ty;
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/BenchmarkPatch/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | ####################################################################################################
 2 | # Referencing to
 3 | # https://github.com/google/benchmark/commit/27c1d8ace94d23ab5d807801f280faea78836533#r103259540
 4 | ####################################################################################################
 5 | # we dont need all the benchmark internal testing
 6 | set( BENCHMARK_ENABLE_TESTING OFF CACHE STRING "")
 7 | 
 8 | cmake_minimum_required( VERSION 3.0 )
 9 | project( target )
10 | enable_language( CXX )
11 | include( ExternalProject )
12 | enable_testing()
13 | 
14 | set( RESULT_FILES "" )
15 | macro( add_branch branch_name )
16 |     ExternalProject_Add( benchmark_${branch_name}
17 |         INSTALL_DIR install/${branch_name}
18 |         CMAKE_ARGS 
19 |             -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
20 |             -DCMAKE_BUILD_TYPE=release 
21 |             -DBENCHMARK_ENABLE_TESTING=OFF 
22 |             -DBENCHMARK_ENABLE_LIBPFM=OFF
23 |         GIT_REPOSITORY https://github.com/google/benchmark.git 
24 |         GIT_TAG ${branch_name} )
25 | 
26 |     ExternalProject_Get_Property( benchmark_${branch_name} INSTALL_DIR)
27 |     add_executable( main_${branch_name} main.cpp )
28 |     target_include_directories( main_${branch_name} PUBLIC ${INSTALL_DIR}/include )
29 |     target_link_libraries( main_${branch_name} ${INSTALL_DIR}/lib/libbenchmark.a pthread )
30 |     add_dependencies( main_${branch_name} benchmark_${branch_name} )
31 |     add_custom_command( 
32 |         OUTPUT results_${branch_name}.json 
33 |         COMMAND main_${branch_name} --v=0 --benchmark_out=results_${branch_name}.json --benchmark_out_format=json )
34 |     list( APPEND RESULT_FILES results_${branch_name}.json )
35 | endmacro()
36 | 
37 | add_branch( v1.3.0 )
38 | add_branch( v1.4.0 )
39 | add_branch( v1.4.1 )
40 | add_branch( v1.5.0 )
41 | add_branch( v1.5.1 )
42 | add_branch( v1.5.2 )
43 | add_branch( v1.5.3 )
44 | add_branch( v1.5.4 )
45 | add_branch( v1.5.5 )
46 | add_branch( v1.5.6 )
47 | add_branch( v1.6.0 )
48 | add_branch( v1.6.1 )
49 | add_branch( v1.6.2 )
50 | add_branch( v1.7.0 )
51 | add_branch( v1.7.1 )
52 | add_branch( main )
53 | 
54 | string( REPLACE ";" "  " FILE_LIST "${RESULT_FILES}" )
55 | 
56 | find_package (Python3 COMPONENTS Interpreter)
57 | if ( Python3_Interpreter_FOUND )
58 | add_custom_target( 
59 |     graph ALL
60 |     DEPENDS ${RESULT_FILES}
61 |     COMMAND ${Python3_EXECUTABLE} ${PROJECT_SOURCE_DIR}/compile_benchmark_results.py graph ${RESULT_FILES} )
62 | add_test( NAME regression 
63 |     COMMAND ${Python3_EXECUTABLE} ${PROJECT_SOURCE_DIR}/compile_benchmark_results.py check ${RESULT_FILES} )
64 | endif()
65 | 
66 | 
67 | 


--------------------------------------------------------------------------------
/BenchmarkPatch/compile_benchmark_results.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | import matplotlib.pyplot as plt
 3 | import os, sys
 4 | import re
 5 | 
 6 | if len(sys.argv)<=1:
 7 |     print("Usage: compile_benchmark_results.py (check|graph) <json> [<json> ...]")
 8 |     sys.exit(0)
 9 | 
10 | command = sys.argv[1]
11 | tests=[]
12 | benchmarks = {}
13 | for filename in sys.argv[2:]:
14 |     with open(filename,'r') as fin:
15 |         jstext = fin.read()
16 |         results = json.loads( jstext )
17 |     test_name = re.match('^.*_(.*).json',filename)[1]
18 |     tests.append( test_name )
19 |     ghz = float(results['context']['mhz_per_cpu'])/1000.
20 |     stats = {}
21 |     for bench in results['benchmarks']:
22 |         bench_name = bench['name']
23 |         cputime = float(bench['cpu_time'])
24 |         cycles = cputime * ghz
25 |         stats.setdefault(bench_name,[]).append( cycles )        
26 |     for bench_name,values in stats.items():
27 |         min_value = min(values)
28 |         benchmarks.setdefault(bench_name,[]).append( min_value )
29 | 
30 | if command=='check':
31 |     fail = False
32 |     for bench_name,values in benchmarks.items():
33 |         last_value = values[-1]
34 |         sorted_values = sorted(values[:-1])
35 |         median = sorted_values[int(len(sorted_values)/2)]
36 |         if last_value > 1.1*median:
37 |             print("***ERROR*** Regression failed on benchmark",bench_name,": last value", last_value, "from branch", tests[-1], "is higher than the median ", median )
38 |             fail = True
39 |     if fail:
40 |         sys.exit(1)
41 |     sys.exit(0)
42 | 
43 | if command=='graph':
44 |     benchmark_names = list(benchmarks.keys())
45 |     num_benchmarks = len(benchmark_names)
46 |     num_tests = len(tests)
47 |     print( "Benchmarks:", benchmark_names )
48 |     print( "Benchmarks:%d Tests:%d" %(num_benchmarks, num_tests) )
49 |     width = 0.5 #1./(1+num_benchmarks)
50 |     fig, axes = plt.subplots(num_benchmarks,layout='constrained',figsize=(8,num_benchmarks*4), sharex=True)
51 |     if num_benchmarks==1:
52 |         axes = [ axes ]
53 |     for ax,bench_name in zip(axes,benchmark_names):
54 |         items = benchmarks[bench_name]
55 |         label_positions = range(num_tests) 
56 |         rects = ax.bar( label_positions, items, width, label=bench_name)
57 |         ax.bar_label(rects, padding=3)
58 |         ax.set_xticks(label_positions,tests )
59 |         max_value = max(items)
60 |         min_value = min(items)
61 |         value_range = max_value - min_value
62 |         margin = 0.1*value_range
63 |         ax.legend(loc='upper left', ncols=3)
64 |         ax.set_ylabel('Cycles')
65 |         ax.set_ylim( [min_value-margin,max_value+2*margin ] )
66 |     plt.savefig('graph_cycles.png')
67 | 
68 | 


--------------------------------------------------------------------------------
/CompileTimeSwitch/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdint>
 2 | #include <cstddef>
 3 | #include <vector>
 4 | #include <array>
 5 | #include <iostream>
 6 | #include <memory>
 7 | #include <limits>
 8 | #include <algorithm>
 9 | #include <string_view>
10 | 
11 | #include "functions.h"
12 | #include "utils.h"
13 | 
14 | namespace caleth {
15 | double callfn(void* fn, const std::vector<double>& args);
16 | };
17 | namespace fred {
18 | double callfn(void* fn, const std::vector<double>& args);
19 | };
20 | namespace fred2 {
21 | double callfn(void* fn, const std::vector<double>& args);
22 | };
23 | namespace trivial {
24 | double callfn(void* fn, const std::vector<double>& args);
25 | };
26 | 
27 | template <double (*Fn)(void*, const std::vector<double>&)>
28 | void test(std::string_view name, Function fn, const std::vector<double>& args) {
29 |     struct Result {
30 |         long long elapsed = 0;
31 |         double value = 0;
32 |         bool operator<(const Result& rhs) {
33 |             return elapsed < rhs.elapsed;
34 |         }
35 |     };
36 |     std::array<Result, 10000> samples;
37 |     bool first = true;
38 |     for (auto& result : samples) {
39 |         auto t0 = tic();
40 |         if (!first) {
41 |             result.value = Fn(fn.fnptr, args);
42 |             result.elapsed = toc() - t0;
43 |         } else {
44 |             result.elapsed = toc() - t0;
45 |             result.value = 0;
46 |             first = false;
47 |         }
48 |     }
49 |     samples[0].value = samples[1].value;
50 |     std::sort(samples.begin(), samples.end());
51 |     long long noop = samples[0].elapsed;
52 |     long long median = samples[samples.size() / 2].elapsed - noop;
53 |     long long slowest = samples.back().elapsed - noop;
54 |     long long best = samples[1].elapsed - noop;
55 |     double sum = 0;
56 |     for (const auto& result : samples) {
57 |         sum += result.value;
58 |     }
59 |     std::cout << name << " " << sum / samples.size() << " " << best << " " << median
60 |               << " " << slowest << std::endl;
61 | }
62 | 
63 | int main(int argc, char* argv[]) {
64 |     if (argc == 1) {
65 |         std::cout << "Usage: caller <fnum> [<value>...]" << std::endl;
66 |         return 0;
67 |     }
68 |     int fnum = std::atoi(argv[1]);
69 |     int numargs = argc - 2;
70 |     std::vector<double> args(numargs);
71 |     for (int j = 0; j < numargs; ++j) args[j] = std::atof(argv[j + 2]);
72 |     Function fn = fntable[fnum];
73 |     if (fn.numargs != numargs) {
74 |         std::cout << "Wrong number of arguments for function #" << fnum << ". Got "
75 |                   << numargs << " expected " << fn.numargs << std::endl;
76 |         return 1;
77 |     }
78 | 
79 | #if defined(RUN_CALETH) || defined(RUN_ALL)
80 |     test<caleth::callfn>("StackOverflow::caleth", fn, args);
81 | #endif
82 | #if defined(RUN_TRIVIAL) || defined(RUN_ALL)
83 |     test<trivial::callfn>("Trivial solution     ", fn, args);
84 | #endif
85 | #if defined(RUN_FRED) || defined(RUN_ALL)
86 |     test<fred::callfn>("Fred's solution      ", fn, args);
87 | #endif
88 | #if defined(RUN_FRED2) || defined(RUN_ALL)
89 |     test<fred2::callfn>("Fred's solution 2    ", fn, args);
90 | #endif
91 | }
92 | 


--------------------------------------------------------------------------------
/FieldExtract/AsmCopyGen.cpp:
--------------------------------------------------------------------------------
 1 | #include "AsmCopyGen.h"
 2 | 
 3 | AsmCopyGen::Bytes AsmCopyGen::getBytes() {
 4 |     return bytes;
 5 | }
 6 | 
 7 | void AsmCopyGen::copyField(uint32_t source, uint32_t target, uint32_t size) {
 8 |     switch (size) {
 9 |         case 1: {
10 |             // movzbl source(%rdi), %eax
11 |             if (source == 0) {
12 |                 insert({0x0f, 0xb6, 0x07});
13 |             } else if (source < 128) {
14 |                 insert({0x0f, 0xb6, 0x47, uint8_t(source)});
15 |             } else {
16 |                 insert({0x0f, 0xb6, 0x87, uint8_t(source), uint8_t(source >> 8), uint8_t(source >> 16),
17 |                         uint8_t(source >> 24)});
18 |             }
19 |             // mov %al,target(%rsi)
20 |             if (target == 0) {
21 |                 insert({0x88, 0x06});
22 |             } else if (target < 128) {
23 |                 insert({0x88, 0x46, uint8_t(target)});
24 |             } else {
25 |                 insert(
26 |                     {0x88, 0x86, uint8_t(target), uint8_t(target >> 8), uint8_t(target >> 16), uint8_t(target >> 24)});
27 |             }
28 |         }; break;
29 |         case 2: {
30 |             // movzwl source(%rdi), %eax
31 |             if (source == 0) {
32 |                 insert({0x0f, 0xb7, 0x07});
33 |             } else if (source < 128) {
34 |                 insert({0x0f, 0xb7, 0x47, uint8_t(source)});
35 |             } else {
36 |                 insert({0x0f, 0xb7, 0x87, uint8_t(source), uint8_t(source >> 8), uint8_t(source >> 16),
37 |                         uint8_t(source >> 24)});
38 |             }
39 |             // mov %ax,target(%rsi)
40 |             if (target == 0) {
41 |                 insert({0x66, 0x89, 0x06});
42 |             } else if (target < 128) {
43 |                 insert({0x66, 0x89, 0x46, uint8_t(target)});
44 |             } else {
45 |                 insert({0x66, 0x89, 0x86, uint8_t(target), uint8_t(target >> 8), uint8_t(target >> 16),
46 |                         uint8_t(target >> 24)});
47 |             }
48 |         }; break;
49 |         case 4: {
50 |             // mov source(%rdi), %eax
51 |             if (source == 0) {
52 |                 insert({0x8b, 0x07});
53 |             } else if (source < 128) {
54 |                 insert({0x8b, 0x47, uint8_t(source)});
55 |             } else {
56 |                 insert(
57 |                     {0x8b, 0x87, uint8_t(source), uint8_t(source >> 8), uint8_t(source >> 16), uint8_t(source >> 24)});
58 |             }
59 |             // mov %eax,target(%rsi)
60 |             if (target == 0) {
61 |                 insert({0x89, 0x06});
62 |             } else if (target < 128) {
63 |                 insert({0x89, 0x46, uint8_t(target)});
64 |             } else {
65 |                 insert(
66 |                     {0x89, 0x86, uint8_t(target), uint8_t(target >> 8), uint8_t(target >> 16), uint8_t(target >> 24)});
67 |             }
68 |         }; break;
69 |         case 8: {
70 |             // mov source(%rdi), %rax
71 |             if (source == 0) {
72 |                 insert({0x48, 0x8b, 0x07});
73 |             } else if (source < 128) {
74 |                 insert({0x48, 0x8b, 0x47, uint8_t(source)});
75 |             } else {
76 |                 insert({0x48, 0x8b, 0x87, uint8_t(source), uint8_t(source >> 8), uint8_t(source >> 16),
77 |                         uint8_t(source >> 24)});
78 |             }
79 |             // mov %rax,target(%rsi)
80 |             if (target == 0) {
81 |                 insert({0x48, 0x89, 0x06});
82 |             } else if (target < 128) {
83 |                 insert({0x48, 0x89, 0x46, uint8_t(target)});
84 |             } else {
85 |                 insert({0x48, 0x89, 0x86, uint8_t(target), uint8_t(target >> 8), uint8_t(target >> 16),
86 |                         uint8_t(target >> 24)});
87 |             }
88 |         }; break;
89 |     }
90 | }
91 | 


--------------------------------------------------------------------------------
/Calculator/TreeNodes.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "Pointer.h"
  4 | #include "Node.h"
  5 | #include "FunctionOps.h"
  6 | #include <string_view>
  7 | 
  8 | namespace Interpreter {
  9 | 
 10 | using NodePtr = Pointer<Node>;
 11 | 
 12 | struct Constant : public Node {
 13 |     Constant(double dval) {
 14 |         value = dval;
 15 |     }
 16 |     double value;
 17 |     double calc() override {
 18 |         return value;
 19 |     }
 20 | };
 21 | 
 22 | struct Parenthesis : public Node {
 23 |     Parenthesis(NodePtr n) {
 24 |         node = n;
 25 |     }
 26 |     NodePtr node;
 27 |     double calc() override {
 28 |         return node->calc();
 29 |     }
 30 |     void visit(Visitor& visitor) override {
 31 |         visitor.visit(this);
 32 |         visitor.visit(node.get());
 33 |     }
 34 | };
 35 | 
 36 | struct UnaryOp : public Node {
 37 |     enum class Operation : uint16_t { NA = 0, Negative = 1, Positive = 2 };
 38 |     Operation op = Operation::NA;
 39 |     NodePtr node;
 40 |     double calc() override {
 41 |         switch (op) {
 42 |             case Operation::Positive: return node->calc(); break;
 43 |             case Operation::Negative: return -node->calc(); break;
 44 |         }
 45 |         return node->calc();
 46 |     }
 47 | };
 48 | 
 49 | struct BinaryOp : public Node {
 50 |     enum class Operation : int { NA, Addition, Subtraction, Multiplication, Division };
 51 |     static int precedence(Operation op) {
 52 |         switch (op) {
 53 |             case Operation::NA: return 0; break;
 54 |             case Operation::Addition:
 55 |             case Operation::Subtraction: return 1; break;
 56 |             case Operation::Multiplication:
 57 |             case Operation::Division: return 2; break;
 58 |         }
 59 |         return 3;
 60 |     }
 61 |     BinaryOp(Operation oper, NodePtr lhs, NodePtr rhs) {
 62 |         op = oper;
 63 |         left = lhs;
 64 |         right = rhs;
 65 |     }
 66 |     double calc() override {
 67 |         switch (op) {
 68 |             case Operation::Addition: return left->calc() + right->calc(); break;
 69 |             case Operation::Subtraction: return left->calc() - right->calc(); break;
 70 |             case Operation::Multiplication: return left->calc() * right->calc(); break;
 71 |             case Operation::Division: return left->calc() / right->calc(); break;
 72 |         }
 73 |         return 0;
 74 |     }
 75 |     void visit(Visitor& visitor) override {
 76 |         visitor.visit(left.get());
 77 |         visitor.visit(this);
 78 |         visitor.visit(right.get());
 79 |     }
 80 | 
 81 |     Operation op = Operation::NA;
 82 |     NodePtr left;
 83 |     NodePtr right;
 84 | };
 85 | 
 86 | struct Variable : public Node {
 87 |     Variable(std::string_view varname) {
 88 |         name = varname;
 89 |     }
 90 |     std::string name;
 91 |     double value;
 92 |     double calc() override {
 93 |         return value;
 94 |     }
 95 |     void visit(Visitor& visitor) {
 96 |         visitor.visit(this);
 97 |     }
 98 | };
 99 | 
100 | //! Represents a function
101 | struct Function {
102 |     std::string name;
103 |     size_t num_args;
104 |     void* fnptr;
105 | };
106 | 
107 | //! Represents a function call
108 | struct FunctionCall : public Node {};
109 | 
110 | template <size_t N>
111 | struct FunctionCallWithArgs : public FunctionCall {
112 |     FunctionCallWithArgs(void* fn, const std::vector<NodePtr>& arguments) {
113 |         fnptr = fn;
114 |         for (unsigned j = 0; j < N; ++j) {
115 |             args[j] = arguments[j];
116 |         }
117 |     }
118 | 
119 |     //! arguments
120 |     std::array<NodePtr, N> args;
121 | 
122 |     //! the function to be called
123 |     void* fnptr;
124 | 
125 |     double calc() override {
126 |         std::array<double, N> values;
127 |         for (size_t j = 0; j < N; ++j) {
128 |             values[j] = args[j]->calc();
129 |         }
130 |         double value = callfn(fnptr, values.data(), N);
131 |         return value;
132 |     }
133 |     void visit(Visitor& visitor) override {
134 |         visitor.visit(this);
135 |         for (const NodePtr& arg : args) {
136 |             visitor.visit(arg.get());
137 |         }
138 |     }
139 | };
140 | 
141 | }  // namespace Interpreter
142 | 


--------------------------------------------------------------------------------
/CacheCheck/testTrash.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <atomic>
  3 | #include <thread>
  4 | #include <unistd.h>
  5 | #include <boost/atomic.hpp>
  6 | #include <mutex>
  7 | #include <vector>
  8 | #include <benchmark/benchmark.h>
  9 | #include "boost/smart_ptr/detail/spinlock.hpp"
 10 | #include <linux/perf_event.h>
 11 | #include <xmmintrin.h>
 12 | #include <boost/thread.hpp>
 13 | 
 14 | static inline void yield(uint64_t k) {
 15 |     if (k < 4) {
 16 |     }
 17 | 
 18 |     else if (k < 16) {
 19 |         __asm__ __volatile__("rep; nop" : : : "memory");
 20 |     }
 21 | 
 22 |     else if (k < 32 || k & 1) {
 23 |         sched_yield();
 24 |     } else {
 25 |         struct timespec rqtp = {0, 0};
 26 | 
 27 |         rqtp.tv_sec = 0;
 28 |         rqtp.tv_nsec = 1000;
 29 | 
 30 |         nanosleep(&rqtp, 0);
 31 |     }
 32 | }
 33 | 
 34 | struct BadSpinLock {
 35 |     std::atomic<bool> lock_ = {false};
 36 | 
 37 |     void lock() {
 38 |         while (lock_.exchange(true))
 39 |             ;
 40 |     }
 41 | 
 42 |     void unlock() {
 43 |         lock_.store(false);
 44 |     }
 45 | };
 46 | 
 47 | struct NaiveSpinLock {
 48 |     NaiveSpinLock() {
 49 |         val = 0;
 50 |     }
 51 | 
 52 |     inline bool try_lock() {
 53 |         return __sync_lock_test_and_set(&val, 1) == 0;
 54 |     }
 55 | 
 56 |     inline void lock() {
 57 |         while (!try_lock())
 58 |             ;
 59 |     }
 60 |     inline void unlock() {
 61 |         __sync_synchronize();
 62 |         __sync_lock_release(&val);
 63 |     }
 64 | 
 65 |     volatile uint32_t val __attribute__((aligned(16)));
 66 | };
 67 | 
 68 | struct NaiveWithBackoff {
 69 |     inline bool try_lock() {
 70 |         return __sync_lock_test_and_set(&val, 1) == 0;
 71 |     }
 72 | 
 73 |     inline void lock() {
 74 |         for (unsigned k = 0; !try_lock(); ++k) {
 75 |             yield(k);
 76 |         }
 77 |     }
 78 |     inline void unlock() {
 79 |         __sync_synchronize();
 80 |         __sync_lock_release(&val);
 81 |     }
 82 | 
 83 |     volatile uint32_t val __attribute__((aligned(16))) = 0;
 84 | };
 85 | 
 86 | struct ErikSpinLock {
 87 |     std::atomic<bool> lock_ = {false};
 88 |     void lock() {
 89 |         for (;;) {
 90 |             if (!lock_.exchange(true, std::memory_order_acquire)) {
 91 |                 break;
 92 |             }
 93 |             while (lock_.load(std::memory_order_relaxed)) {
 94 |                 __builtin_ia32_pause();
 95 |             }
 96 |         }
 97 |     }
 98 |     void unlock() {
 99 |         lock_.store(false, std::memory_order_release);
100 |     }
101 | };
102 | 
103 | /*** WEIRD ***/
104 | 
105 | struct AtomicSpinLock {
106 |     std::atomic_flag flag = ATOMIC_FLAG_INIT;
107 | 
108 |     void lock() {
109 |         while (flag.test_and_set(std::memory_order_acquire))
110 |             ;
111 |     }
112 |     void unlock() {
113 |         flag.clear(std::memory_order_release);
114 |     }
115 | };
116 | 
117 | struct AtomicWithBackoff {
118 |     std::atomic_flag flag = ATOMIC_FLAG_INIT;
119 | 
120 |     void lock() {
121 |         for (uint64_t k = 0; flag.test_and_set(std::memory_order_acquire); ++k) {
122 |             yield(k);
123 |         }
124 |     }
125 |     void unlock() {
126 |         flag.clear(std::memory_order_release);
127 |     }
128 | };
129 | 
130 | uint64_t counter = 0;
131 | 
132 | template <typename LockType>
133 | static uint64_t increment() {
134 |     uint64_t value = 0;
135 |     static LockType my_lock;
136 |     my_lock.lock();
137 |     value = counter++;
138 |     my_lock.unlock();
139 |     return value;
140 | }
141 | 
142 | template <typename LockType>
143 | static void entry(int* flag) {
144 |     uint64_t oldvalue = 0;
145 |     while (*flag) {
146 |         uint64_t newvalue = increment<LockType>();
147 |         if (newvalue <= oldvalue) {
148 |             std::cerr << "Error: value " << newvalue << " is less than " << oldvalue
149 |                       << std::endl;
150 |         }
151 |         oldvalue = newvalue;
152 |     }
153 | }
154 | 
155 | #include <pthread.h>
156 | static int getNumberOfAvailableCores() {
157 |     cpu_set_t cpuset;
158 |     CPU_ZERO(&cpuset);
159 |     int result = pthread_getaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
160 |     int counter = 0;
161 |     for (int j = 0; j < CPU_SETSIZE; j++) {
162 |         if (CPU_ISSET(j, &cpuset)) counter++;
163 |     }
164 |     return counter;
165 | }
166 | 
167 | static int numcores =
168 |     getNumberOfAvailableCores() - 1;  // boost::thread::physical_concurrency();
169 | 
170 | template <typename LockType>
171 | static void testLock(benchmark::State& state) {
172 |     int numthreads = state.range(0);
173 |     if (numthreads > numcores) {
174 |         numcores = numthreads;
175 |     }
176 | 
177 |     std::vector<int> flags(numthreads, 1);
178 |     std::vector<std::thread> threads;
179 |     for (int j = 0; j < numthreads; ++j) {
180 |         threads.emplace_back(entry<LockType>, &flags[j]);
181 |     }
182 | 
183 |     for (auto _ : state) {
184 |         increment<LockType>();
185 |     }
186 | 
187 |     for (int j = 0; j < numthreads; ++j) {
188 |         flags[j] = 0;
189 |         threads[j].join();
190 |     }
191 | }
192 | 
193 | BENCHMARK(testLock<BadSpinLock>)->RangeMultiplier(2)->Range(1, numcores);
194 | BENCHMARK(testLock<ErikSpinLock>)->RangeMultiplier(2)->Range(1, numcores);
195 | BENCHMARK(testLock<NaiveSpinLock>)->RangeMultiplier(2)->Range(1, numcores);
196 | BENCHMARK(testLock<NaiveWithBackoff>)->RangeMultiplier(2)->Range(1, numcores);
197 | BENCHMARK(testLock<AtomicSpinLock>)->RangeMultiplier(2)->Range(1, numcores);
198 | BENCHMARK(testLock<AtomicWithBackoff>)->RangeMultiplier(2)->Range(1, numcores);
199 | BENCHMARK(testLock<std::mutex>)->RangeMultiplier(2)->Range(1, numcores);
200 | BENCHMARK(testLock<boost::detail::spinlock>)->RangeMultiplier(2)->Range(1, numcores);
201 | BENCHMARK_MAIN();
202 | 


--------------------------------------------------------------------------------
/Calculator/Lexer.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "Pointer.h"
  4 | #include "TreeNodes.h"
  5 | 
  6 | #include <string_view>
  7 | #include <stack>
  8 | #include <optional>
  9 | 
 10 | namespace Interpreter {
 11 | 
 12 | //! Not technically a lexer but it takes care of the basic token
 13 | //! types like numbers
 14 | struct Lexer : public RefCounted {
 15 |     //! Just a type shortener
 16 |     using sviterator = std::string_view::iterator;
 17 | 
 18 |     Lexer() {
 19 |     }
 20 | 
 21 |     //! Resets the code and parser position
 22 |     void reset(std::string_view str) {
 23 |         code = str;
 24 |         it = code.begin();
 25 |     }
 26 | 
 27 |     //! The string with the expression to be parsed
 28 |     std::string_view code;
 29 | 
 30 |     //! The current position of the parser
 31 |     sviterator it;
 32 | 
 33 | private:
 34 |     //! A stack to restore positions in case of failure
 35 |     //! Being private will force the use of StackSaver (preferred)
 36 |     std::stack<sviterator> stack;
 37 | 
 38 |     //! Saves the current iterator and returns it
 39 |     sviterator save() {
 40 |         stack.push(it);
 41 |         return it;
 42 |     }
 43 |     //! Discards the top stack, committing the iterator as consequence
 44 |     sviterator commit() {
 45 |         sviterator tmp = stack.top();
 46 |         stack.pop();
 47 |         return tmp;
 48 |     }
 49 |     //! Restores the top of the stack as the current iterator. Returns the old current
 50 |     sviterator restore() {
 51 |         sviterator tmp = it;
 52 |         it = stack.top();
 53 |         stack.pop();
 54 |         return tmp;
 55 |     }
 56 | 
 57 | public:
 58 |     friend class StackSaver;
 59 | 
 60 |     //! Restores the stack if not committed before destruction
 61 |     struct StackSaver {
 62 |         StackSaver(Lexer* lexer) : _lexer(lexer) {
 63 |             _lexer->save();
 64 |             _committed = false;
 65 |         }
 66 |         void commit() {
 67 |             _committed = true;
 68 |         }
 69 |         ~StackSaver() {
 70 |             if (_committed)
 71 |                 _lexer->commit();
 72 |             else
 73 |                 _lexer->restore();
 74 |         }
 75 |         bool _committed;
 76 |         Lexer* _lexer;
 77 |     };
 78 | 
 79 |     //! Test a single character for a condition
 80 |     template <typename Fn>
 81 |     std::optional<char> test(Fn&& fn) {
 82 |         if (it != code.end()) {
 83 |             if (fn(*it)) {
 84 |                 return *it++;
 85 |             }
 86 |         }
 87 |         return {};
 88 |     };
 89 | 
 90 |     //! Skips until fn is false, returning the string if it's non-empty
 91 |     template <typename Fn>
 92 |     std::optional<std::string_view> skip(Fn&& fn) {
 93 |         sviterator start = it;
 94 |         for (; it != code.end(); ++it) {
 95 |             if (!fn(*it)) break;
 96 |         }
 97 |         if (it == start) return {};
 98 |         return std::string_view{start, size_t(it - start)};
 99 |     };
100 | 
101 |     size_t svtoul(std::string_view sv) {
102 |         size_t ival = 0;
103 |         for (char ch : sv) {
104 |             ival = 10 * ival + (ch - '0');
105 |         }
106 |         return ival;
107 |     }
108 | 
109 |     //! Parses an unsigned integer
110 |     std::optional<size_t> parseuint() {
111 |         if (auto s = skip(isdigit())) {
112 |             return {svtoul(s.value())};
113 |         }
114 |         return {};
115 |     }
116 | 
117 |     //! Parses a signed integer
118 |     std::optional<ssize_t> parseint() {
119 |         save();
120 |         bool neg = false;
121 |         if (auto sgn = test(isany("+-"))) {
122 |             neg = sgn.value() == '-';
123 |         }
124 |         if (auto uval = parseuint()) {
125 |             ssize_t ival = uval.value();
126 |             return neg ? -ival : ival;
127 |         }
128 |         restore();
129 |         return {};
130 |     }
131 | 
132 |     //! Skips whitespace
133 |     std::optional<std::string_view> skipws() {
134 |         return skip(isspace());
135 |     }
136 | 
137 |     //! Power of 10 of a number
138 |     static size_t ipow10(size_t val, size_t iexp) {
139 |         for (; iexp > 0; --iexp) val = val * 10;
140 |         return val;
141 |     }
142 |     //! Parses a double
143 |     std::optional<double> parsedouble() {
144 |         save();
145 |         bool neg = false;
146 |         if (auto sgn = test(isany("+-"))) {
147 |             neg = sgn.value() == '-';
148 |         }
149 |         if (auto sint = skip(isdigit())) {
150 |             size_t ival = svtoul(sint.value());  // convert the integer part
151 |             if (test(ischar('.'))) {
152 |                 if (auto sfrac = skip(isdigit())) {       // we have digits after period
153 |                     size_t fval = svtoul(sfrac.value());  // convert the fractional
154 |                     ssize_t len = sfrac.value().size();   // used as exponent below
155 |                     ival = ipow10(ival, len);             // scale the whole part
156 |                     double dval =
157 |                         (ival + fval) * pow(10, -len);  // compute the power of 10
158 |                     commit();
159 |                     return neg ? -dval : dval;
160 |                 }
161 |             }
162 |             // Just convert to double
163 |             double dval = ival;
164 |             commit();
165 |             return neg ? -dval : dval;
166 |         }
167 |         restore();
168 |         return {};
169 |     }
170 | 
171 |     //! Returns an arithmetic operator
172 |     std::optional<BinaryOp::Operation> arithop() {
173 |         if (auto s = test(isany("-+*/"))) {
174 |             switch (s.value()) {
175 |                 case '+': return BinaryOp::Operation::Addition; break;
176 |                 case '-': return BinaryOp::Operation::Subtraction; break;
177 |                 case '*': return BinaryOp::Operation::Multiplication; break;
178 |                 case '/': return BinaryOp::Operation::Division; break;
179 |             }
180 |         }
181 |         return {};
182 |     }
183 | };
184 | 
185 | }  // namespace Interpreter
186 | 


--------------------------------------------------------------------------------
/Calculator/Calculator.h:
--------------------------------------------------------------------------------
  1 | #include <cstdint>
  2 | #include <cstdio>
  3 | #include <cctype>
  4 | #include <string_view>
  5 | #include <stack>
  6 | #include <cmath>
  7 | #include <iostream>
  8 | 
  9 | #include "Pointer.h"
 10 | #include "TreeNodes.h"
 11 | #include "Predicates.h"
 12 | #include "Lexer.h"
 13 | #include "FunctionOps.h"
 14 | 
 15 | namespace Interpreter {
 16 | 
 17 | //! The Calculator has the high level grammar rules and inherits from
 18 | //! the Lexer which handles more low level char-by-char operations
 19 | struct Calculator : public Lexer {
 20 |     //! returns a node that holds a floating point value
 21 |     NodePtr dbl64() {
 22 |         if (auto dbl = parsedouble()) {
 23 |             return NodePtr(new Constant(dbl.value()));
 24 |         }
 25 |         return NodePtr();
 26 |     }
 27 | 
 28 |     //! Returns an expression node between parenthesis
 29 |     NodePtr parenthesis() {
 30 |         StackSaver saver(this);
 31 |         if (test(ischar('('))) {
 32 |             if (auto xp = expression()) {
 33 |                 if (test(ischar(')'))) {
 34 |                     saver.commit();
 35 |                     return NodePtr(new Parenthesis(xp));
 36 |                 }
 37 |             }
 38 |         }
 39 |         return NodePtr();
 40 |     }
 41 | 
 42 |     //! Returns a primitive node
 43 |     NodePtr primitive() {
 44 |         StackSaver saver(this);
 45 |         NodePtr lhs;
 46 |         if ((lhs = variable()) || (lhs = parenthesis()) || (lhs = dbl64())) {
 47 |             saver.commit();
 48 |         }
 49 |         return lhs;
 50 |     }
 51 | 
 52 |     //! Rearrange the tree such that operators will have the right precedence
 53 |     void adjustPrecedence(NodePtr& lhs, NodePtr& rhs, BinaryOp::Operation op) {
 54 |         auto binop = rhs.as<BinaryOp>();
 55 |         if (binop && (BinaryOp::precedence(binop->op) < BinaryOp::precedence(op))) {
 56 |             // Pointer<Node> tmp = binop->left;
 57 |             binop->left.reset(new BinaryOp(op, lhs, binop->left));
 58 |             lhs = rhs;
 59 |         } else {
 60 |             // Pointer<Node> tmp = lhs;
 61 |             lhs.reset(new BinaryOp(op, lhs, rhs));
 62 |         }
 63 |     }
 64 | 
 65 |     //! Returns an expression node, something that returns a value
 66 |     NodePtr expression() {
 67 |         StackSaver saver(this);
 68 |         skipws();
 69 |         if (auto lhs = primitive()) {
 70 |             while (auto op = arithop()) {
 71 |                 if (auto rhs = expression()) {
 72 |                     adjustPrecedence(lhs, rhs, op.value());
 73 |                 }
 74 |             }
 75 |             saver.commit();
 76 |             return lhs;
 77 |         }
 78 |         return {};
 79 |     }
 80 | 
 81 |     //! Returns a node that holds a value that can be changed
 82 |     NodePtr variable() {
 83 |         StackSaver saver(this);
 84 |         if (auto name = skip(isidentifier())) {
 85 |             Pointer<Variable>& var(_variable_map[std::string(name.value())]);
 86 |             if (!var) {
 87 |                 var = new Variable(name.value());
 88 |             }
 89 |             saver.commit();
 90 |             return var;
 91 |         }
 92 |         return {};
 93 |     }
 94 | 
 95 |     //! Creates an AST node representing a particular call into a function
 96 |     //! with the given name and arguments. Returns a null pointer if the
 97 |     //! function name does not exist or the arguments are the wrong size
 98 |     Pointer<FunctionCall> createFunctionCall(std::string_view name,
 99 |                                              const std::vector<NodePtr>& args) {
100 |         if (auto fn = findFunction(name)) {
101 |             if (args.size() == fn->num_args) {
102 |                 switch (fn->num_args) {
103 |                     case 0:
104 |                         return Pointer<FunctionCall>(
105 |                             new FunctionCallWithArgs<0>(fn->fnptr, args));
106 |                         break;
107 |                     case 1:
108 |                         return Pointer<FunctionCall>(
109 |                             new FunctionCallWithArgs<1>(fn->fnptr, args));
110 |                         break;
111 |                     case 2:
112 |                         return Pointer<FunctionCall>(
113 |                             new FunctionCallWithArgs<2>(fn->fnptr, args));
114 |                         break;
115 |                     case 3:
116 |                         return Pointer<FunctionCall>(
117 |                             new FunctionCallWithArgs<3>(fn->fnptr, args));
118 |                         break;
119 |                     case 4:
120 |                         return Pointer<FunctionCall>(
121 |                             new FunctionCallWithArgs<4>(fn->fnptr, args));
122 |                         break;
123 |                     case 5:
124 |                         return Pointer<FunctionCall>(
125 |                             new FunctionCallWithArgs<5>(fn->fnptr, args));
126 |                         break;
127 |                     case 6:
128 |                         return Pointer<FunctionCall>(
129 |                             new FunctionCallWithArgs<6>(fn->fnptr, args));
130 |                         break;
131 |                     case 7:
132 |                         return Pointer<FunctionCall>(
133 |                             new FunctionCallWithArgs<7>(fn->fnptr, args));
134 |                         break;
135 |                     case 8:
136 |                         return Pointer<FunctionCall>(
137 |                             new FunctionCallWithArgs<8>(fn->fnptr, args));
138 |                         break;
139 |                     case 9:
140 |                         return Pointer<FunctionCall>(
141 |                             new FunctionCallWithArgs<9>(fn->fnptr, args));
142 |                         break;
143 |                     case 10:
144 |                         return Pointer<FunctionCall>(
145 |                             new FunctionCallWithArgs<10>(fn->fnptr, args));
146 |                         break;
147 |                 }
148 |             }
149 |         }
150 |         return {};
151 |     }
152 | 
153 |     //! Returns a node that holds a function with arguments
154 |     Pointer<FunctionCall> function() {
155 |         StackSaver saver(this);
156 |         if (auto name = skip(isidentifier())) {
157 |             if (test(ischar('('))) {
158 |                 std::vector<NodePtr> args;
159 |                 while (auto xp = expression()) {
160 |                     args.push_back(xp);
161 |                 }
162 |                 if (test(ischar(')'))) {
163 |                     if (auto fn = createFunctionCall(name.value(), args)) {
164 |                         saver.commit();
165 |                         return fn;
166 |                     }
167 |                 }
168 |             }
169 |         }
170 |         return {};
171 |     }
172 | 
173 |     //! Returns a copy of the Function descriptor, if there is one
174 |     std::optional<Function> findFunction(std::string_view name) {
175 |         auto fn = _function_map.find(std::string(name));
176 |         if (fn != _function_map.end()) return fn->second;
177 |         return {};
178 |     }
179 | 
180 |     //! A hash map to hold our variables
181 |     using VariableMap = std::unordered_map<std::string, Pointer<Variable>>;
182 |     VariableMap _variable_map;
183 | 
184 |     //! A hash map to hold our functions
185 |     using FunctionMap = std::unordered_map<std::string, Function>;
186 |     FunctionMap _function_map = {{"log", Function{"log", 1, (void*)&::log}}};
187 | 
188 |     NodePtr parse(std::string_view code) {
189 |         reset(code);
190 |         return expression();
191 |     };
192 | };
193 | 
194 | }  // namespace Interpreter


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright [yyyy] [name of copyright owner]
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/FieldExtract/selectfields.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #include <array>
  3 | #include <cstdint>
  4 | #include <cstdlib>
  5 | #include <cstring>
  6 | #include <iostream>
  7 | #include <stdexcept>
  8 | 
  9 | #include "AsmCopyGen.h"
 10 | #include "AsmUtils.h"
 11 | 
 12 | // A random message with a sequence of fields
 13 | struct Message {
 14 |     uint8_t field_1;
 15 |     uint16_t field_2;
 16 |     uint32_t field_3;
 17 |     uint64_t field_4;
 18 |     int8_t field_5;
 19 |     int16_t field_6;
 20 |     int32_t field_7;
 21 |     int64_t field_8;
 22 |     int8_t field_9;
 23 |     int16_t field_10;
 24 |     int32_t field_11;
 25 |     int64_t field_12;
 26 |     int8_t field_13;
 27 |     int16_t field_14;
 28 |     int32_t field_15;
 29 |     int64_t field_16;
 30 |     int8_t field_17;
 31 |     int16_t field_18;
 32 |     int32_t field_19;
 33 |     int64_t field_20;
 34 |     uint8_t field_21;
 35 |     uint16_t field_22;
 36 |     uint32_t field_23;
 37 |     uint64_t field_24;
 38 |     int8_t field_25;
 39 |     int16_t field_26;
 40 |     int32_t field_27;
 41 |     int64_t field_28;
 42 |     int8_t field_29;
 43 |     int16_t field_30;
 44 |     int32_t field_31;
 45 |     int64_t field_32;
 46 |     int8_t field_33;
 47 |     int16_t field_34;
 48 |     int32_t field_35;
 49 |     int64_t field_36;
 50 |     int8_t field_37;
 51 |     int16_t field_38;
 52 |     int32_t field_39;
 53 |     int64_t field_40;
 54 | } __attribute__((packed));
 55 | 
 56 | struct MetaItem {
 57 |     uint32_t offset;
 58 |     uint32_t size;
 59 | };
 60 | 
 61 | using Bytes = AsmCopyGen::Bytes;
 62 | 
 63 | std::vector<MetaItem> metadata = {
 64 |     {offsetof(Message, field_1), sizeof(Message::field_1)},   {offsetof(Message, field_2), sizeof(Message::field_2)},
 65 |     {offsetof(Message, field_3), sizeof(Message::field_3)},   {offsetof(Message, field_4), sizeof(Message::field_4)},
 66 |     {offsetof(Message, field_5), sizeof(Message::field_5)},   {offsetof(Message, field_6), sizeof(Message::field_6)},
 67 |     {offsetof(Message, field_7), sizeof(Message::field_7)},   {offsetof(Message, field_8), sizeof(Message::field_8)},
 68 |     {offsetof(Message, field_9), sizeof(Message::field_9)},   {offsetof(Message, field_10), sizeof(Message::field_10)},
 69 |     {offsetof(Message, field_11), sizeof(Message::field_11)}, {offsetof(Message, field_12), sizeof(Message::field_12)},
 70 |     {offsetof(Message, field_13), sizeof(Message::field_13)}, {offsetof(Message, field_14), sizeof(Message::field_14)},
 71 |     {offsetof(Message, field_15), sizeof(Message::field_15)}, {offsetof(Message, field_16), sizeof(Message::field_16)},
 72 |     {offsetof(Message, field_17), sizeof(Message::field_17)}, {offsetof(Message, field_18), sizeof(Message::field_18)},
 73 |     {offsetof(Message, field_19), sizeof(Message::field_19)}, {offsetof(Message, field_20), sizeof(Message::field_20)},
 74 |     {offsetof(Message, field_21), sizeof(Message::field_21)}, {offsetof(Message, field_22), sizeof(Message::field_22)},
 75 |     {offsetof(Message, field_23), sizeof(Message::field_23)}, {offsetof(Message, field_24), sizeof(Message::field_24)},
 76 |     {offsetof(Message, field_25), sizeof(Message::field_25)}, {offsetof(Message, field_26), sizeof(Message::field_26)},
 77 |     {offsetof(Message, field_27), sizeof(Message::field_27)}, {offsetof(Message, field_28), sizeof(Message::field_28)},
 78 |     {offsetof(Message, field_29), sizeof(Message::field_29)}, {offsetof(Message, field_30), sizeof(Message::field_30)},
 79 |     {offsetof(Message, field_31), sizeof(Message::field_31)}, {offsetof(Message, field_32), sizeof(Message::field_32)},
 80 |     {offsetof(Message, field_33), sizeof(Message::field_33)}, {offsetof(Message, field_34), sizeof(Message::field_34)},
 81 |     {offsetof(Message, field_35), sizeof(Message::field_35)}, {offsetof(Message, field_36), sizeof(Message::field_36)},
 82 |     {offsetof(Message, field_37), sizeof(Message::field_37)}, {offsetof(Message, field_38), sizeof(Message::field_38)},
 83 |     {offsetof(Message, field_39), sizeof(Message::field_39)}, {offsetof(Message, field_40), sizeof(Message::field_40)}};
 84 | 
 85 | // Use metadata and the user input field list to create the custom assembly
 86 | Bytes genCopyAssembly(const std::vector<uint32_t> &ilist) {
 87 |     AsmCopyGen gen;
 88 |     uint32_t offset = 0;
 89 |     for (unsigned field : ilist) {
 90 |         if (field == 0 || field > metadata.size()) {
 91 |             throw std::out_of_range("Field number out of range: " + std::to_string(field));
 92 |         }
 93 |         MetaItem meta(metadata[field - 1]);
 94 |         gen.copyField(meta.offset, offset, meta.size);
 95 |         offset += meta.size;
 96 |     }
 97 |     Bytes res = gen.getBytes();
 98 |     res.push_back(0xc3);  // ret
 99 |     return res;
100 | }
101 | 
102 | Bytes genHotpatch(const std::vector<uint32_t> &ilist, uint32_t patchsize) {
103 |     AsmCopyGen gen;
104 |     uint32_t offset = 0;
105 |     for (unsigned field : ilist) {
106 |         if (field == 0 || field > metadata.size()) {
107 |             throw std::out_of_range("Field number out of range: " + std::to_string(field));
108 |         }
109 |         MetaItem meta(metadata[field - 1]);
110 |         gen.copyField(meta.offset, offset, meta.size);
111 |         offset += meta.size;
112 |     }
113 |     Bytes res = gen.getBytes();
114 |     uint32_t left = patchsize - res.size();
115 |     if (left < 5) {
116 |         for (uint32_t j = 0; j < left; ++j) {
117 |             res.push_back(0x90);  // nop
118 |         }
119 |     } else {
120 |         // Short jump
121 |         left -= 5;
122 |         Bytes v{0xe9, uint8_t(left), uint8_t(left >> 8), uint8_t(left >> 16), uint8_t(left >> 24)};
123 |         res.insert(res.end(), v.begin(), v.end());
124 |     }
125 |     return res;
126 | }
127 | 
128 | void genTrampoline(const std::vector<uint32_t> &ilist, void *callback, Bytes &res) {
129 |     AsmCopyGen gen;
130 |     uint32_t offset = 0;
131 |     for (unsigned field : ilist) {
132 |         if (field == 0 || field > metadata.size()) {
133 |             throw std::out_of_range("Field number out of range: " + std::to_string(field));
134 |         }
135 |         MetaItem meta(metadata[field - 1]);
136 |         gen.copyField(meta.offset, offset, meta.size);
137 |         offset += meta.size;
138 |     }
139 |     res = gen.getBytes();
140 | 
141 |     // Add the jump back
142 |     Bytes v({0xe9, 0, 0, 0, 0});
143 |     res.insert(res.end(), v.begin(), v.end());
144 |     uint8_t *endptr = res.data() + res.size();
145 |     uint64_t off = uint64_t(callback) - uint64_t(endptr);
146 |     uint8_t *jump = endptr - 4;
147 |     jump[0] = uint8_t(off);
148 |     jump[1] = uint8_t(off >> 8);
149 |     jump[2] = uint8_t(off >> 16);
150 |     jump[3] = uint8_t(off >> 24);
151 | }
152 | 
153 | // Make the copy in the traditional way using metadata and offsets
154 | void copyVanilla(uint8_t *dst, uint8_t *src, const std::vector<uint32_t> &ilist) {
155 |     uint32_t offset = 0;
156 |     for (unsigned field : ilist) {
157 |         if (field == 0 || field > metadata.size()) {
158 |             throw std::out_of_range("Field number out of range: " + std::to_string(field));
159 |         }
160 |         MetaItem meta(metadata[field - 1]);
161 |         memcpy(&dst[offset], &src[meta.offset], meta.size);
162 |         offset += meta.size;
163 |     }
164 | }
165 | 
166 | extern "C" {
167 | extern uint8_t hotpatch[];
168 | extern uint8_t hotpatch_end[];
169 | extern uint8_t trampoline[];
170 | };
171 | 
172 | void compare(const std::string &msg, const std::vector<uint8_t> &golden, const std::vector<uint8_t> &bytes) {
173 |     if (golden.size() != bytes.size()) {
174 |         std::cout << msg << " Error: vector size is " << bytes.size() << " expected " << golden.size() << std::endl;
175 |         return;
176 |     }
177 |     for (uint32_t j = 0; j < golden.size(); ++j) {
178 |         if (golden[j] != bytes[j]) {
179 |             std::cout << msg << " Error on byte " << j << " got " << uint32_t(bytes[j]) << " expected "
180 |                       << uint32_t(golden[j]) << std::endl;
181 |             std::cout << "Golden:\n";
182 |             for (uint32_t k = 0; k < golden.size(); ++k) {
183 |                 char str[16];
184 |                 sprintf(str, "%02x ", golden[k]);
185 |                 std::cout << str;
186 |             }
187 |             std::cout << std::endl;
188 |             std::cout << "Bytes:\n";
189 |             for (uint32_t k = 0; k < golden.size(); ++k) {
190 |                 char str[16];
191 |                 sprintf(str, "%02x ", bytes[k]);
192 |                 std::cout << str;
193 |             }
194 |             std::cout << std::endl;
195 |             std::exit(0);
196 |             return;
197 |         }
198 |     }
199 | }
200 | 
201 | int main(int argc, char *argv[]) {
202 |     // Sanity
203 |     if (argc < 2) {
204 |         std::cout << "Usage: selectfields <num> [ <num> ... ]" << std::endl;
205 |         std::cout << "Pass a list of field numbers that should be copied into the "
206 |                      "output messages in any order. "
207 |                   << std::endl;
208 |         std::cout << "Valid field numbers from 1 to " << metadata.size() << std::endl;
209 |         std::cout << "Example: 1 2 3 4 15 20" << std::endl;
210 |         return 0;
211 |     }
212 | 
213 |     // Read input vector from user
214 |     std::vector<unsigned> fields;
215 |     for (uint32_t j = 1; j < argc; ++j) {
216 |         fields.push_back(::atoi(argv[j]));
217 |     }
218 | 
219 |     // Hotpatch first
220 |     uint32_t hotpatch_size = intptr_t(hotpatch_end) - intptr_t(hotpatch);
221 |     std::cout << "Hotpatch size:" << hotpatch_size << std::endl;
222 |     Bytes hp = genHotpatch(fields, hotpatch_size);
223 |     makeExecutable(hotpatch, hotpatch_size);
224 |     memcpy((void *)&hotpatch[0], hp.data(), hp.size());
225 |     std::cout << "Hotpatch:" << std::endl;
226 |     for (uint32_t j = 0; j < hp.size(); ++j) {
227 |         char str[32];
228 |         sprintf(str, "%02x ", hotpatch[j]);
229 |         std::cout << str << " ";
230 |     }
231 |     std::cout << std::endl;
232 | 
233 |     // Create custom generated assembly for the given fields
234 |     Bytes proc = genCopyAssembly(fields);
235 |     makeExecutable(proc.data(), proc.size());
236 | 
237 |     // Assign pointer to function
238 |     using CopyFieldsFn = void(Message *, uint8_t *);
239 |     CopyFieldsFn *copyfn = reinterpret_cast<CopyFieldsFn *>(proc.data());
240 | 
241 |     // Setup trampoline
242 |     Bytes tramp;
243 |     uint8_t *trampend = &trampoline[5];  // next byte after jump
244 |     genTrampoline(fields, trampend, tramp);
245 |     makeExecutable(tramp.data(), tramp.size());
246 |     uint64_t troffset = uint64_t(tramp.data()) - uint64_t(trampend);
247 |     trampoline[0] = 0xe9;  // jumpq 32-bit
248 |     trampoline[1] = uint8_t(troffset);
249 |     trampoline[2] = uint8_t(troffset >> 8);
250 |     trampoline[3] = uint8_t(troffset >> 16);
251 |     trampoline[4] = uint8_t(troffset >> 24);
252 | 
253 |     // Create a typical message, fill fields
254 |     Message msg;
255 |     std::memset(&msg, 0, sizeof(msg));
256 |     msg.field_1 = 1;
257 |     msg.field_2 = 2;
258 |     msg.field_3 = 3;
259 |     msg.field_4 = 4;
260 |     msg.field_5 = 5;
261 |     msg.field_6 = 6;
262 |     msg.field_7 = 7;
263 |     msg.field_8 = 8;
264 |     msg.field_9 = 9;
265 |     msg.field_10 = 10;
266 |     msg.field_11 = 11;
267 |     msg.field_12 = 12;
268 |     msg.field_13 = 13;
269 |     msg.field_14 = 14;
270 |     msg.field_15 = 15;
271 |     msg.field_16 = 16;
272 |     msg.field_17 = 17;
273 |     msg.field_18 = 18;
274 |     msg.field_19 = 19;
275 |     msg.field_20 = 20;
276 |     msg.field_21 = 21;
277 |     msg.field_22 = 22;
278 |     msg.field_23 = 23;
279 |     msg.field_24 = 24;
280 |     msg.field_25 = 25;
281 |     msg.field_26 = 26;
282 |     msg.field_27 = 27;
283 |     msg.field_28 = 28;
284 |     msg.field_29 = 29;
285 |     msg.field_30 = 30;
286 |     msg.field_31 = 31;
287 |     msg.field_32 = 32;
288 |     msg.field_33 = 33;
289 |     msg.field_34 = 34;
290 |     msg.field_35 = 35;
291 |     msg.field_36 = 36;
292 |     msg.field_37 = 37;
293 |     msg.field_38 = 38;
294 |     msg.field_39 = 39;
295 |     msg.field_40 = 40;
296 | 
297 |     // Create an array to hold the results
298 |     // This example is current not going to check the size but this should be
299 |     // done using the metadata provided
300 |     // So this *might* crash if you are a smart ass and pass a large enough list
301 |     // Fill with some notorious values (0xff)
302 |     std::vector<uint8_t> bytes(4096, 0xff);
303 |     std::vector<uint8_t> golden = bytes;
304 | 
305 |     // Loop over a number of times doing copies and gathering
306 |     // micro-benchmarking statistics
307 |     double sum1 = 0;
308 |     double sum2 = 0;
309 |     double sum3 = 0;
310 |     double sum4 = 0;
311 |     double sum5 = 0;
312 |     const unsigned numloops = 1000000;
313 |     bool ok = false;
314 |     for (uint32_t j = 0; j < numloops; ++j) {
315 |         // Test "normal" way
316 |         {
317 |             std::fill(bytes.begin(), bytes.end(), 0xff);
318 |             uint64_t t0 = tic();
319 |             copyVanilla(bytes.data(), (uint8_t *)&msg, fields);
320 |             uint64_t t1 = toc();
321 |             sum1 += (t1 - t0);
322 |             golden = bytes;
323 |         }
324 | 
325 |         // Test with hotpatch
326 |         {
327 |             std::fill(bytes.begin(), bytes.end(), 0xff);
328 |             uint64_t t0 = tic();
329 |             asm(R"( 
330 |             .globl hotpatch
331 |             hotpatch:
332 |             .zero 512
333 |             .globl hotpatch_end 
334 |             hotpatch_end:    
335 |             )" ::"D"(&msg),
336 |                 "S"(bytes.data())
337 |                 : "rax", "memory");
338 |             uint64_t t1 = toc();
339 |             sum2 += (t1 - t0);
340 | 
341 |             compare("Hotpatch", golden, bytes);
342 |         }
343 | 
344 |         // Test with trampoline
345 |         {
346 |             std::fill(bytes.begin(), bytes.end(), 0xff);
347 |             uint64_t t0 = tic();
348 |             asm(R"(
349 |             .globl trampoline
350 |             trampoline:
351 |             .zero 5
352 |             )" ::"D"(&msg),
353 |                 "S"(bytes.data())
354 |                 : "rax", "memory");
355 |             uint64_t t1 = toc();
356 |             sum5 += (t1 - t0);
357 | 
358 |             compare("Trampoline", golden, bytes);
359 |         }
360 | 
361 |         // Test with pointer
362 |         {
363 |             std::fill(bytes.begin(), bytes.end(), 0xff);
364 |             uint64_t t0 = tic();
365 |             copyfn(&msg, bytes.data());
366 |             uint64_t t1 = toc();
367 |             sum3 += (t1 - t0);
368 |             compare("Pointer", golden, bytes);
369 |         }
370 | 
371 |         // Empty test
372 |         {
373 |             uint64_t t0 = tic();
374 |             asm("" ::: "memory");
375 |             uint64_t t1 = toc();
376 |             sum4 += (t1 - t0);
377 |         }
378 |     }
379 | 
380 |     // Display statistics
381 |     std::cout << "Average times:" << std::endl;
382 |     std::cout << "\tVanilla   :" << (sum1 - sum4) / numloops << std::endl;
383 |     std::cout << "\tHotpatch:  " << (sum2 - sum4) / numloops << std::endl;
384 |     std::cout << "\tPointer:   " << (sum3 - sum4) / numloops << std::endl;
385 |     std::cout << "\tTrampoline:" << (sum5 - sum4) / numloops << std::endl;
386 |     std::cout << std::endl;
387 | 
388 | // Printout end result for peace of mind
389 | #if 0 
390 |     std::cout << "Bytes:\n\t";
391 |     for (uint8_t val : bytes) {
392 |         char str[16];
393 |         ::sprintf(str, "%02x ", val);
394 |         std::cout << str;
395 |     }
396 |     std::cout << std::endl;
397 | #endif
398 |     return 0;
399 | }


--------------------------------------------------------------------------------