Make this moderately less embarrassing

Author: tokenrove

.gitignore

@@ -1,2 +1,3 @@
 *~
 *.o
+generated/

Makefile

@@ -33,40 +33,47 @@ help:
 
 THIS_RUN := results-$(shell date +%Y%m%d-%H%M%S)
 
-CFLAGS ?= -Wall -pedantic -std=gnu11 -O3 -g
+# Note that you may have to change -DHAVE_GETRANDOM to -DHAVE_RDRAND
+# depending on what kernel and hardware you have.
+CFLAGS ?= -Wall -pedantic -std=gnu11 -I. -Igenerated -O3 -g -DHAVE_GETRANDOM
 LDFLAGS ?= -lm
 
 all: run-experiment
-run-experiment: clean-old-results generate-files run-trials analyze-results
-	mkdir $(shell hostname)-$(shell date +%y%m%d)
+run-experiment: clean generate-files run-trials analyze-results
+
+generated/:
+	mkdir -p generated/
 
 %.o: %.c
 	$(CC) $(CFLAGS) -DN_ENTRIES=$(N_ENTRIES) -o $@ -c $^
 
 HEADER_FILES := dispatch.h dummy-fns.h
-DRIVER_OBJS := main.o dummy-fns.o ns-$(CALL_DISTRIBUTION).o
-$(PLATFORM)-linear: $(PLATFORM)-linear.o $(DRIVER_OBJS)
-$(PLATFORM)-binary: $(PLATFORM)-binary.o $(DRIVER_OBJS)
-$(PLATFORM)-vtable: $(PLATFORM)-vtable.o $(DRIVER_OBJS)
-c-switch: c-switch.o $(DRIVER_OBJS)
-c-vtable: c-vtable.o $(DRIVER_OBJS)
+DRIVER_OBJS := main.o generated/dummy-fns.o ns-$(CALL_DISTRIBUTION).o xoroshiro128plus.o
+$(PLATFORM)-linear: generated/$(PLATFORM)-linear.o $(DRIVER_OBJS)
+$(PLATFORM)-binary: generated/$(PLATFORM)-binary.o $(DRIVER_OBJS)
+$(PLATFORM)-vtable: generated/$(PLATFORM)-vtable.o $(DRIVER_OBJS)
+c-switch: generated/c-switch.o $(DRIVER_OBJS)
+c-vtable: generated/c-vtable.o $(DRIVER_OBJS)
 
 %.c: $(HEADER_FILES)
 
 $(TRIALS):
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+	$(CC) -static $(CFLAGS) -o $@ $^ $(LDFLAGS)
 
-GENERATED_FILES := dummy-fns.h dummy-fns.c $(PLATFORM)-linear.s $(PLATFORM)-binary.s $(PLATFORM)-vtable.s c-switch.c c-vtable.c
+GENERATED_FILES := generated/dummy-fns.h generated/dummy-fns.c \
+	generated/$(PLATFORM)-linear.s generated/$(PLATFORM)-binary.s \
+	generated/$(PLATFORM)-vtable.s generated/c-switch.c generated/c-vtable.c
 
 $(GENERATED_FILES): generator
 
 GENERATOR_FLAGS=--fn-work=$(FN_WORK) --fn-alignment=$(FN_ALIGNMENT) --n-entries=$(N_ENTRIES)
-generate-files: generator
+generate-files: generated/ generator
 	./generator $(GENERATOR_FLAGS) $(GENERATED_FILES)
 
 run-trials: $(shell shuf -e $(TRIALS))
 	for i in $^; do \
 	  echo running $$i in $(THIS_RUN); \
+	  perf stat -r $(N_RUNS) ./$$i $(N_DISPATCHES) ||:; \
 	done
 
 clean:

README.md

@@ -0,0 +1,20 @@
+
+*Do not use this code!*
+
+This is some benchmarking code I wrote several years ago and came back
+to a few times, in support of [a blog post I finally published].  One
+of the reasons I delayed finishing that post so long was that I
+realized *the methodology used here is flawed*.  It's enough for us to
+make a (weak) point, but shouldn't be taken seriously.
+
+I'll do something like this again soon, and hopefully that will set a
+better example.
+
+There is both a Makefile that will do things, and a Python program
+(`run-experiment.py`) that will do similar things.  The Makefile is
+broken but convenient.  Many of the options for programs here don't
+actually do anything.
+
+You have been warned.
+
+[a blog post I finally published]: http://www.cipht.net/2017/10/03/are-jump-tables-always-fastest.html

dispatch.h

@@ -1,5 +1,8 @@
+#include <stdint.h>
 
 extern void dispatch(int state);
 extern int next_state(void);
 
 extern int state_trk;
+
+extern uint64_t next(void);

