bench.c

#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() */