shithub: 9bench

Download patch

ref: 3f899338e54ae7ed97d980838a0c40e350718405
author: Ori Bernstein <ori@eigenstate.org>
date: Tue Oct 27 20:22:07 EDT 2020

initial commit

--- /dev/null	Thu Dec 31 12:39:09 2020
+++ b/bench.h	Tue Oct 27 20:22:07 2020
@@ -0,0 +1,40 @@
+#pragma lib	"libbench.a"
+#pragma src	"/sys/src/libbench"
+
+typedef struct BItem BItem;
+typedef struct BResult BResult;
+typedef struct B B;
+
+typedef void (*BFn)(B* b);
+
+// single benchmark function
+struct BItem
+{
+	char *name;
+	BFn fn;
+};
+
+// result of benchmarking
+struct BResult
+{
+	int N;
+	vlong ns;
+	uvlong cycles;
+};
+
+// type passed to bench functions
+struct B
+{
+	int N;
+	vlong start;	/* start ns */
+	vlong ns;	/* duration */
+	uvlong scycles;	/* start cycles */
+	uvlong ecycles;	/* end cycles */
+	uvlong bcycles;	/* best cycles */
+	BItem item;
+};
+
+// public api
+void benchinit(void);
+void bench(char *name, BFn);
+void benchitems(BItem[], int);
--- /dev/null	Thu Dec 31 12:39:09 2020
+++ b/mkfile	Tue Oct 27 20:22:07 2020
@@ -0,0 +1,29 @@
+</$objtype/mkfile
+
+TARG=sysbench
+OFILES=\
+	run.$O\
+	test.$O\
+
+HFILES=\
+	bench.h\
+
+CLEANFILES=$O.test $O.true
+
+</sys/src/cmd/mkone
+
+%.$O:	%.c
+	$CC -pFTVw $stem.c
+
+install:V:	$LIB
+	cp bench.h /sys/include/bench.h
+
+bench:	$O.out $O.true
+	$O.out
+
+true.$O:	true.c
+	$CC $CFLAGS true.c
+
+$O.true:	true.$O
+	$LD -o $target $prereq
+
--- /dev/null	Thu Dec 31 12:39:09 2020
+++ b/run.c	Tue Oct 27 20:22:07 2020
@@ -0,0 +1,226 @@
+#include <u.h>
+#include <libc.h>
+#include <bench.h>
+
+#define BENCHTIME (1000000000)	/* 1s in ns */
+
+uvlong boverhead;
+
+static int
+min(int x, int y)
+{
+        if(x > y) {
+                return y;
+        }
+        return x;
+}
+
+static int
+max(int x, int y)
+{
+        if(x < y) {
+                return y;
+        }
+        return x;
+}
+
+// run the benchmarking function once, looping n times
+static void
+benchrunn(B *b, int n)
+{
+
+	b->N = n;
+
+	// reset
+	b->start = nsec();
+	b->ns = 0;
+	cycles(&b->scycles);
+
+	b->item.fn(b);
+
+	// stop
+	cycles(&b->ecycles);
+	b->ns += nsec() - b->start;
+	b->bcycles += b->ecycles - b->scycles - boverhead;
+}
+
+static vlong
+nsperop(B *b)
+{
+	if(b->N <= 0)
+		return 0;
+
+	return b->ns / (vlong)b->N;
+}
+
+static uvlong
+cyperop(B *b)
+{
+	if(b->N <= 0)
+		return 0;
+
+	return b->bcycles / (uvlong)b->N;
+}
+
+static int
+rounddown10(int n)
+{
+	int tens, result, i;
+
+	tens = 0;
+
+	while(n >= 10) {
+		n = n / 10;
+		tens++;
+	}
+
+	result = 1;
+
+	for(i = 0; i < tens; i++) {
+		result *= 10;
+	}
+
+	return result;
+}
+
+static int
+roundup(int n)
+{
+	int base;
+
+	base = rounddown10(n);
+
+	if(n <= base)
+		return base;
+	if(n <= 2*base)
+		return 2*base;
+	if(n <= 5*base)
+		return 5*base;
+
+	return 10*base;
+}
+
+// run the benchmark for one function
+static BResult
+benchrun(B *b)
+{
+	int n, last;
+	vlong d;
+	BResult res;
+
+	n = 1;
+
+	benchrunn(b, n);
+
+	d = BENCHTIME;
+
+	while(b->ns < d && n < 1000000000) {
+		last = n;
+		if(nsperop(b) == 0) {
+			n = 1000000000;
+		} else {
+			n = (int) d/nsperop(b);
+		}
+
+		n = max(min(n+n/2, 100*last), last+1);
+
+		n = roundup(n);
+		benchrunn(b, n);
+	}
+
+	res.N = b->N;
+	res.ns = b->ns;
+	res.cycles = b->bcycles;
+
+	return res;
+}
+
+static void
+benchres(BResult *res)
+{
+	char nsop[32];
+	char cyop[32];
+	vlong nsperop;
+	uvlong cyperop;
+
+	if(res->N <= 0) {
+		nsperop = 0;
+		cyperop = 0;
+	} else {
+		nsperop = res->ns / (vlong)res->N;
+		cyperop = res->cycles / (uvlong)res->N;
+	}
+
+	snprint(nsop, sizeof(nsop), "%10lld    ns/op", nsperop);
+	snprint(cyop, sizeof(cyop), "%10ulld    cy/op", cyperop);
+
+	if(res->N > 0 && nsperop < 100) {
+		if(nsperop < 10)
+			snprint(nsop, sizeof(nsop), "%13.2f ns/op", (double)res->ns / (double)res->N);
+		else
+			snprint(nsop, sizeof(nsop), "%12.1f  ns/op", (double)res->ns / (double)res->N);
+	}
+
+	if(res->N > 0 && cyperop < 100) {
+		if(cyperop < 10)
+			snprint(cyop, sizeof(cyop), "%13.2f cy/op", (double)res->cycles / (double)res->N);
+		else
+			snprint(cyop, sizeof(cyop), "%12.1f  cy/op", (double)res->cycles / (double)res->N);
+	}
+
+	print("%10d N\t%s\t%s\n", res->N, nsop, cyop);
+}
+
+/*
+ * public api
+*/
+
+// setup. currently only calculates cycles() overhead.
+// not strictly necessary, but will give better cycle counts.
+void
+benchinit(void)
+{
+	int at;
+	uvlong a, b;
+
+	/* figure out cycles overhead */
+	boverhead = -1;
+
+	for(at = 0; at < 1000000; at++) {
+		cycles(&a);
+		cycles(&b);
+		if(boverhead > b - a)
+			boverhead = b - a;
+	}
+
+}
+
+// bench a single function
+void
+bench(char *name, BFn fn)
+{
+	B b;
+	BResult res;
+
+	memset(&b, 0, sizeof(B));
+	memset(&res, 0, sizeof(BResult));
+
+	b.item.name = name;
+	b.item.fn = fn;
+
+	print("%16s\t", name);
+	res = benchrun(&b);
+
+	benchres(&res);
+}
+
+// bench an array of functions
+void
+benchitems(BItem items[], int len)
+{
+	int i;
+
+	for(i = 0; i < len; i++) {
+		bench(items[i].name, items[i].fn);
+	}
+}
--- /dev/null	Thu Dec 31 12:39:09 2020
+++ b/test.c	Tue Oct 27 20:22:07 2020
@@ -0,0 +1,232 @@
+#include <u.h>
+#include <libc.h>
+#include <bench.h>
+
+typedef struct SLock SLock;
+struct SLock {
+	long	state;
+	long	sem;
+};
+
+int	casl(long *, long, long);
+
+void
+slock(SLock *s)
+{
+	int i;
+
+	for(i = 0; i < 100; i++){
+		if(casl(&s->state, 0, 1))
+			return;
+		sleep(0);
+	}
+	if(ainc(&s->state) == 1)
+		return;
+	while(semacquire(&s->sem, 1) == -1)
+		/* retry */;
+}
+
+void
+sunlock(SLock *s)
+{
+	if(adec(&s->state) == 0)
+		return;
+	semrelease(&s->sem, 1);
+}
+
+void
+benchmallocfree32(B *b)
+{
+	int i;
+
+	for(i = 0; i < b->N; i++) {
+		free(malloc(32));
+	}
+}
+
+void
+benchrand(B *b)
+{
+	int i;
+
+	for(i = 0; i < b->N; i++) {
+		(void)rand();
+	}
+}
+
+void
+benchtruerand(B *b)
+{
+	int i;
+
+	for(i = 0; i < b->N; i++) {
+		(void)truerand();
+	}
+}
+
+void
+benchinc(B *b)
+{
+	int i;
+	long inc;
+
+	inc = 0;
+	for(i = 0; i < b->N; i++) {
+		inc++;
+	}
+}
+
+void
+benchainc(B *b)
+{
+	int i;
+	long inc;
+
+	for(i = 0; i < b->N; i++) {
+		ainc(&inc);
+	}
+}
+
+void
+benchfork(B *b)
+{
+	int i;
+	
+	for(i = 0; i < b->N; i++){
+		if(!rfork(RFPROC|RFMEM))
+			exits(nil);
+		waitpid();
+	}
+}
+void
+benchmfork(B *b)
+{
+	int i;
+	
+	for(i = 0; i < b->N; i++){
+		if(!fork())
+			exits(nil);
+		waitpid();
+	}
+}
+
+
+void
+benchforkexecl(B *b)
+{
+	int i;
+	
+	for(i = 0; i < b->N; i++){
+		switch(fork()){
+		case -1:
+			abort();
+		case 0:
+			execl("./6.true", "6.true", nil);
+			print("exec: %r");
+			abort();
+		default:
+			waitpid();
+		}
+	}
+}
+
+Lock l;
+QLock q;
+SLock s;
+int count;
+
+void
+hammerlock(int n)
+{
+	int i;
+
+	for(i = 0; i < n; i++){
+		lock(&l);
+		count++;
+		unlock(&l);
+	}
+}
+
+void
+hammerqlock(int n)
+{
+	int i;
+
+	for(i = 0; i < n; i++){
+		qlock(&q);
+		count++;
+		qunlock(&q);
+	}
+}
+
+void
+hammerslock(int n)
+{
+	int i;
+
+	for(i = 0; i < n; i++){
+		slock(&s);
+		count++;
+		sunlock(&s);
+	}
+}
+
+void
+lockbench(void (*fn)(int), int nthr, int ninc)
+{
+	int i, p;
+
+	for(i = 0; i < nthr; i++){
+		if((p = rfork(RFPROC|RFMEM)) == -1)
+			sysfatal("rfork: %r");
+		if(p == 0){
+			(*fn)(ninc);
+			exits(nil);
+		}
+	}
+	for(i = 0; i < nthr; i++)
+		free(wait());
+}
+
+#define LKB(nthr) \
+	void benchlock##nthr(B *b){lockbench(hammerlock, nthr, b->N);} \
+	void benchqlock##nthr(B *b){lockbench(hammerqlock, nthr, b->N);} \
+	void benchslock##nthr(B *b){lockbench(hammerslock, nthr, b->N);}
+
+LKB(1)
+LKB(4)
+LKB(32)
+LKB(512)
+
+void
+main(void)
+{
+	benchinit();
+
+	bench("mallocfree32", benchmallocfree32);
+	bench("rand", benchrand);
+	bench("truerand", benchtruerand);
+	bench("inc", benchinc);
+	bench("ainc", benchainc);
+	bench("mfork", benchmfork);
+	bench("fork", benchfork);
+	bench("forkexecl", benchforkexecl);
+
+	bench("lock1", benchlock1);
+	bench("qlock1", benchqlock1);
+	bench("slock1", benchslock1);
+
+	bench("lock4", benchlock4);
+	bench("qlock4", benchqlock4);
+	bench("slock4", benchslock4);
+
+	bench("lock32", benchlock32);
+	bench("qlock32", benchqlock32);
+	bench("slock32", benchslock32);
+
+	bench("lock512", benchlock512);
+	bench("qlock512", benchqlock512);
+	bench("slock512", benchslock512);
+	exits(0);
+}
+
--- /dev/null	Thu Dec 31 12:39:09 2020
+++ b/true.c	Tue Oct 27 20:22:07 2020
@@ -0,0 +1,9 @@
+#include <u.h>
+#include <libc.h>
+
+void
+main(void)
+{
+	exits(0);
+}
+