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
// 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);
}
// calculate the relative-difference between absolute times, but
// 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);
return ~(diff >> (8 * sizeof(int) -1)) & diff;
}
// 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;
if ((e->id << q->npw2) == 0) {
e->id = 1;
@ -44,7 +47,8 @@ static inline void equeue_incid(equeue_t *q, struct equeue_event *e) {
// 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
void *buffer = malloc(size);
if (!buffer) {
@ -56,7 +60,8 @@ int equeue_create(equeue_t *q, size_t size) {
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
q->buffer = buffer;
q->allocated = 0;
@ -99,7 +104,8 @@ int equeue_create_inplace(equeue_t *q, size_t size, void *buffer) {
return 0;
}
void equeue_destroy(equeue_t *q) {
void equeue_destroy(equeue_t *q)
{
// call destructors on pending events
for (struct equeue_event *es = q->queue; es; es = es->next) {
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
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
size += sizeof(struct equeue_event);
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;
}
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);
// 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);
}
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);
if (!e) {
return 0;
@ -196,7 +205,8 @@ void *equeue_alloc(equeue_t *q, size_t size) {
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;
if (e->dtor) {
@ -208,7 +218,8 @@ void equeue_dealloc(equeue_t *q, void *p) {
// 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
int id = (e->id << q->npw2) | ((unsigned char *)e - q->buffer);
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;
}
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
struct equeue_event *e = (struct equeue_event *)
&q->buffer[id & ((1 << q->npw2) - 1)];
@ -298,7 +310,8 @@ static struct equeue_event *equeue_unqueue(equeue_t *q, int id) {
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);
// 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;
}
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;
unsigned tick = equeue_tick();
e->cb = cb;
@ -353,7 +367,8 @@ int equeue_post(equeue_t *q, void (*cb)(void*), void *p) {
return id;
}
void equeue_cancel(equeue_t *q, int id) {
void equeue_cancel(equeue_t *q, int id)
{
if (!id) {
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;
if (!id) {
@ -383,14 +399,16 @@ int equeue_timeleft(equeue_t *q, int id) {
return ret;
}
void equeue_break(equeue_t *q) {
void equeue_break(equeue_t *q)
{
equeue_mutex_lock(&q->queuelock);
q->break_requested = true;
equeue_mutex_unlock(&q->queuelock);
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 timeout = tick + ms;
q->background.active = false;
@ -473,17 +491,20 @@ void equeue_dispatch(equeue_t *q, int ms) {
// 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;
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;
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;
e->dtor = dtor;
}
@ -495,12 +516,14 @@ struct ecallback {
void *data;
};
static void ecallback_dispatch(void *p) {
static void ecallback_dispatch(void *p)
{
struct ecallback *e = (struct ecallback *)p;
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));
if (!e) {
return 0;
@ -511,7 +534,8 @@ int equeue_call(equeue_t *q, void (*cb)(void*), void *data) {
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));
if (!e) {
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);
}
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));
if (!e) {
return 0;
@ -539,7 +564,8 @@ int equeue_call_every(equeue_t *q, int ms, void (*cb)(void*), void *data) {
// backgrounding
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);
if (q->background.update) {
q->background.update(q->background.timer, -1);
@ -562,11 +588,13 @@ struct equeue_chain_context {
int id;
};
static void equeue_chain_dispatch(void *p) {
static void equeue_chain_dispatch(void *p)
{
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;
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) {
equeue_background(q, 0, 0);
return;

27
events/equeue/equeue_posix.c
View File

@ -25,7 +25,8 @@
// Tick operations
unsigned equeue_tick(void) {
unsigned equeue_tick(void)
{
struct timeval tv;
gettimeofday(&tv, 0);
return (unsigned)(tv.tv_sec * 1000 + tv.tv_usec / 1000);
@ -33,25 +34,30 @@ unsigned equeue_tick(void) {
// Mutex operations
int equeue_mutex_create(equeue_mutex_t *m) {
int equeue_mutex_create(equeue_mutex_t *m)
{
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);
}
void equeue_mutex_lock(equeue_mutex_t *m) {
void equeue_mutex_lock(equeue_mutex_t *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);
}
// 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);
if (err) {
return err;
@ -66,19 +72,22 @@ int equeue_sema_create(equeue_sema_t *s) {
return 0;
}
void equeue_sema_destroy(equeue_sema_t *s) {
void equeue_sema_destroy(equeue_sema_t *s)
{
pthread_cond_destroy(&s->cond);
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);
s->signal = true;
pthread_cond_signal(&s->cond);
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);
if (!s->signal) {
if (ms < 0) {

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

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

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

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