服务器架构设计1
说到服务器，通常可以想象都是一个while(1)无限循环，当某种条件触发之后，则跳出循环。
然而，有些时候，则需要服务器针对某些ses，周期性的执行特定操作，如何实现呢。
一个简单的方法就是，建立session的node list，节点信息包括(time，ses私有变量，回调函数，执行周期interval)，主线程周期性的访问这个node list，如果时间条件满足，执行回调函数。
构造了一个简单node list，便于说明。
inline uint64_t get_current_clock(void)
{
struct timespec tp;
clock_gettime(CLOCK_MONOTONIC, &tp);
return (uint64_t)tp.tv_sec * 1e3 + (uint64_t)(tp.tv_nsec / 1e6);
}
static void heap_insert_helper(timer_event_t* heap[], uint32_t idx)
{
if(idx <= 0) {
return;
}
uint32_t p = (idx - 1) >> 1;
if(heap[p]->time <= heap[idx]->time) {
return;
} else {
timer_event_t* tmp = heap[p];
heap[p] = heap[idx];
heap[idx] = tmp;
heap_insert_helper(heap, p);
}
}
static void event_heap_insert(timer_ctx_t* ctx, timer_event_t* evt)
{
timer_event_t** heap = ctx->heap;
uint32_t idx = ctx->nevts++;
heap[idx] = evt;
heap_insert_helper(heap, idx);
}
static void heap_del_helper(timer_event_t* heap[], uint32_t nevts, uint32_t idx)
{
if(idx >= nevts) {
return;
}
uint32_t lchild = idx * 2 + 1;
uint32_t rchild = idx * 2 + 2;
uint32_t i = idx;
if(lchild < nevts && (heap[i]->time > heap[lchild]->time)) {
i = lchild;
}
if(rchild < nevts && (heap[i]->time > heap[rchild]->time)) {
i = rchild;
}
if(i != idx) {
timer_event_t* tmp = heap[i];
heap[i] = heap[idx];
heap[idx] = tmp;
heap_del_helper(heap, nevts, i);
}
}
static timer_event_t* event_heap_pop(timer_ctx_t* ctx)
{
timer_event_t* evt = ctx->heap[0];
ctx->heap[0] = ctx->heap[--ctx->nevts];
heap_del_helper(ctx->heap, ctx->nevts, 0);
return evt;
}
static void
event_re_enqueue(timer_ctx_t* ctx, timer_event_t* evt)
{
if(evt->enable && evt->interval > 0) {
evt->time += evt->interval;
if(evt->count > 0) {
evt->count--;
if(evt->count == 0) {
evt->interval = 0;
}
}
event_heap_insert(ctx, evt);
} else {
mpool_put(evt);
}
}
void timer_run(timer_ctx_t *ctx)
{
while(ctx->nevts > 0
&& ctx->heap[0]->time <= get_current_clock()) {
timer_event_t *evt = event_heap_pop(ctx);
if(evt->enable && evt->cb) {
evt->cb(evt->data);
}
event_re_enqueue(ctx, evt);
}
}
timer_ctx_t* timer_init(timer_ctx_t* ctx)
{
if(!ctx) {
return NULL;
}
memset(ctx, 0, sizeof(timer_ctx_t));
//make sure mpool is large enough
ctx->mpool = mpool_calloc(MAX_EVENT_COUNT, sizeof(timer_event_t));
// ctx->mpool = mpool_init(sizeof(timer_event_t),
// (sizeof(timer_event_t) + sizeof(void*)) * MAX_EVENT_COUNT + 512,
// NULL);
if(!ctx->mpool) {
goto error;
}
return ctx;
error:
mpool_cleanup(ctx->mpool);
return NULL;
}
void timer_cleanup(timer_ctx_t *ctx)
{
if(!ctx) {
return;
}
mpool_cleanup(ctx->mpool);
ctx->mpool = NULL;
}
int
timer_register(
timer_ctx_t *ctx,
timer_cb_t cb,
void* data,
uint32_t delay,
uint32_t interval,
uint32_t count)
{
timer_event_t *evt = NULL;
if(ctx->nevts >= MAX_EVENT_COUNT) {
goto err;
}
evt = (timer_event_t*)mpool_get(ctx->mpool);
if(!evt) {
goto err;
}
memset(evt, 0, sizeof(timer_event_t));
int idx = mpool_get_idx(ctx->mpool, evt);
if(idx < 0) {
goto err;
}
evt->id = idx;
evt->time = get_current_clock() + delay;
evt->cb = cb;
evt->data = data;
evt->interval = interval;
evt->count = count;
evt->enable = 1;
event_heap_insert(ctx, evt);
return idx;
err:
if(evt) {
mpool_put(evt);
}
return -1;
}
void timer_cancel(timer_ctx_t *ctx, int id)
{
timer_event_t *evt = mpool_get_by_idx(ctx->mpool, id);
if(evt) {
evt->enable = 0;
}
}