Skip to content

Commit

Permalink
Merge pull request #6 from geky/rename-equeue-calls
Browse files Browse the repository at this point in the history 
Rename event -> equeue for functions operating on queues
  • Loading branch information
@geky
geky authored Jul 29, 2016
2 parents ed105c9 + ee453c9 commit bd91305
Show file tree
Hide file tree
Showing 5 changed files with 132 additions and 137 deletions.
6 changes: 3 additions & 3 deletions README.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,9 +18,9 @@ int main() {
equeue_create(&queue, 32*EVENTS_EVENT_SIZE);

// events are simple callbacks
event_call(&queue, print, "called immediately");
event_call_in(&queue, print, "called in 2 seconds", 2000);
event_call_every(&queue, print, "called every 1 seconds", 1000);
equeue_call(&queue, print, "called immediately");
equeue_call_in(&queue, print, "called in 2 seconds", 2000);
equeue_call_every(&queue, print, "called every 1 seconds", 1000);

// events are executed when dispatch is called
equeue_dispatch(&queue, 3000);
Expand Down
71 changes: 33 additions & 38 deletions events.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -57,7 +57,7 @@ void equeue_destroy(equeue_t *q) {
while (q->queue) {
struct event *e = q->queue;
q->queue = e->next;
event_dealloc(q, e+1);
equeue_dealloc(q, e+1);
}

events_mutex_destroy(&q->freelock);
Expand All @@ -67,7 +67,7 @@ void equeue_destroy(equeue_t *q) {
}

// equeue allocation functions
static void *equeue_alloc(equeue_t *q, unsigned size) {
static void *equeue_mem_alloc(equeue_t *q, unsigned size) {
size = size + sizeof(unsigned);
size = (size + sizeof(unsigned)-1) & ~(sizeof(unsigned)-1);
if (size < sizeof(struct equeue_chunk)) {
Expand Down Expand Up @@ -103,7 +103,7 @@ static void *equeue_alloc(equeue_t *q, unsigned size) {
return 0;
}

static void equeue_dealloc(equeue_t *q, void *e) {
static void equeue_mem_dealloc(equeue_t *q, void *e) {
struct equeue_chunk *c = (struct equeue_chunk *)((unsigned *)e - 1);

events_mutex_lock(&q->freelock);
Expand All @@ -126,36 +126,36 @@ static void equeue_dealloc(equeue_t *q, void *e) {
}

// event allocation functions
static inline int event_next_id(equeue_t *q) {
static inline int equeue_next_id(equeue_t *q) {
int id = q->next_id++;
if (q->next_id < 0) {
q->next_id = 42;
}
return id;
}

void *event_alloc(equeue_t *q, unsigned size) {
struct event *e = equeue_alloc(q, sizeof(struct event) + size);
void *equeue_alloc(equeue_t *q, unsigned size) {
struct event *e = equeue_mem_alloc(q, sizeof(struct event) + size);
if (!e) {
return 0;
}

e->id = event_next_id(q);
e->id = equeue_next_id(q);
e->target = 0;
e->period = -1;
e->dtor = 0;

return e + 1;
}

void event_dealloc(equeue_t *q, void *p) {
void equeue_dealloc(equeue_t *q, void *p) {
struct event *e = (struct event*)p - 1;

if (e->dtor) {
e->dtor(e+1);
}

equeue_dealloc(q, e);
equeue_mem_dealloc(q, e);
}

// equeue scheduling functions
Expand Down Expand Up @@ -187,10 +187,10 @@ static struct event *equeue_dequeue(equeue_t *q, int id) {
return 0;
}

static int equeue_post(equeue_t *q, struct event *e, int ms) {
static int equeue_post_in(equeue_t *q, struct event *e, int ms) {
int id = e->id;
if (ms < 0) {
event_dealloc(q, e+1);
equeue_dealloc(q, e+1);
return id;
}

Expand All @@ -202,23 +202,30 @@ static int equeue_post(equeue_t *q, struct event *e, int ms) {
return id;
}

static void equeue_cancel(equeue_t *q, int id) {
int equeue_post(equeue_t *q, void (*cb)(void*), void *p) {
struct event *e = (struct event*)p - 1;
e->cb = cb;
int id = equeue_post_in(q, e, e->target);
return id;
}

void equeue_cancel(equeue_t *q, int id) {
events_mutex_lock(&q->queuelock);
struct event *e = equeue_dequeue(q, id);
events_mutex_unlock(&q->queuelock);

if (e) {
event_dealloc(q, e+1);
equeue_dealloc(q, e+1);
}
}

void equeue_break(equeue_t *q) {
equeue_post(q, &q->break_, 0);
equeue_post_in(q, &q->break_, 0);
}

void equeue_dispatch(equeue_t *q, int ms) {
if (ms >= 0) {
equeue_post(q, &q->break_, ms);
equeue_post_in(q, &q->break_, ms);
}

while (1) {
Expand All @@ -244,7 +251,7 @@ void equeue_dispatch(equeue_t *q, int ms) {

if (e->period >= 0) {
// requeue periodic tasks to avoid race conditions
// in event_cancel
// in equeue_cancel
equeue_enqueue(q, e, e->period);
}
events_mutex_unlock(&q->queuelock);
Expand All @@ -257,7 +264,7 @@ void equeue_dispatch(equeue_t *q, int ms) {
e->cb(e + 1);

if (e->period < 0) {
event_dealloc(q, e+1);
equeue_dealloc(q, e+1);
}
}

Expand All @@ -281,18 +288,6 @@ void event_dtor(void *p, void (*dtor)(void *)) {
e->dtor = dtor;
}

// event operations
int event_post(equeue_t *q, void (*cb)(void*), void *p) {
struct event *e = (struct event*)p - 1;
e->cb = cb;
int id = equeue_post(q, e, e->target);
return id;
}

void event_cancel(equeue_t *q, int id) {
equeue_cancel(q, id);
}

// simple callbacks
struct ecallback {
void (*cb)(void*);
Expand All @@ -304,31 +299,31 @@ static void ecallback_dispatch(void *p) {
e->cb(e->data);
}

int event_call(equeue_t *q, void (*cb)(void*), void *data) {
struct ecallback *e = event_alloc(q, sizeof(struct ecallback));
int equeue_call(equeue_t *q, void (*cb)(void*), void *data) {
struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback));
if (!e) {
return 0;
}

e->cb = cb;
e->data = data;
return event_post(q, ecallback_dispatch, e);
return equeue_post(q, ecallback_dispatch, e);
}

int event_call_in(equeue_t *q, int ms, void (*cb)(void*), void *data) {
struct ecallback *e = event_alloc(q, sizeof(struct ecallback));
int equeue_call_in(equeue_t *q, int ms, void (*cb)(void*), void *data) {
struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback));
if (!e) {
return 0;
}

event_delay(e, ms);
e->cb = cb;
e->data = data;
return event_post(q, ecallback_dispatch, e);
return equeue_post(q, ecallback_dispatch, e);
}

int event_call_every(equeue_t *q, int ms, void (*cb)(void*), void *data) {
struct ecallback *e = event_alloc(q, sizeof(struct ecallback));
int equeue_call_every(equeue_t *q, int ms, void (*cb)(void*), void *data) {
struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback));
if (!e) {
return 0;
}
Expand All @@ -337,5 +332,5 @@ int event_call_every(equeue_t *q, int ms, void (*cb)(void*), void *data) {
event_period(e, ms);
e->cb = cb;
e->data = data;
return event_post(q, ecallback_dispatch, e);
return equeue_post(q, ecallback_dispatch, e);
}
32 changes: 16 additions & 16 deletions events.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -80,26 +80,26 @@ void equeue_break(equeue_t *queue);
// Passed callback will be executed in the associated equeue's
// dispatch call with the data pointer passed unmodified
//
// event_call - Immediately post an event to the queue
// event_call_in - Post an event after a specified time in milliseconds
// event_call_every - Post an event periodically in milliseconds
// equeue_call - Immediately post an event to the queue
// equeue_call_in - Post an event after a specified time in milliseconds
// equeue_call_every - Post an event periodically in milliseconds
//
// These calls will result in 0 if no memory is available, otherwise they
// will result in a unique identifier that can be passed to event_cancel.
int event_call(equeue_t *queue, void (*cb)(void *), void *data);
int event_call_in(equeue_t *queue, int ms, void (*cb)(void *), void *data);
int event_call_every(equeue_t *queue, int ms, void (*cb)(void *), void *data);
// will result in a unique identifier that can be passed to equeue_cancel.
int equeue_call(equeue_t *queue, void (*cb)(void *), void *data);
int equeue_call_in(equeue_t *queue, int ms, void (*cb)(void *), void *data);
int equeue_call_every(equeue_t *queue, int ms, void (*cb)(void *), void *data);

// Events with queue handled blocks of memory
//
// Argument to event_post must point to a result of a event_alloc call
// Argument to equeue_post must point to a result of a equeue_alloc call
// and the associated memory is automatically freed after the event
// is dispatched.
//
// event_alloc will result in null if no memory is available
// equeue_alloc will result in null if no memory is available
// or the requested size is less than the size passed to equeue_create.
void *event_alloc(equeue_t *queue, unsigned size);
void event_dealloc(equeue_t *queue, void *event);
void *equeue_alloc(equeue_t *queue, unsigned size);
void equeue_dealloc(equeue_t *queue, void *event);

// Configure an allocated event
//
Expand All @@ -112,21 +112,21 @@ void event_dtor(void *event, void (*dtor)(void *));

// Post an allocted event to the event queue
//
// Argument to event_post must point to a result of a event_alloc call
// Argument to equeue_post must point to a result of a equeue_alloc call
// and the associated memory is automatically freed after the event
// is dispatched.
//
// This call results in an unique identifier that can be passed to
// event_cancel.
int event_post(equeue_t *queue, void (*cb)(void *), void *event);
// equeue_cancel.
int equeue_post(equeue_t *queue, void (*cb)(void *), void *event);

// Cancel events that are in flight
//
// Every event_call function returns a non-negative identifier on success
// Every equeue_call function returns a non-negative identifier on success
// that can be used to cancel an in-flight event. If the event has already
// been dispatched or does not exist, no error occurs. Note, this can not
// stop a currently executing event
void event_cancel(equeue_t *queue, int event);
void equeue_cancel(equeue_t *queue, int event);


#ifdef __cplusplus
Expand Down
Loading

0 comments on commit bd91305

Please sign in to comment.