ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

events: fix astyle

pull/8365/head
Martin Kojtal 2018-10-10 13:35:21 -05:00
parent 62148b973e
commit 08b94aa193
4 changed files with 237 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
events/equeue/equeue.c
View File

@ -23,19 +23,22 @@
// calculate the relative-difference between absolute times while // calculate the relative-difference between absolute times while
// correctly handling overflow conditions // correctly handling overflow conditions
static inline int equeue_tickdiff(unsigned a, unsigned b) { static inline int equeue_tickdiff(unsigned a, unsigned b)
{
return (int)(unsigned)(a - b); return (int)(unsigned)(a - b);
} }
// calculate the relative-difference between absolute times, but // calculate the relative-difference between absolute times, but
// also clamp to zero, resulting in only non-zero values. // also clamp to zero, resulting in only non-zero values.
static inline int equeue_clampdiff(unsigned a, unsigned b) { static inline int equeue_clampdiff(unsigned a, unsigned b)
{
int diff = equeue_tickdiff(a, b); int diff = equeue_tickdiff(a, b);
return ~(diff >> (8 * sizeof(int) -1)) & diff; return ~(diff >> (8 * sizeof(int) -1)) & diff;
} }
// Increment the unique id in an event, hiding the event from cancel // Increment the unique id in an event, hiding the event from cancel
static inline void equeue_incid(equeue_t *q, struct equeue_event *e) { static inline void equeue_incid(equeue_t *q, struct equeue_event *e)
{
e->id += 1; e->id += 1;
if ((e->id << q->npw2) == 0) { if ((e->id << q->npw2) == 0) {
e->id = 1; e->id = 1;
@ -44,7 +47,8 @@ static inline void equeue_incid(equeue_t *q, struct equeue_event *e) {
// equeue lifetime management // equeue lifetime management
int equeue_create(equeue_t *q, size_t size) { int equeue_create(equeue_t *q, size_t size)
{
// dynamically allocate the specified buffer // dynamically allocate the specified buffer
void *buffer = malloc(size); void *buffer = malloc(size);
if (!buffer) { if (!buffer) {
@ -56,7 +60,8 @@ int equeue_create(equeue_t *q, size_t size) {
return err; return err;
} }
int equeue_create_inplace(equeue_t *q, size_t size, void *buffer) { int equeue_create_inplace(equeue_t *q, size_t size, void *buffer)
{
// setup queue around provided buffer // setup queue around provided buffer
q->buffer = buffer; q->buffer = buffer;
q->allocated = 0; q->allocated = 0;
@ -99,7 +104,8 @@ int equeue_create_inplace(equeue_t *q, size_t size, void *buffer) {
return 0; return 0;
} }
void equeue_destroy(equeue_t *q) { void equeue_destroy(equeue_t *q)
{
// call destructors on pending events // call destructors on pending events
for (struct equeue_event *es = q->queue; es; es = es->next) { for (struct equeue_event *es = q->queue; es; es = es->next) {
for (struct equeue_event *e = q->queue; e; e = e->sibling) { for (struct equeue_event *e = q->queue; e; e = e->sibling) {
@ -123,7 +129,8 @@ void equeue_destroy(equeue_t *q) {
// equeue chunk allocation functions // equeue chunk allocation functions
static struct equeue_event *equeue_mem_alloc(equeue_t *q, size_t size) { static struct equeue_event *equeue_mem_alloc(equeue_t *q, size_t size)
{
// add event overhead // add event overhead
size += sizeof(struct equeue_event); size += sizeof(struct equeue_event);
size = (size + sizeof(void *) -1) & ~(sizeof(void *) -1); size = (size + sizeof(void *) -1) & ~(sizeof(void *) -1);
@ -162,7 +169,8 @@ static struct equeue_event *equeue_mem_alloc(equeue_t *q, size_t size) {
return 0; return 0;
} }
static void equeue_mem_dealloc(equeue_t *q, struct equeue_event *e) { static void equeue_mem_dealloc(equeue_t *q, struct equeue_event *e)
{
equeue_mutex_lock(&q->memlock); equeue_mutex_lock(&q->memlock);
// stick chunk into list of chunks // stick chunk into list of chunks
@ -183,7 +191,8 @@ static void equeue_mem_dealloc(equeue_t *q, struct equeue_event *e) {
equeue_mutex_unlock(&q->memlock); equeue_mutex_unlock(&q->memlock);
} }
void *equeue_alloc(equeue_t *q, size_t size) { void *equeue_alloc(equeue_t *q, size_t size)
{
struct equeue_event *e = equeue_mem_alloc(q, size); struct equeue_event *e = equeue_mem_alloc(q, size);
if (!e) { if (!e) {
return 0; return 0;
@ -196,7 +205,8 @@ void *equeue_alloc(equeue_t *q, size_t size) {
return e + 1; return e + 1;
} }
void equeue_dealloc(equeue_t *q, void *p) { void equeue_dealloc(equeue_t *q, void *p)
{
struct equeue_event *e = (struct equeue_event *)p - 1; struct equeue_event *e = (struct equeue_event *)p - 1;
if (e->dtor) { if (e->dtor) {
@ -208,7 +218,8 @@ void equeue_dealloc(equeue_t *q, void *p) {
// equeue scheduling functions // equeue scheduling functions
static int equeue_enqueue(equeue_t *q, struct equeue_event *e, unsigned tick) { static int equeue_enqueue(equeue_t *q, struct equeue_event *e, unsigned tick)
{
// setup event and hash local id with buffer offset for unique id // setup event and hash local id with buffer offset for unique id
int id = (e->id << q->npw2) | ((unsigned char *)e - q->buffer); int id = (e->id << q->npw2) | ((unsigned char *)e - q->buffer);
e->target = tick + equeue_clampdiff(e->target, tick); e->target = tick + equeue_clampdiff(e->target, tick);
@ -255,7 +266,8 @@ static int equeue_enqueue(equeue_t *q, struct equeue_event *e, unsigned tick) {
return id; return id;
} }
static struct equeue_event *equeue_unqueue(equeue_t *q, int id) { static struct equeue_event *equeue_unqueue(equeue_t *q, int id)
{
// decode event from unique id and check that the local id matches // decode event from unique id and check that the local id matches
struct equeue_event *e = (struct equeue_event *) struct equeue_event *e = (struct equeue_event *)
&q->buffer[id & ((1 << q->npw2) - 1)]; &q->buffer[id & ((1 << q->npw2) - 1)];
@ -298,7 +310,8 @@ static struct equeue_event *equeue_unqueue(equeue_t *q, int id) {
return e; return e;
} }
static struct equeue_event *equeue_dequeue(equeue_t *q, unsigned target) { static struct equeue_event *equeue_dequeue(equeue_t *q, unsigned target)
{
equeue_mutex_lock(&q->queuelock); equeue_mutex_lock(&q->queuelock);
// find all expired events and mark a new generation // find all expired events and mark a new generation
@ -342,7 +355,8 @@ static struct equeue_event *equeue_dequeue(equeue_t *q, unsigned target) {
return head; return head;
} }
int equeue_post(equeue_t *q, void (*cb)(void*), void *p) { int equeue_post(equeue_t *q, void (*cb)(void *), void *p)
{
struct equeue_event *e = (struct equeue_event *)p - 1; struct equeue_event *e = (struct equeue_event *)p - 1;
unsigned tick = equeue_tick(); unsigned tick = equeue_tick();
e->cb = cb; e->cb = cb;
@ -353,7 +367,8 @@ int equeue_post(equeue_t *q, void (*cb)(void*), void *p) {
return id; return id;
} }
void equeue_cancel(equeue_t *q, int id) { void equeue_cancel(equeue_t *q, int id)
{
if (!id) { if (!id) {
return; return;
} }
@ -364,7 +379,8 @@ void equeue_cancel(equeue_t *q, int id) {
} }
} }
int equeue_timeleft(equeue_t *q, int id) { int equeue_timeleft(equeue_t *q, int id)
{
int ret = -1; int ret = -1;
if (!id) { if (!id) {
@ -383,14 +399,16 @@ int equeue_timeleft(equeue_t *q, int id) {
return ret; return ret;
} }
void equeue_break(equeue_t *q) { void equeue_break(equeue_t *q)
{
equeue_mutex_lock(&q->queuelock); equeue_mutex_lock(&q->queuelock);
q->break_requested = true; q->break_requested = true;
equeue_mutex_unlock(&q->queuelock); equeue_mutex_unlock(&q->queuelock);
equeue_sema_signal(&q->eventsema); equeue_sema_signal(&q->eventsema);
} }
void equeue_dispatch(equeue_t *q, int ms) { void equeue_dispatch(equeue_t *q, int ms)
{
unsigned tick = equeue_tick(); unsigned tick = equeue_tick();
unsigned timeout = tick + ms; unsigned timeout = tick + ms;
q->background.active = false; q->background.active = false;
@ -473,17 +491,20 @@ void equeue_dispatch(equeue_t *q, int ms) {
// event functions // event functions
void equeue_event_delay(void *p, int ms) { void equeue_event_delay(void *p, int ms)
{
struct equeue_event *e = (struct equeue_event *)p - 1; struct equeue_event *e = (struct equeue_event *)p - 1;
e->target = ms; e->target = ms;
} }
void equeue_event_period(void *p, int ms) { void equeue_event_period(void *p, int ms)
{
struct equeue_event *e = (struct equeue_event *)p - 1; struct equeue_event *e = (struct equeue_event *)p - 1;
e->period = ms; e->period = ms;
} }
void equeue_event_dtor(void *p, void (*dtor)(void *)) { void equeue_event_dtor(void *p, void (*dtor)(void *))
{
struct equeue_event *e = (struct equeue_event *)p - 1; struct equeue_event *e = (struct equeue_event *)p - 1;
e->dtor = dtor; e->dtor = dtor;
} }
@ -495,12 +516,14 @@ struct ecallback {
void *data; void *data;
}; };
static void ecallback_dispatch(void *p) { static void ecallback_dispatch(void *p)
{
struct ecallback *e = (struct ecallback *)p; struct ecallback *e = (struct ecallback *)p;
e->cb(e->data); e->cb(e->data);
} }
int equeue_call(equeue_t *q, void (*cb)(void*), void *data) { int equeue_call(equeue_t *q, void (*cb)(void *), void *data)
{
struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback)); struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback));
if (!e) { if (!e) {
return 0; return 0;
@ -511,7 +534,8 @@ int equeue_call(equeue_t *q, void (*cb)(void*), void *data) {
return equeue_post(q, ecallback_dispatch, e); return equeue_post(q, ecallback_dispatch, e);
} }
int equeue_call_in(equeue_t *q, int ms, void (*cb)(void*), void *data) { int equeue_call_in(equeue_t *q, int ms, void (*cb)(void *), void *data)
{
struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback)); struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback));
if (!e) { if (!e) {
return 0; return 0;
@ -523,7 +547,8 @@ int equeue_call_in(equeue_t *q, int ms, void (*cb)(void*), void *data) {
return equeue_post(q, ecallback_dispatch, e); return equeue_post(q, ecallback_dispatch, e);
} }
int equeue_call_every(equeue_t *q, int ms, void (*cb)(void*), void *data) { int equeue_call_every(equeue_t *q, int ms, void (*cb)(void *), void *data)
{
struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback)); struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback));
if (!e) { if (!e) {
return 0; return 0;
@ -539,7 +564,8 @@ int equeue_call_every(equeue_t *q, int ms, void (*cb)(void*), void *data) {
// backgrounding // backgrounding
void equeue_background(equeue_t *q, void equeue_background(equeue_t *q,
void (*update)(void *timer, int ms), void *timer) { void (*update)(void *timer, int ms), void *timer)
{
equeue_mutex_lock(&q->queuelock); equeue_mutex_lock(&q->queuelock);
if (q->background.update) { if (q->background.update) {
q->background.update(q->background.timer, -1); q->background.update(q->background.timer, -1);
@ -562,11 +588,13 @@ struct equeue_chain_context {
int id; int id;
}; };
static void equeue_chain_dispatch(void *p) { static void equeue_chain_dispatch(void *p)
{
equeue_dispatch((equeue_t *)p, 0); equeue_dispatch((equeue_t *)p, 0);
} }
static void equeue_chain_update(void *p, int ms) { static void equeue_chain_update(void *p, int ms)
{
struct equeue_chain_context *c = (struct equeue_chain_context *)p; struct equeue_chain_context *c = (struct equeue_chain_context *)p;
equeue_cancel(c->target, c->id); equeue_cancel(c->target, c->id);
@ -577,7 +605,8 @@ static void equeue_chain_update(void *p, int ms) {
} }
} }
void equeue_chain(equeue_t *q, equeue_t *target) { void equeue_chain(equeue_t *q, equeue_t *target)
{
if (!target) { if (!target) {
equeue_background(q, 0, 0); equeue_background(q, 0, 0);
return; return;

27
events/equeue/equeue_posix.c
View File

@ -25,7 +25,8 @@
// Tick operations // Tick operations
unsigned equeue_tick(void) { unsigned equeue_tick(void)
{
struct timeval tv; struct timeval tv;
gettimeofday(&tv, 0); gettimeofday(&tv, 0);
return (unsigned)(tv.tv_sec * 1000 + tv.tv_usec / 1000); return (unsigned)(tv.tv_sec * 1000 + tv.tv_usec / 1000);
@ -33,25 +34,30 @@ unsigned equeue_tick(void) {
// Mutex operations // Mutex operations
int equeue_mutex_create(equeue_mutex_t *m) { int equeue_mutex_create(equeue_mutex_t *m)
{
return pthread_mutex_init(m, 0); return pthread_mutex_init(m, 0);
} }
void equeue_mutex_destroy(equeue_mutex_t *m) { void equeue_mutex_destroy(equeue_mutex_t *m)
{
pthread_mutex_destroy(m); pthread_mutex_destroy(m);
} }
void equeue_mutex_lock(equeue_mutex_t *m) { void equeue_mutex_lock(equeue_mutex_t *m)
{
pthread_mutex_lock(m); pthread_mutex_lock(m);
} }
void equeue_mutex_unlock(equeue_mutex_t *m) { void equeue_mutex_unlock(equeue_mutex_t *m)
{
pthread_mutex_unlock(m); pthread_mutex_unlock(m);
} }
// Semaphore operations // Semaphore operations
int equeue_sema_create(equeue_sema_t *s) { int equeue_sema_create(equeue_sema_t *s)
{
int err = pthread_mutex_init(&s->mutex, 0); int err = pthread_mutex_init(&s->mutex, 0);
if (err) { if (err) {
return err; return err;
@ -66,19 +72,22 @@ int equeue_sema_create(equeue_sema_t *s) {
return 0; return 0;
} }
void equeue_sema_destroy(equeue_sema_t *s) { void equeue_sema_destroy(equeue_sema_t *s)
{
pthread_cond_destroy(&s->cond); pthread_cond_destroy(&s->cond);
pthread_mutex_destroy(&s->mutex); pthread_mutex_destroy(&s->mutex);
} }
void equeue_sema_signal(equeue_sema_t *s) { void equeue_sema_signal(equeue_sema_t *s)
{
pthread_mutex_lock(&s->mutex); pthread_mutex_lock(&s->mutex);
s->signal = true; s->signal = true;
pthread_cond_signal(&s->cond); pthread_cond_signal(&s->cond);
pthread_mutex_unlock(&s->mutex); pthread_mutex_unlock(&s->mutex);
} }
bool equeue_sema_wait(equeue_sema_t *s, int ms) { bool equeue_sema_wait(equeue_sema_t *s, int ms)
{
pthread_mutex_lock(&s->mutex); pthread_mutex_lock(&s->mutex);
if (!s->signal) { if (!s->signal) {
if (ms < 0) { if (ms < 0) {

51
events/equeue/tests/prof.c
View File

@ -113,12 +113,14 @@ static const char *prof_units;
// Various test functions // Various test functions
void no_func(void *eh) { void no_func(void *eh)
{
} }
// Actual performance tests // Actual performance tests
void baseline_prof(void) { void baseline_prof(void)
{
prof_loop() { prof_loop() {
prof_start(); prof_start();
__asm__ volatile(""); __asm__ volatile("");
@ -126,7 +128,8 @@ void baseline_prof(void) {
} }
} }
void equeue_tick_prof(void) { void equeue_tick_prof(void)
{
prof_volatile(unsigned) res; prof_volatile(unsigned) res;
prof_loop() { prof_loop() {
prof_start(); prof_start();
@ -135,7 +138,8 @@ void equeue_tick_prof(void) {
} }
} }
void equeue_alloc_prof(void) { void equeue_alloc_prof(void)
{
struct equeue q; struct equeue q;
equeue_create(&q, 32 * EQUEUE_EVENT_SIZE); equeue_create(&q, 32 * EQUEUE_EVENT_SIZE);
@ -150,7 +154,8 @@ void equeue_alloc_prof(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void equeue_alloc_many_prof(int count) { void equeue_alloc_many_prof(int count)
{
struct equeue q; struct equeue q;
equeue_create(&q, count * EQUEUE_EVENT_SIZE); equeue_create(&q, count * EQUEUE_EVENT_SIZE);
@ -175,7 +180,8 @@ void equeue_alloc_many_prof(int count) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void equeue_post_prof(void) { void equeue_post_prof(void)
{
struct equeue q; struct equeue q;
equeue_create(&q, EQUEUE_EVENT_SIZE); equeue_create(&q, EQUEUE_EVENT_SIZE);
@ -192,7 +198,8 @@ void equeue_post_prof(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void equeue_post_many_prof(int count) { void equeue_post_many_prof(int count)
{
struct equeue q; struct equeue q;
equeue_create(&q, count * EQUEUE_EVENT_SIZE); equeue_create(&q, count * EQUEUE_EVENT_SIZE);
@ -213,7 +220,8 @@ void equeue_post_many_prof(int count) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void equeue_post_future_prof(void) { void equeue_post_future_prof(void)
{
struct equeue q; struct equeue q;
equeue_create(&q, EQUEUE_EVENT_SIZE); equeue_create(&q, EQUEUE_EVENT_SIZE);
@ -231,7 +239,8 @@ void equeue_post_future_prof(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void equeue_post_future_many_prof(int count) { void equeue_post_future_many_prof(int count)
{
struct equeue q; struct equeue q;
equeue_create(&q, count * EQUEUE_EVENT_SIZE); equeue_create(&q, count * EQUEUE_EVENT_SIZE);
@ -253,7 +262,8 @@ void equeue_post_future_many_prof(int count) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void equeue_dispatch_prof(void) { void equeue_dispatch_prof(void)
{
struct equeue q; struct equeue q;
equeue_create(&q, EQUEUE_EVENT_SIZE); equeue_create(&q, EQUEUE_EVENT_SIZE);
@ -268,7 +278,8 @@ void equeue_dispatch_prof(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void equeue_dispatch_many_prof(int count) { void equeue_dispatch_many_prof(int count)
{
struct equeue q; struct equeue q;
equeue_create(&q, count * EQUEUE_EVENT_SIZE); equeue_create(&q, count * EQUEUE_EVENT_SIZE);
@ -285,7 +296,8 @@ void equeue_dispatch_many_prof(int count) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void equeue_cancel_prof(void) { void equeue_cancel_prof(void)
{
struct equeue q; struct equeue q;
equeue_create(&q, EQUEUE_EVENT_SIZE); equeue_create(&q, EQUEUE_EVENT_SIZE);
@ -300,7 +312,8 @@ void equeue_cancel_prof(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void equeue_cancel_many_prof(int count) { void equeue_cancel_many_prof(int count)
{
struct equeue q; struct equeue q;
equeue_create(&q, count * EQUEUE_EVENT_SIZE); equeue_create(&q, count * EQUEUE_EVENT_SIZE);
@ -319,7 +332,8 @@ void equeue_cancel_many_prof(int count) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void equeue_alloc_size_prof(void) { void equeue_alloc_size_prof(void)
{
size_t size = 32 * EQUEUE_EVENT_SIZE; size_t size = 32 * EQUEUE_EVENT_SIZE;
struct equeue q; struct equeue q;
@ -331,7 +345,8 @@ void equeue_alloc_size_prof(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void equeue_alloc_many_size_prof(int count) { void equeue_alloc_many_size_prof(int count)
{
size_t size = count * EQUEUE_EVENT_SIZE; size_t size = count * EQUEUE_EVENT_SIZE;
struct equeue q; struct equeue q;
@ -346,7 +361,8 @@ void equeue_alloc_many_size_prof(int count) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void equeue_alloc_fragmented_size_prof(int count) { void equeue_alloc_fragmented_size_prof(int count)
{
size_t size = count * EQUEUE_EVENT_SIZE; size_t size = count * EQUEUE_EVENT_SIZE;
struct equeue q; struct equeue q;
@ -381,7 +397,8 @@ void equeue_alloc_fragmented_size_prof(int count) {
// Entry point // Entry point
int main() { int main()
{
printf("beginning profiling...\n"); printf("beginning profiling...\n");
prof_baseline(baseline_prof); prof_baseline(baseline_prof);

111
events/equeue/tests/tests.c
View File

@ -51,14 +51,17 @@ static int test_failure;
// Test functions // Test functions
void pass_func(void *eh) { void pass_func(void *eh)
{
} }
void simple_func(void *p) { void simple_func(void *p)
{
(*(int *)p)++; (*(int *)p)++;
} }
void sloth_func(void *p) { void sloth_func(void *p)
{
usleep(10000); usleep(10000);
(*(int *)p)++; (*(int *)p)++;
} }
@ -68,7 +71,8 @@ struct indirect {
uint8_t buffer[7]; uint8_t buffer[7];
}; };
void indirect_func(void *p) { void indirect_func(void *p)
{
struct indirect *i = (struct indirect *)p; struct indirect *i = (struct indirect *)p;
(*i->touched)++; (*i->touched)++;
} }
@ -78,7 +82,8 @@ struct timing {
unsigned delay; unsigned delay;
}; };
void timing_func(void *p) { void timing_func(void *p)
{
struct timing *timing = (struct timing *)p; struct timing *timing = (struct timing *)p;
unsigned tick = equeue_tick(); unsigned tick = equeue_tick();
@ -95,7 +100,8 @@ struct fragment {
struct timing timing; struct timing timing;
}; };
void fragment_func(void *p) { void fragment_func(void *p)
{
struct fragment *fragment = (struct fragment *)p; struct fragment *fragment = (struct fragment *)p;
timing_func(&fragment->timing); timing_func(&fragment->timing);
@ -114,7 +120,8 @@ struct cancel {
int id; int id;
}; };
void cancel_func(void *p) { void cancel_func(void *p)
{
struct cancel *cancel = (struct cancel *)p; struct cancel *cancel = (struct cancel *)p;
equeue_cancel(cancel->q, cancel->id); equeue_cancel(cancel->q, cancel->id);
} }
@ -125,7 +132,8 @@ struct nest {
void *data; void *data;
}; };
void nest_func(void *p) { void nest_func(void *p)
{
struct nest *nest = (struct nest *)p; struct nest *nest = (struct nest *)p;
equeue_call(nest->q, nest->cb, nest->data); equeue_call(nest->q, nest->cb, nest->data);
@ -134,7 +142,8 @@ void nest_func(void *p) {
// Simple call tests // Simple call tests
void simple_call_test(void) { void simple_call_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -147,7 +156,8 @@ void simple_call_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void simple_call_in_test(void) { void simple_call_in_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -162,7 +172,8 @@ void simple_call_in_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void simple_call_every_test(void) { void simple_call_every_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -177,7 +188,8 @@ void simple_call_every_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void simple_post_test(void) { void simple_post_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -197,7 +209,8 @@ void simple_post_test(void) {
} }
// Misc tests // Misc tests
void destructor_test(void) { void destructor_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -253,7 +266,8 @@ void destructor_test(void) {
test_assert(touched == 3); test_assert(touched == 3);
} }
void allocation_failure_test(void) { void allocation_failure_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -269,7 +283,8 @@ void allocation_failure_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void cancel_test(int N) { void cancel_test(int N)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -293,7 +308,8 @@ void cancel_test(int N) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void cancel_inflight_test(void) { void cancel_inflight_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -328,7 +344,8 @@ void cancel_inflight_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void cancel_unnecessarily_test(void) { void cancel_unnecessarily_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -356,7 +373,8 @@ void cancel_unnecessarily_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void loop_protect_test(void) { void loop_protect_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -376,7 +394,8 @@ void loop_protect_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void break_test(void) { void break_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -391,7 +410,8 @@ void break_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void break_no_windup_test(void) { void break_no_windup_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -411,7 +431,8 @@ void break_no_windup_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void period_test(void) { void period_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -425,7 +446,8 @@ void period_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void nested_test(void) { void nested_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -462,7 +484,8 @@ void nested_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void sloth_test(void) { void sloth_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -483,13 +506,15 @@ void sloth_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void *multithread_thread(void *p) { void *multithread_thread(void *p)
{
equeue_t *q = (equeue_t *)p; equeue_t *q = (equeue_t *)p;
equeue_dispatch(q, -1); equeue_dispatch(q, -1);
return 0; return 0;
} }
void multithread_test(void) { void multithread_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -511,11 +536,13 @@ void multithread_test(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void background_func(void *p, int ms) { void background_func(void *p, int ms)
{
*(unsigned *)p = ms; *(unsigned *)p = ms;
} }
void background_test(void) { void background_test(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -542,7 +569,8 @@ void background_test(void) {
test_assert(ms == -1); test_assert(ms == -1);
} }
void chain_test(void) { void chain_test(void)
{
equeue_t q1; equeue_t q1;
int err = equeue_create(&q1, 2048); int err = equeue_create(&q1, 2048);
test_assert(!err); test_assert(!err);
@ -582,7 +610,8 @@ void chain_test(void) {
equeue_destroy(&q2); equeue_destroy(&q2);
} }
void unchain_test(void) { void unchain_test(void)
{
equeue_t q1; equeue_t q1;
int err = equeue_create(&q1, 2048); int err = equeue_create(&q1, 2048);
test_assert(!err); test_assert(!err);
@ -616,7 +645,8 @@ void unchain_test(void) {
} }
// Barrage tests // Barrage tests
void simple_barrage_test(int N) { void simple_barrage_test(int N)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, N * (EQUEUE_EVENT_SIZE + sizeof(struct timing))); int err = equeue_create(&q, N * (EQUEUE_EVENT_SIZE + sizeof(struct timing)));
test_assert(!err); test_assert(!err);
@ -639,7 +669,8 @@ void simple_barrage_test(int N) {
equeue_destroy(&q); equeue_destroy(&q);
} }
void fragmenting_barrage_test(int N) { void fragmenting_barrage_test(int N)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, int err = equeue_create(&q,
2 * N * (EQUEUE_EVENT_SIZE + sizeof(struct fragment) + N * sizeof(int))); 2 * N * (EQUEUE_EVENT_SIZE + sizeof(struct fragment) + N * sizeof(int)));
@ -671,13 +702,15 @@ struct ethread {
int ms; int ms;
}; };
static void *ethread_dispatch(void *p) { static void *ethread_dispatch(void *p)
{
struct ethread *t = (struct ethread *)p; struct ethread *t = (struct ethread *)p;
equeue_dispatch(t->q, t->ms); equeue_dispatch(t->q, t->ms);
return 0; return 0;
} }
void multithreaded_barrage_test(int N) { void multithreaded_barrage_test(int N)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, N * (EQUEUE_EVENT_SIZE + sizeof(struct timing))); int err = equeue_create(&q, N * (EQUEUE_EVENT_SIZE + sizeof(struct timing)));
test_assert(!err); test_assert(!err);
@ -707,20 +740,21 @@ void multithreaded_barrage_test(int N) {
equeue_destroy(&q); equeue_destroy(&q);
} }
struct count_and_queue struct count_and_queue {
{
int p; int p;
equeue_t *q; equeue_t *q;
}; };
void simple_breaker(void *p) { void simple_breaker(void *p)
{
struct count_and_queue *caq = (struct count_and_queue *)p; struct count_and_queue *caq = (struct count_and_queue *)p;
equeue_break(caq->q); equeue_break(caq->q);
usleep(10000); usleep(10000);
caq->p++; caq->p++;
} }
void break_request_cleared_on_timeout(void) { void break_request_cleared_on_timeout(void)
{
equeue_t q; equeue_t q;
int err = equeue_create(&q, 2048); int err = equeue_create(&q, 2048);
test_assert(!err); test_assert(!err);
@ -745,7 +779,8 @@ void break_request_cleared_on_timeout(void) {
equeue_destroy(&q); equeue_destroy(&q);
} }
int main() { int main()
{
printf("beginning tests...\n"); printf("beginning tests...\n");
test_run(simple_call_test); test_run(simple_call_test);