generator

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 
-# parse arguments (tunable parameters)
+import argparse
+import os.path
 
 
 def emit_dummy_fns(out, options):
@@ -9,7 +10,7 @@ def emit_dummy_fns(out, options):
 
 """
     for i in range(options.n):
-        s += "void fn_{0}(void) {{ state_trk += {0}; }}\n".format(i)
+        s += "void fn_{0}(void) {{ state_trk += {0};  __builtin_ia32_clflush(dispatch); }}\n".format(i)
     out.write(s)
 
 def emit_dummy_fns_h(out, options):
@@ -103,7 +104,7 @@ def emit_binary_amd64(out, options):
     def generate_binary_calls(l, i, n, last_comparison):
         if n <= 1: return 'jmp fn_{0}'.format(i)
         if n == 2: return """{2}
-	je fn_{0}
+        je fn_{0}
         jmp fn_{1}""".format(i, i+1, '' if last_comparison == i else "cmp ${0}, %edi".format(i))
         if n == 3: return """{3}
         je fn_{0}
@@ -126,12 +127,11 @@ dispatch:
 	{}
 	call abort\n""".format(generate_binary_calls("", 0, options.n, None)))
 
-import argparse
 
 def main():
     parser = argparse.ArgumentParser()
-    # parser.add_argument('--fn-work', choices=['none', 'clflush'],
-    #                     help='what kind of work dummy functions do (none, clflush)')
+    parser.add_argument('--fn-work', choices=['none', 'clflush', 'memcpy'],
+                        help='what kind of work dummy functions do (none, clflush)')
     parser.add_argument('--cache-flush', choices=['none', 'I', 'D', 'ID'],
                         help='whether dummy functions flush cache')
     parser.add_argument('--fn-alignment',
@@ -153,7 +153,7 @@ def main():
          'x86_64-vtable.s': lambda f: emit_vtable_amd64(f, options)}
     for x in options.file:
         with open(x, "w") as f:
-            t[x](f)
+            t[os.path.basename(x)](f)
     exit(0)
 
 if __name__ == '__main__': main()

main.c

@@ -1,15 +1,40 @@
 /* Common entry point for generated code.
  */
 
+#include "dispatch.h"
 #include <string.h>
 #include <stdlib.h>
-#include "dispatch.h"
 
 int state_trk = 0;
+extern uint64_t xorshift_seed[2];
+
+static void seed(void);
+
+#if defined(HAVE_RDRAND)
+static void seed(void)
+{
+    asm volatile("0:   rdrand %0; jnc 0b" : "=r" (xorshift_seed[0]));
+    asm volatile("0:   rdrand %0; jnc 0b" : "=r" (xorshift_seed[1]));
+}
+
+#elif defined(HAVE_GETRANDOM)
+#include <linux/random.h>
+#include <sys/syscall.h>
+
+static void seed(void)
+{
+    ssize_t rv = syscall(SYS_getrandom, xorshift_seed, sizeof(xorshift_seed), 0);
+    if (rv != sizeof(xorshift_seed)) abort();
+}
+#else
+#error "Need a way to seed the PRNG"
+#endif
 
 int main(int argc, char **argv)
 {
     if (argc < 2) abort();
+
+    seed();
     size_t count = atoi(argv[1]);
     while (--count)
         dispatch(next_state());

ns-pareto.c

@@ -5,7 +5,7 @@
 
 int next_state(void)
 {
-    if (fmod((double)rand(), 100.0d) < 80.0d)
-        return 42 % N_ENTRIES;
-    return rand() % N_ENTRIES;  /* you should never do this. */
+    if (next() % 10 < 8)
+        return 0;
+    return next() % N_ENTRIES;  /* you should never do this. */
 }

ns-uniform.c

@@ -3,5 +3,5 @@
 
 int next_state(void)
 {
-    return rand() % N_ENTRIES;  /* you should never do this. */
+    return next() % N_ENTRIES;  /* you should never do this. */
 }

xoroshiro128plus.c

@@ -0,0 +1,27 @@
+/*  Written in 2016 by David Blackman and Sebastiano Vigna ([email protected])
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+#include <stdint.h>
+
+uint64_t xorshift_seed[2];
+
+static inline uint64_t rotl(const uint64_t x, int k) {
+	return (x << k) | (x >> (64 - k));
+}
+
+uint64_t next(void) {
+	const uint64_t s0 = xorshift_seed[0];
+	uint64_t s1 = xorshift_seed[1];
+	const uint64_t result = s0 + s1;
+
+	s1 ^= s0;
+	xorshift_seed[0] = rotl(s0, 55) ^ s1 ^ (s1 << 14); // a, b
+	xorshift_seed[1] = rotl(s1, 36); // c
+
+	return result;
+}