1 files changed, 293 insertions, 0 deletions
diff --git a/src/ext/timeouts/bench/bench.c b/src/ext/timeouts/bench/bench.c
new file mode 100644
index 0000000000..0d4cee44a0
--- /dev/null
+++ b/src/ext/timeouts/bench/bench.c
@@ -0,0 +1,293 @@
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <unistd.h>
+#include <dlfcn.h>
+
+#if __APPLE__
+#include <mach/mach_time.h>
+#endif
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+#include "timeout.h"
+#include "bench.h"
+
+#if LUA_VERSION_NUM < 502
+static int lua_absindex(lua_State *L, int idx) {
+	return (idx > 0 || idx <= LUA_REGISTRYINDEX)? idx : lua_gettop(L) + idx + 1;
+} /* lua_absindex() */
+
+static void luaL_setfuncs(lua_State *L, const luaL_Reg *l, int nup) {
+	int i, t = lua_absindex(L, -1 - nup);
+
+	for (; l->name; l++) {
+		for (i = 0; i < nup; i++)
+			lua_pushvalue(L, -nup);
+		lua_pushcclosure(L, l->func, nup);
+		lua_setfield(L, t, l->name);
+	}
+
+	lua_pop(L, nup);
+} /* luaL_setfuncs() */
+
+#define luaL_newlibtable(L, l) \
+	lua_createtable(L, 0, (sizeof (l) / sizeof *(l)) - 1)
+
+#define luaL_newlib(L, l) \
+	(luaL_newlibtable((L), (l)), luaL_setfuncs((L), (l), 0))
+#endif
+
+#ifndef MAX
+#define MAX(a, b) (((a) > (b))? (a) : (b))
+#endif
+
+
+struct bench {
+	const char *path;
+	void *solib;
+	size_t count;
+	timeout_t timeout_max;
+	int verbose;
+
+	void *state;
+	struct timeout *timeout;
+	struct benchops ops;
+	timeout_t curtime;
+}; /* struct bench */
+
+
+#if __APPLE__
+static mach_timebase_info_data_t timebase;
+#endif
+
+
+static int long long monotime(void) {
+#if __APPLE__
+	unsigned long long abt;
+
+	abt = mach_absolute_time();
+	abt = abt * timebase.numer / timebase.denom;
+
+	return abt / 1000LL;
+#else
+	struct timespec ts;
+
+	clock_gettime(CLOCK_MONOTONIC, &ts);
+
+	return (ts.tv_sec * 1000000L) + (ts.tv_nsec / 1000L);
+#endif
+} /* monotime() */
+
+
+static int bench_clock(lua_State *L) {
+	lua_pushnumber(L, (double)monotime() / 1000000L);
+
+	return 1;
+} /* bench_clock() */
+
+
+static int bench_new(lua_State *L) {
+	const char *path = luaL_checkstring(L, 1);
+	size_t count = luaL_optinteger(L, 2, 1000000);
+	timeout_t timeout_max = luaL_optinteger(L, 3, 300 * 1000000L);
+	int verbose = (lua_isnone(L, 4))? 0 : lua_toboolean(L, 4);
+	struct bench *B;
+	struct benchops *ops;
+
+	B = lua_newuserdata(L, sizeof *B);
+	memset(B, 0, sizeof *B);
+
+	luaL_getmetatable(L, "BENCH*");
+	lua_setmetatable(L, -2);
+
+	B->count = count;
+	B->timeout_max = timeout_max;
+	B->verbose = verbose;
+
+	if (!(B->timeout = calloc(count, sizeof *B->timeout)))
+		return luaL_error(L, "%s", strerror(errno));
+
+	if (!(B->solib = dlopen(path, RTLD_NOW|RTLD_LOCAL)))
+		return luaL_error(L, "%s: %s", path, dlerror());
+
+	if (!(ops = dlsym(B->solib, "benchops")))
+		return luaL_error(L, "%s: %s", path, dlerror());
+
+	B->ops = *ops;
+	B->state = B->ops.init(B->timeout, B->count, B->verbose);
+
+	return 1;
+} /* bench_new() */
+
+
+static int bench_add(lua_State *L) {
+	struct bench *B = lua_touserdata(L, 1);
+	unsigned i;
+	timeout_t t;
+
+	i = (lua_isnoneornil(L, 2))? random() % B->count : (unsigned)luaL_checkinteger(L, 2);
+	t = (lua_isnoneornil(L, 3))? random() % B->timeout_max : (unsigned)luaL_checkinteger(L, 3);
+
+	B->ops.add(B->state, &B->timeout[i], t);
+
+	return 0;
+} /* bench_add() */
+
+
+static int bench_del(lua_State *L) {
+	struct bench *B = lua_touserdata(L, 1);
+	size_t i = luaL_optinteger(L, 2, random() % B->count);
+	size_t j = luaL_optinteger(L, 3, i);
+
+	while (i <= j && i < B->count) {
+		B->ops.del(B->state, &B->timeout[i]);
+		++i;
+	}
+
+	return 0;
+} /* bench_del() */
+
+
+static int bench_fill(lua_State *L) {
+	struct bench *B = lua_touserdata(L, 1);
+	size_t count = luaL_optinteger(L, 2, B->count);
+	long timeout_inc = luaL_optinteger(L, 3, -1), timeout_max = 0, timeout;
+	size_t i;
+
+	if (timeout_inc < 0) {
+		for (i = 0; i < count; i++) {
+			timeout = random() % B->timeout_max;
+			B->ops.add(B->state, &B->timeout[i], timeout);
+			timeout_max = MAX(timeout, timeout_max);
+		}
+	} else {
+		for (i = 0; i < count; i++) {
+			timeout = timeout_inc + i;
+			B->ops.add(B->state, &B->timeout[i], timeout_inc + i);
+			timeout_max = MAX(timeout, timeout_max);
+		}
+	}
+
+	lua_pushinteger(L, (lua_Integer)count);
+	lua_pushinteger(L, (lua_Integer)timeout_max);
+
+	return 2;
+} /* bench_fill() */
+
+
+static int bench_expire(lua_State *L) {
+	struct bench *B = lua_touserdata(L, 1);
+	unsigned count = luaL_optinteger(L, 2, B->count);
+	unsigned step = luaL_optinteger(L, 3, 300000);
+	size_t i = 0;
+
+	while (i < count && !B->ops.empty(B->state)) {
+		B->curtime += step;
+		B->ops.update(B->state, B->curtime);
+
+		while (B->ops.get(B->state))
+			i++;
+	}
+
+	lua_pushinteger(L, (lua_Integer)i);
+
+	return 1;
+} /* bench_expire() */
+
+
+static int bench_empty(lua_State *L) {
+	struct bench *B = lua_touserdata(L, 1);
+
+	lua_pushboolean(L, B->ops.empty(B->state));
+
+	return 1;
+} /* bench_empty() */
+
+
+static int bench__next(lua_State *L) {
+	struct bench *B = lua_touserdata(L, lua_upvalueindex(1));
+	struct timeouts_it *it = lua_touserdata(L, lua_upvalueindex(2));
+	struct timeout *to;
+
+	if (!B->ops.next || !(to = B->ops.next(B->state, it)))
+		return 0;
+
+	lua_pushinteger(L, luaL_optinteger(L, 2, 0) + 1);
+
+	lua_newtable(L);
+	lua_pushinteger(L, to->expires);
+	lua_setfield(L, -2, "expires");
+
+	return 2;
+} /* bench__next() */
+
+static int bench__pairs(lua_State *L) {
+	struct timeouts_it *it;
+
+	lua_settop(L, 1);
+
+	it = lua_newuserdata(L, sizeof *it);
+	TIMEOUTS_IT_INIT(it, TIMEOUTS_ALL);
+
+	lua_pushcclosure(L, &bench__next, 2);
+	lua_pushvalue(L, 1);
+	lua_pushinteger(L, 0);
+
+	return 3;
+} /* bench__pairs() */
+
+
+static int bench__gc(lua_State *L) {
+	struct bench *B = lua_touserdata(L, 1);
+
+	if (B->state) {
+		B->ops.destroy(B->state);
+		B->state = NULL;
+	}
+
+	return 0;
+} /* bench__gc() */
+
+
+static const luaL_Reg bench_methods[] = {
+	{ "add",    &bench_add },
+	{ "del",    &bench_del },
+	{ "fill",   &bench_fill },
+	{ "expire", &bench_expire },
+	{ "empty",  &bench_empty },
+	{ "close",  &bench__gc },
+	{ NULL,     NULL }
+};
+
+static const luaL_Reg bench_metatable[] = {
+	{ "__pairs", &bench__pairs },
+	{ "__gc",    &bench__gc },
+	{ NULL,      NULL }
+};
+
+static const luaL_Reg bench_globals[] = {
+	{ "new",   &bench_new },
+	{ "clock", &bench_clock },
+	{ NULL,  NULL }
+};
+
+int luaopen_bench(lua_State *L) {
+#if __APPLE__
+	mach_timebase_info(&timebase);
+#endif
+
+	if (luaL_newmetatable(L, "BENCH*")) {
+		luaL_setfuncs(L, bench_metatable, 0);
+		luaL_newlib(L, bench_methods);
+		lua_setfield(L, -2, "__index");
+	}
+
+	luaL_newlib(L, bench_globals);
+
+	return 1;
+} /* luaopen_bench() */
+