LGTM, pushed, thanks.
> -----Original Message----- > From: Beignet [mailto:[email protected]] On Behalf Of > [email protected] > Sent: Wednesday, December 21, 2016 19:05 > To: [email protected] > Subject: [Beignet] [PATCH] Refine list related functions. > > From: Junyan He <[email protected]> > > Make the list related functions more clear and readable. > > Signed-off-by: Junyan He <[email protected]> > --- > src/cl_base_object.c | 6 +-- > src/cl_base_object.h | 2 +- > src/cl_command_queue_enqueue.c | 22 ++++----- > src/cl_context.c | 24 +++++----- > src/cl_event.c | 23 +++++---- > src/cl_event.h | 2 +- > src/cl_mem.c | 10 ++-- > src/cl_mem.h | 4 +- > src/cl_utils.c | 51 ++++++++++++++++++++ > src/cl_utils.h | 104 > ++++++++++++++++------------------------- > 10 files changed, 137 insertions(+), 111 deletions(-) > > diff --git a/src/cl_base_object.c b/src/cl_base_object.c index > 00c4b35..af537cc 100644 > --- a/src/cl_base_object.c > +++ b/src/cl_base_object.c > @@ -29,7 +29,7 @@ cl_object_init_base(cl_base_object obj, cl_ulong magic) > pthread_mutex_init(&obj->mutex, NULL); > pthread_cond_init(&obj->cond, NULL); > obj->owner = invalid_thread_id; > - list_init(&obj->node); > + list_node_init(&obj->node); > } > > LOCAL void > @@ -54,9 +54,9 @@ cl_object_destroy_base(cl_base_object obj) > assert(0); > } > > - if (!list_empty(&obj->node)) { > + if (!list_node_out_of_list(&obj->node)) { > DEBUGP(DL_ERROR, "CL object %p, call destroy while still belong to some > object %p", > - obj, obj->node.prev); > + obj, obj->node.p); > assert(0); > } > > diff --git a/src/cl_base_object.h b/src/cl_base_object.h index > 4e643df..d064a82 100644 > --- a/src/cl_base_object.h > +++ b/src/cl_base_object.h > @@ -47,7 +47,7 @@ typedef struct _cl_base_object { > DEFINE_ICD(dispatch); /* Dispatch function table for icd */ > cl_ulong magic; /* Magic number for each CL object */ > atomic_t ref; /* Reference for each CL object */ > - list_head node; /* CL object node belong to some container */ > + list_node node; /* CL object node belong to some container */ > pthread_mutex_t mutex; /* THe mutex to protect this object MT safe */ > pthread_cond_t cond; /* Condition to wait for getting the object */ > pthread_t owner; /* The thread which own this object */ > diff --git a/src/cl_command_queue_enqueue.c > b/src/cl_command_queue_enqueue.c index 32545b3..8bf05a2 100644 > --- a/src/cl_command_queue_enqueue.c > +++ b/src/cl_command_queue_enqueue.c > @@ -29,8 +29,8 @@ worker_thread_function(void *Arg) > cl_command_queue queue = worker->queue; > cl_event e; > cl_uint cookie = -1; > - list_head *pos; > - list_head *n; > + list_node *pos; > + list_node *n; > list_head ready_list; > cl_int exec_status; > > @@ -63,8 +63,8 @@ worker_thread_function(void *Arg) > { > e = list_entry(pos, _cl_event, enqueue_node); > if (cl_event_is_ready(e) <= CL_COMPLETE) { > - list_del(&e->enqueue_node); > - list_add_tail(&e->enqueue_node, &ready_list); > + list_node_del(&e->enqueue_node); > + list_add_tail(&ready_list, &e->enqueue_node); > } > } > > @@ -105,7 +105,7 @@ worker_thread_function(void *Arg) > list_for_each_safe(pos, n, &ready_list) > { > e = list_entry(pos, _cl_event, enqueue_node); > - list_del(&e->enqueue_node); > + list_node_del(&e->enqueue_node); > cl_event_delete(e); > } > > @@ -138,8 +138,8 @@ > cl_command_queue_enqueue_event(cl_command_queue queue, cl_event > event) > assert(CL_OBJECT_IS_COMMAND_QUEUE(queue)); > CL_OBJECT_LOCK(queue); > assert(queue->worker.quit == CL_FALSE); > - assert(list_empty(&event->enqueue_node)); > - list_add_tail(&event->enqueue_node, &queue- > >worker.enqueued_events); > + assert(list_node_out_of_list(&event->enqueue_node)); > + list_add_tail(&queue->worker.enqueued_events, &event- > >enqueue_node); > queue->worker.cookie++; > CL_OBJECT_NOTIFY_COND(queue); > CL_OBJECT_UNLOCK(queue); > @@ -167,8 +167,8 @@ LOCAL void > cl_command_queue_destroy_enqueue(cl_command_queue queue) { > cl_command_queue_enqueue_worker worker = &queue->worker; > - list_head *pos; > - list_head *n; > + list_node *pos; > + list_node *n; > cl_event e; > > assert(worker->queue == queue); > @@ -190,7 +190,7 @@ > cl_command_queue_destroy_enqueue(cl_command_queue queue) > list_for_each_safe(pos, n, &worker->enqueued_events) > { > e = list_entry(pos, _cl_event, enqueue_node); > - list_del(&e->enqueue_node); > + list_node_del(&e->enqueue_node); > cl_event_set_status(e, -1); // Give waiters a chance to wakeup. > cl_event_delete(e); > } > @@ -202,7 +202,7 @@ LOCAL cl_event * > cl_command_queue_record_in_queue_events(cl_command_queue queue, > cl_uint *list_num) { > int event_num = 0; > - list_head *pos; > + list_node *pos; > cl_command_queue_enqueue_worker worker = &queue->worker; > cl_event *enqueued_list = NULL; > int i; > diff --git a/src/cl_context.c b/src/cl_context.c index edff8a2..6b6cd62 100644 > --- a/src/cl_context.c > +++ b/src/cl_context.c > @@ -46,7 +46,7 @@ cl_context_add_queue(cl_context ctx, > cl_command_queue queue) { > cl_context_add_ref(ctx); > > CL_OBJECT_LOCK(ctx); > - list_add_tail(&queue->base.node, &ctx->queues); > + list_add_tail(&ctx->queues, &queue->base.node); > ctx->queue_num++; > ctx->queue_cookie++; > CL_OBJECT_UNLOCK(ctx); > @@ -58,7 +58,7 @@ LOCAL void > cl_context_remove_queue(cl_context ctx, cl_command_queue queue) { > assert(queue->ctx == ctx); > CL_OBJECT_LOCK(ctx); > - list_del(&queue->base.node); > + list_node_del(&queue->base.node); > ctx->queue_num--; > ctx->queue_cookie++; > CL_OBJECT_UNLOCK(ctx); > @@ -73,7 +73,7 @@ cl_context_add_mem(cl_context ctx, cl_mem mem) { > cl_context_add_ref(ctx); > > CL_OBJECT_LOCK(ctx); > - list_add_tail(&mem->base.node, &ctx->mem_objects); > + list_add_tail(&ctx->mem_objects, &mem->base.node); > ctx->mem_object_num++; > CL_OBJECT_UNLOCK(ctx); > > @@ -86,7 +86,7 @@ cl_context_add_svm(cl_context ctx, cl_mem mem) { > cl_context_add_ref(ctx); > > CL_OBJECT_LOCK(ctx); > - list_add_tail(&mem->base.node, &ctx->svm_objects); > + list_add_tail(&ctx->svm_objects, &mem->base.node); > ctx->svm_object_num++; > CL_OBJECT_UNLOCK(ctx); > > @@ -97,7 +97,7 @@ LOCAL void > cl_context_remove_mem(cl_context ctx, cl_mem mem) { > assert(mem->ctx == ctx); > CL_OBJECT_LOCK(ctx); > - list_del(&mem->base.node); > + list_node_del(&mem->base.node); > ctx->mem_object_num--; > CL_OBJECT_UNLOCK(ctx); > > @@ -111,7 +111,7 @@ cl_context_add_sampler(cl_context ctx, cl_sampler > sampler) { > cl_context_add_ref(ctx); > > CL_OBJECT_LOCK(ctx); > - list_add_tail(&sampler->base.node, &ctx->samplers); > + list_add_tail(&ctx->samplers, &sampler->base.node); > ctx->sampler_num++; > CL_OBJECT_UNLOCK(ctx); > > @@ -122,7 +122,7 @@ LOCAL void > cl_context_remove_sampler(cl_context ctx, cl_sampler sampler) { > assert(sampler->ctx == ctx); > CL_OBJECT_LOCK(ctx); > - list_del(&sampler->base.node); > + list_node_del(&sampler->base.node); > ctx->sampler_num--; > CL_OBJECT_UNLOCK(ctx); > > @@ -136,7 +136,7 @@ cl_context_add_event(cl_context ctx, cl_event event) > { > cl_context_add_ref(ctx); > > CL_OBJECT_LOCK(ctx); > - list_add_tail(&event->base.node, &ctx->events); > + list_add_tail(&ctx->events, &event->base.node); > ctx->event_num++; > CL_OBJECT_UNLOCK(ctx); > > @@ -147,7 +147,7 @@ LOCAL void > cl_context_remove_event(cl_context ctx, cl_event event) { > assert(event->ctx == ctx); > CL_OBJECT_LOCK(ctx); > - list_del(&event->base.node); > + list_node_del(&event->base.node); > ctx->event_num--; > CL_OBJECT_UNLOCK(ctx); > > @@ -161,7 +161,7 @@ cl_context_add_program(cl_context ctx, cl_program > program) { > cl_context_add_ref(ctx); > > CL_OBJECT_LOCK(ctx); > - list_add_tail(&program->base.node, &ctx->programs); > + list_add_tail(&ctx->programs, &program->base.node); > ctx->program_num++; > CL_OBJECT_UNLOCK(ctx); > > @@ -172,7 +172,7 @@ LOCAL void > cl_context_remove_program(cl_context ctx, cl_program program) { > assert(program->ctx == ctx); > CL_OBJECT_LOCK(ctx); > - list_del(&program->base.node); > + list_node_del(&program->base.node); > ctx->program_num--; > CL_OBJECT_UNLOCK(ctx); > > @@ -474,7 +474,7 @@ unlock: > cl_mem > cl_context_get_svm_from_ptr(cl_context ctx, const void * p) { > - struct list_head *pos; > + struct list_node *pos; > cl_mem buf; > > list_for_each (pos, (&ctx->mem_objects)) { diff --git a/src/cl_event.c > b/src/cl_event.c index 0804dbd..8a58806 100644 > --- a/src/cl_event.c > +++ b/src/cl_event.c > @@ -99,7 +99,7 @@ cl_event_new(cl_context ctx, cl_command_queue > queue, cl_command_type type, > e->queue = queue; > > list_init(&e->callbacks); > - list_init(&e->enqueue_node); > + list_node_init(&e->enqueue_node); > > assert(type >= CL_COMMAND_NDRANGE_KERNEL && type <= > CL_COMMAND_FILL_IMAGE); > e->event_type = type; > @@ -132,7 +132,7 @@ cl_event_delete(cl_event event) > > cl_enqueue_delete(&event->exec_data); > > - assert(list_empty(&event->enqueue_node)); > + assert(list_node_out_of_list(&event->enqueue_node)); > > if (event->depend_events) { > assert(event->depend_event_num); > @@ -144,8 +144,8 @@ cl_event_delete(cl_event event) > > /* Free all the callbacks. Last ref, no need to lock. */ > while (!list_empty(&event->callbacks)) { > - cb = list_entry(event->callbacks.next, _cl_event_user_callback, node); > - list_del(&cb->node); > + cb = list_entry(event->callbacks.head_node.n, _cl_event_user_callback, > node); > + list_node_del(&cb->node); > cl_free(cb); > } > > @@ -261,7 +261,7 @@ cl_event_set_callback(cl_event event, cl_int > exec_type, cl_event_notify_cb pfn_n > break; > } > > - list_init(&cb->node); > + list_node_init(&cb->node); > cb->pfn_notify = pfn_notify; > cb->user_data = user_data; > cb->status = exec_type; > @@ -269,7 +269,7 @@ cl_event_set_callback(cl_event event, cl_int > exec_type, cl_event_notify_cb pfn_n > > CL_OBJECT_LOCK(event); > if (event->status > exec_type) { > - list_add_tail(&cb->node, &event->callbacks); > + list_add_tail(&event->callbacks, &cb->node); > cb = NULL; > } else { > /* The state has already OK, call it immediately. */ @@ -293,8 +293,8 > @@ > LOCAL cl_int cl_event_set_status(cl_event event, cl_int status) { > list_head tmp_callbacks; > - list_head *n; > - list_head *pos; > + list_node *n; > + list_node *pos; > cl_bool notify_queue = CL_FALSE; > cl_event_user_callback cb; > > @@ -324,8 +324,7 @@ cl_event_set_status(cl_event event, cl_int status) > do { > status = event->status; > list_init(&tmp_callbacks); > - list_replace(&event->callbacks, &tmp_callbacks); > - list_init(&event->callbacks); > + list_move(&event->callbacks, &tmp_callbacks); > /* Call all the callbacks without lock. */ > CL_OBJECT_UNLOCK(event); > > @@ -338,7 +337,7 @@ cl_event_set_status(cl_event event, cl_int status) > if (cb->status < status) > continue; > > - list_del(&cb->node); > + list_node_del(&cb->node); > cb->executed = CL_TRUE; > cb->pfn_notify(event, status, cb->user_data); > cl_free(cb); > @@ -347,7 +346,7 @@ cl_event_set_status(cl_event event, cl_int status) > CL_OBJECT_LOCK(event); > > // Set back the uncalled callbacks. > - list_splice_tail(&tmp_callbacks, &event->callbacks); > + list_merge(&event->callbacks, &tmp_callbacks); > > /* Status may changed because we unlock. need to check again. */ > } while (status != event->status); > diff --git a/src/cl_event.h b/src/cl_event.h index f67299c..25177da 100644 > --- a/src/cl_event.h > +++ b/src/cl_event.h > @@ -32,7 +32,7 @@ typedef struct _cl_event_user_callback { > cl_bool executed; /* Indicat the callback function been > called or not > */ > cl_event_notify_cb pfn_notify; /* Callback function */ > void *user_data; /* Callback user data */ > - list_head node; /* Event callback list node */ > + list_node node; /* Event callback list node */ > } _cl_event_user_callback; > > typedef _cl_event_user_callback *cl_event_user_callback; diff --git > a/src/cl_mem.c b/src/cl_mem.c index d105bff..b45bc04 100644 > --- a/src/cl_mem.c > +++ b/src/cl_mem.c > @@ -269,7 +269,7 @@ error: > LOCAL cl_int > cl_mem_is_valid(cl_mem mem, cl_context ctx) { > - struct list_head *pos; > + struct list_node *pos; > cl_base_object pbase_object; > > CL_OBJECT_LOCK(ctx); > @@ -1229,8 +1229,8 @@ cl_mem_delete(cl_mem mem) > > /* First, call all the callbacks registered by user. */ > while (!list_empty(&mem->dstr_cb_head)) { > - cb = list_entry(mem->dstr_cb_head.next, _cl_mem_dstr_cb, node); > - list_del(&cb->node); > + cb = list_entry(mem->dstr_cb_head.head_node.n, _cl_mem_dstr_cb, > node); > + list_node_del(&cb->node); > cb->pfn_notify(mem, cb->user_data); > cl_free(cb); > } > @@ -2470,12 +2470,12 @@ cl_mem_set_destructor_callback(cl_mem > memobj, > } > > memset(cb, 0, sizeof(_cl_mem_dstr_cb)); > - list_init(&cb->node); > + list_node_init(&cb->node); > cb->pfn_notify = pfn_notify; > cb->user_data = user_data; > > CL_OBJECT_LOCK(memobj); > - list_add(&cb->node, &memobj->dstr_cb_head, memobj- > >dstr_cb_head.next); > + list_add(&memobj->dstr_cb_head, &cb->node); > CL_OBJECT_UNLOCK(memobj); > return CL_SUCCESS; > } > diff --git a/src/cl_mem.h b/src/cl_mem.h index dbe4bec..43d30aa 100644 > --- a/src/cl_mem.h > +++ b/src/cl_mem.h > @@ -64,8 +64,8 @@ typedef struct _cl_mapped_ptr { }cl_mapped_ptr; > > typedef struct _cl_mem_dstr_cb { > - list_head node; /* Mem callback list node */ > - void (CL_CALLBACK *pfn_notify)(cl_mem memobj, void *user_data); > + list_node node; /* Mem callback list node */ void(CL_CALLBACK > + *pfn_notify)(cl_mem memobj, void *user_data); > void *user_data; > } _cl_mem_dstr_cb; > typedef _cl_mem_dstr_cb* cl_mem_dstr_cb; diff --git a/src/cl_utils.c > b/src/cl_utils.c index 0d0a12f..bc62feb 100644 > --- a/src/cl_utils.c > +++ b/src/cl_utils.c > @@ -18,6 +18,57 @@ > > #include "cl_utils.h" > #include <string.h> > +#include <assert.h> > + > +LOCAL void > +list_node_insert_before(struct list_node *node, struct list_node > +*the_new) { > + list_node *before_node = node->p; > + the_new->p = before_node; > + the_new->n = node; > + node->p = the_new; > + before_node->n = the_new; > +} > + > +LOCAL void > +list_node_insert_after(struct list_node *node, struct list_node > +*the_new) { > + list_node *after_node = node->n; > + the_new->n = after_node; > + the_new->p = node; > + node->n = the_new; > + after_node->p = the_new; > +} > + > +LOCAL void > +list_move(struct list_head *the_old, struct list_head *the_new) { > + assert(list_empty(the_new)); > + if (list_empty(the_old)) { > + return; > + } > + > + memcpy(&the_new->head_node, &the_old->head_node, > sizeof(list_node)); > + the_new->head_node.n->p = &the_new->head_node; > + the_new->head_node.p->n = &the_new->head_node; > + list_init(the_old); > +} > + > +LOCAL void > +list_merge(struct list_head *head, struct list_head *to_merge) { > + if (list_empty(to_merge)) > + return; > + > + list_node *merge_last_node = to_merge->head_node.p; list_node > + *merge_first_node = to_merge->head_node.n; > + > + merge_last_node->n = &head->head_node; > + merge_first_node->p = head->head_node.p; > + head->head_node.p->n = merge_first_node; > + head->head_node.p = merge_last_node; > + list_init(to_merge); > +} > > LOCAL cl_int > cl_get_info_helper(const void *src, size_t src_size, void *dst, size_t > dst_size, > size_t *ret_size) diff --git a/src/cl_utils.h b/src/cl_utils.h index > 829b774..2d24207 100644 > --- a/src/cl_utils.h > +++ b/src/cl_utils.h > @@ -359,79 +359,55 @@ static INLINE int atomic_read(atomic_t *v) { static > INLINE int atomic_inc(atomic_t *v) { return atomic_add(v, 1); } static INLINE > int atomic_dec(atomic_t *v) { return atomic_add(v, -1); } > > -/* The list. */ > +/* Define one list node. */ > +typedef struct list_node { > + struct list_node *n; > + struct list_node *p; > +} list_node; > typedef struct list_head { > - struct list_head *next, *prev; > + list_node head_node; > } list_head; > > -static inline void list_init(struct list_head *head) > +static inline void list_node_init(list_node *node) > { > - head->next = head->prev = head; > + node->n = node; > + node->p = node; > } > -static inline void list_add(struct list_head *the_new, > - struct list_head *prev, struct list_head *next) > +static inline int list_node_out_of_list(const struct list_node *node) > { > - next->prev = the_new; > - the_new->next = next; > - the_new->prev = prev; > - prev->next = the_new; > + return node->n == node; > } > -static inline void list_add_tail(struct list_head *the_new, struct list_head > *head) > +static inline void list_init(list_head *head) > { > - list_add(the_new, head->prev, head); > + head->head_node.n = &head->head_node; head->head_node.p = > + &head->head_node; > } > -static inline void list_del(struct list_head *node) > +extern void list_node_insert_before(list_node *node, list_node > +*the_new); extern void list_node_insert_after(list_node *node, > +list_node *the_new); static inline void list_node_del(struct list_node > +*node) > { > - node->next->prev = node->prev; > - node->prev->next = node->next; > - node->prev = node->next = node; > + node->n->p = node->p; > + node->p->n = node->n; > + /* And all point to self for safe. */ node->p = node; node->n = > + node; > } > -static inline void list_replace(struct list_head *the_old, struct list_head > *the_new) > +static inline void list_add(list_head *head, list_node *the_new) > { > - the_new->next = the_old->next; > - the_new->next->prev = the_new; > - the_new->prev = the_old->prev; > - the_new->prev->next = the_new; > + list_node_insert_after(&head->head_node, the_new); > } > -static inline int list_empty(const struct list_head *head) -{ > - return head->next == head; > -} > -static inline int list_is_last(const struct list_head *list, const struct > list_head > *head) -{ > - return list->next == head; > -} > -static inline void __list_splice(struct list_head *list, > - struct list_head *prev, struct list_head > *next) > -{ > - struct list_head *first = list->next; > - struct list_head *last = list->prev; > - > - first->prev = prev; > - prev->next = first; > - > - last->next = next; > - next->prev = last; > - > - list_init(list); > -} > -/** > - * list_splice - join two lists > - */ > -static inline void list_splice(struct list_head *list, struct list_head > *head) > +static inline void list_add_tail(list_head *head, list_node *the_new) > { > - if (!list_empty(list)) > - __list_splice(list, head, head->next); > + list_node_insert_before(&head->head_node, the_new); > } > - > -/** > - * list_splice_tail - join two lists, each list being a queue > - */ > -static inline void list_splice_tail(struct list_head *list, struct list_head > *head) > +static inline int list_empty(const struct list_head *head) > { > - if (!list_empty(list)) > - __list_splice(list, head->prev, head); > + return head->head_node.n == &head->head_node; > } > +/* Move the content from one head to another. */ extern void > +list_move(struct list_head *the_old, struct list_head *the_new); > +/* Merge the content of the two lists to one head. */ extern void > +list_merge(struct list_head *head, struct list_head *to_merge); > > #undef offsetof > #ifdef __compiler_offsetof > @@ -439,17 +415,17 @@ static inline void list_splice_tail(struct list_head > *list, > struct list_head *he #else #define offsetof(TYPE, MEMBER) ((size_t) & > ((TYPE *)0)->MEMBER) #endif > -#define container_of(ptr, type, member) ({ \ > - const typeof( ((type *)0)->member ) *__mptr = (ptr); \ > +#define list_entry(ptr, type, member) ({ \ > + const typeof( ((type *)0)->member ) *__mptr = (ptr); \ > (type *)( (char *)__mptr - offsetof(type,member) ); }) -#define > list_entry(ptr, type, member) container_of(ptr, type, member) > > #define list_for_each(pos, head) \ > - for (pos = (head)->next; pos != (head); pos = pos->next) > + for (pos = (head)->head_node.n; pos != &((head)->head_node); pos = > + pos->n) > > -#define list_for_each_safe(pos, n, head) \ > - for (pos = (head)->next, n = pos->next; pos != (head); \ > - pos = n, n = pos->next) > +#define list_for_each_safe(pos, ne, head) \ > + for (pos = (head)->head_node.n, ne = pos->n; pos != &((head)- > >head_node); \ > + pos = ne, ne = pos->n) > > -extern cl_int cl_get_info_helper(const void *src, size_t src_size, void *dst, > size_t dst_size, size_t *ret_size); > +extern cl_int cl_get_info_helper(const void *src, size_t src_size, void *dst, > + size_t dst_size, size_t *ret_size); > #endif /* __CL_UTILS_H__ */ > -- > 2.7.4 > > > > _______________________________________________ > Beignet mailing list > [email protected] > https://lists.freedesktop.org/mailman/listinfo/beignet _______________________________________________ Beignet mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/beignet
