LGTM, pushed, thanks. > -----Original Message----- > From: Beignet [mailto:[email protected]] On Behalf Of > [email protected] > Sent: Wednesday, September 28, 2016 16:38 > To: [email protected] > Subject: [Beignet] [PATCH] Delete useless cl_thread files. > > From: Junyan He <[email protected]> > > Signed-off-by: Junyan He <[email protected]> > --- > src/CMakeLists.txt | 1 - > src/cl_command_queue.c | 37 ----- > src/cl_command_queue.h | 14 -- > src/cl_command_queue_gen7.c | 2 - > src/cl_device_id.c | 1 - > src/cl_thread.c | 329 > -------------------------------------------- > src/cl_thread.h | 52 ------- > 7 files changed, 436 deletions(-) > delete mode 100644 src/cl_thread.c > delete mode 100644 src/cl_thread.h > > diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 626b43f..559380a > 100644 > --- a/src/CMakeLists.txt > +++ b/src/CMakeLists.txt > @@ -90,7 +90,6 @@ set(OPENCL_SRC > cl_command_queue.h > cl_command_queue_gen7.c > cl_command_queue_enqueue.c > - cl_thread.c > cl_driver.h > cl_driver.cpp > cl_driver_defs.c > diff --git a/src/cl_command_queue.c b/src/cl_command_queue.c index > 54a487c..a63efaf 100644 > --- a/src/cl_command_queue.c > +++ b/src/cl_command_queue.c > @@ -25,7 +25,6 @@ > #include "cl_device_id.h" > #include "cl_mem.h" > #include "cl_utils.h" > -#include "cl_thread.h" > #include "cl_alloc.h" > #include "cl_driver.h" > #include "cl_khr_icd.h" > @@ -47,10 +46,6 @@ cl_command_queue_new(cl_context ctx) > CL_OBJECT_INIT_BASE(queue, CL_OBJECT_COMMAND_QUEUE_MAGIC); > cl_command_queue_init_enqueue(queue); > > - if ((queue->thread_data = cl_thread_data_create()) == NULL) { > - goto error; > - } > - > /* Append the command queue in the list */ > cl_context_add_queue(ctx, queue); > queue->ctx = ctx; > @@ -82,8 +77,6 @@ cl_command_queue_delete(cl_command_queue > queue) > // a chance to call the call-back function. > //cl_event_update_last_events(queue,1); > > - cl_thread_data_destroy(queue); > - queue->thread_data = NULL; > cl_mem_delete(queue->perf); > cl_context_remove_queue(queue->ctx, queue); > cl_free(queue->wait_events); > @@ -154,8 +147,6 @@ > cl_command_queue_bind_image(cl_command_queue queue, cl_kernel k, > cl_gpgpu gpgpu) LOCAL cl_int > cl_command_queue_bind_surface(cl_command_queue queue, cl_kernel k, > cl_gpgpu gpgpu) { > - //GET_QUEUE_THREAD_GPGPU(queue); > - > /* Bind all user buffers (given by clSetKernelArg) */ > uint32_t i; > enum gbe_arg_type arg_type; /* kind of argument */ @@ -248,34 +239,6 > @@ cl_command_queue_flush_gpgpu(cl_gpgpu gpgpu) > return CL_SUCCESS; > } > > -LOCAL cl_int > -cl_command_queue_flush(cl_command_queue queue) -{ > - int err; > - GET_QUEUE_THREAD_GPGPU(queue); > - err = cl_command_queue_flush_gpgpu(gpgpu); > - // We now keep a list of uncompleted events and check if they compelte > - // every flush. This can make sure all events created have chance to be > - // update status, so the callback functions or reference can be handled. > - //cl_event_update_last_events(queue,0); > - > - cl_event current_event = get_current_event(queue); > - if (current_event && err == CL_SUCCESS) { > - //err = cl_event_flush(current_event); > - set_current_event(queue, NULL); > - } > - cl_invalid_thread_gpgpu(queue); > - return err; > -} > - > -LOCAL cl_int > -cl_command_queue_finish(cl_command_queue queue) -{ > - cl_gpgpu_sync(cl_get_thread_batch_buf(queue)); > - //cl_event_update_last_events(queue,1); > - return CL_SUCCESS; > -} > - > #define DEFAULT_WAIT_EVENTS_SIZE 16 > LOCAL void > cl_command_queue_insert_event(cl_command_queue queue, cl_event > event) diff --git a/src/cl_command_queue.h b/src/cl_command_queue.h > index 42ea7b2..7a8afbf 100644 > --- a/src/cl_command_queue.h > +++ b/src/cl_command_queue.h > @@ -22,7 +22,6 @@ > > #include "cl_internals.h" > #include "cl_driver.h" > -#include "cl_thread.h" > #include "cl_base_object.h" > #include "CL/cl.h" > #include <stdint.h> > @@ -52,7 +51,6 @@ struct _cl_command_queue { > cl_int wait_events_num; /* Number of Non-complete user events > */ > cl_int wait_events_size; /* The size of array that wait_events > point to > */ > cl_command_queue_properties props; /* Queue properties */ > - void *thread_data; /* Used to store thread context data > */ > cl_mem perf; /* Where to put the perf counters */ > > void* cmrt_event; /* the latest CmEvent* of the command > queue > */ > @@ -63,12 +61,6 @@ struct _cl_command_queue { > ((cl_base_object)obj)->magic == > CL_OBJECT_COMMAND_QUEUE_MAGIC && \ > CL_OBJECT_GET_REF(obj) >= 1)) > > -/* The macro to get the thread specified gpgpu struct. */ -#define > GET_QUEUE_THREAD_GPGPU(queue) \ > - cl_gpgpu gpgpu = queue ? cl_get_thread_gpgpu(queue) : NULL; \ > - if (queue) \ > - assert(gpgpu); > - > /* Allocate and initialize a new command queue. Also insert it in the list of > * command queue in the associated context > */ > @@ -92,15 +84,9 @@ extern cl_int > cl_command_queue_ND_range(cl_command_queue queue, > /* The memory object where to report the performance */ extern cl_int > cl_command_queue_set_report_buffer(cl_command_queue, cl_mem); > > -/* Flush for the command queue */ > -extern cl_int cl_command_queue_flush(cl_command_queue); > - > /* Flush for the specified gpgpu */ > extern int cl_command_queue_flush_gpgpu(cl_gpgpu); > > -/* Wait for the completion of the command queue */ -extern cl_int > cl_command_queue_finish(cl_command_queue); > - > /* Bind all the surfaces in the GPGPU state */ extern cl_int > cl_command_queue_bind_surface(cl_command_queue, cl_kernel, > cl_gpgpu); > > diff --git a/src/cl_command_queue_gen7.c > b/src/cl_command_queue_gen7.c index 5ad3b8b..37082a6 100644 > --- a/src/cl_command_queue_gen7.c > +++ b/src/cl_command_queue_gen7.c > @@ -129,7 +129,6 @@ cl_upload_constant_buffer(cl_command_queue > queue, cl_kernel ker, cl_gpgpu gpgpu) > /* calculate constant buffer size > * we need raw_size & aligned_size > */ > - //GET_QUEUE_THREAD_GPGPU(queue); > int32_t arg; > size_t offset = 0; > uint32_t raw_size = 0, aligned_size =0; @@ -338,7 +337,6 @@ > cl_command_queue_ND_range_gen7(cl_command_queue queue, > const size_t *global_wk_sz, > const size_t *local_wk_sz) { > - //GET_QUEUE_THREAD_GPGPU(queue); > cl_gpgpu gpgpu = cl_gpgpu_new(queue->ctx->drv); > cl_context ctx = queue->ctx; > char *final_curbe = NULL; /* Includes them and one sub-buffer per group > */ diff --git a/src/cl_device_id.c b/src/cl_device_id.c index df3355c..e1ceee1 > 100644 > --- a/src/cl_device_id.c > +++ b/src/cl_device_id.c > @@ -24,7 +24,6 @@ > #include "cl_driver.h" > #include "cl_device_data.h" > #include "cl_khr_icd.h" > -#include "cl_thread.h" > #include "CL/cl.h" > #include "CL/cl_ext.h" > #include "CL/cl_intel.h" > diff --git a/src/cl_thread.c b/src/cl_thread.c deleted file mode 100644 index > 0780513..0000000 > --- a/src/cl_thread.c > +++ /dev/null > @@ -1,329 +0,0 @@ > -/* > - * Copyright © 2012 Intel Corporation > - * > - * This library is free software; you can redistribute it and/or > - * modify it under the terms of the GNU Lesser General Public > - * License as published by the Free Software Foundation; either > - * version 2.1 of the License, or (at your option) any later version. > - * > - * This library is distributed in the hope that it will be useful, > - * but WITHOUT ANY WARRANTY; without even the implied warranty of > - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > GNU > - * Lesser General Public License for more details. > - * > - * You should have received a copy of the GNU Lesser General Public > - * License along with this library. If not, see > <http://www.gnu.org/licenses/>. > - * > - */ > -#include <string.h> > -#include <stdio.h> > - > -#include "cl_thread.h" > -#include "cl_alloc.h" > -#include "cl_utils.h" > - > -/* Because the cl_command_queue can be used in several threads > simultaneously but > - without add ref to it, we now handle it like this: > - Keep one threads_slot_array, every time the thread get gpgpu or batch > buffer, if it > - does not have a slot, assign it. > - The resources are keeped in queue private, and resize it if needed. > - When the thread exit, the slot will be set invalid. > - When queue released, all the resources will be released. If user still > enqueue, flush > - or finish the queue after it has been released, the behavior is undefined. > - TODO: Need to shrink the slot map. > - */ > - > -static int thread_array_num = 1; > -static int *thread_slot_map = NULL; > -static int thread_magic_num = 1; > -static pthread_mutex_t thread_queue_map_lock = > PTHREAD_MUTEX_INITIALIZER; > - > -typedef struct _thread_spec_data { > - cl_gpgpu gpgpu ; > - int valid; > - void* thread_batch_buf; > - cl_event last_event; > - cl_event current_event; > - int thread_magic; > -} thread_spec_data; > - > -typedef struct _queue_thread_private { > - thread_spec_data** threads_data; > - int threads_data_num; > - pthread_mutex_t thread_data_lock; > -} queue_thread_private; > - > -static pthread_once_t key_once = PTHREAD_ONCE_INIT; -static > pthread_key_t thread_id_key; -static pthread_key_t thread_magic_key; > - > -static void create_thread_key() > -{ > - pthread_key_create(&thread_id_key, NULL); > - pthread_key_create(&thread_magic_key, NULL); -} > - > -static thread_spec_data * > __create_thread_spec_data(cl_command_queue queue, int create) -{ > - queue_thread_private *thread_private = ((queue_thread_private > *)(queue->thread_data)); > - thread_spec_data* spec = NULL; > - int i = 0; > - int *id = NULL, *magic = NULL; > - > - pthread_once(&key_once, create_thread_key); > - id = pthread_getspecific(thread_id_key); > - if(id == NULL) { > - id = (int *)malloc(sizeof(int)); > - *id = -1; > - pthread_setspecific(thread_id_key, id); > - } > - magic = pthread_getspecific(thread_magic_key); > - if(magic == NULL) { > - magic = (int *)malloc(sizeof(int)); > - *magic = -1; > - pthread_setspecific(thread_magic_key, magic); > - } > - > - if (*id == -1) { > - pthread_mutex_lock(&thread_queue_map_lock); > - for (i = 0; i < thread_array_num; i++) { > - if (thread_slot_map[i] == 0) { > - *id = i; > - break; > - } > - } > - > - if (i == thread_array_num) { > - thread_array_num *= 2; > - thread_slot_map = realloc(thread_slot_map, sizeof(int) * > thread_array_num); > - > - if(thread_slot_map == NULL) { > - pthread_mutex_unlock(&thread_queue_map_lock); > - return NULL; > - } > - > - memset(thread_slot_map + thread_array_num/2, 0, sizeof(int) * > (thread_array_num/2)); > - *id = thread_array_num/2; > - } > - > - thread_slot_map[*id] = 1; > - > - *magic = thread_magic_num++; > - pthread_mutex_unlock(&thread_queue_map_lock); > - } > - > - pthread_mutex_lock(&thread_private->thread_data_lock); > - if (thread_array_num > thread_private->threads_data_num) {// just > enlarge > - int old_num = thread_private->threads_data_num; > - thread_private->threads_data_num = thread_array_num; > - thread_private->threads_data = realloc(thread_private->threads_data, > - thread_private->threads_data_num * sizeof(void *)); > - > - if(thread_private->threads_data == NULL) { > - pthread_mutex_unlock(&thread_private->thread_data_lock); > - return NULL; > - } > - > - memset(thread_private->threads_data + old_num, 0, > - sizeof(void*) * (thread_private->threads_data_num - old_num)); > - } > - > - assert(*id != -1 && *id < thread_array_num); > - spec = thread_private->threads_data[*id]; > - if (!spec && create) { > - spec = CALLOC(thread_spec_data); > - spec->thread_magic = *magic; > - thread_private->threads_data[*id] = spec; > - } > - > - pthread_mutex_unlock(&thread_private->thread_data_lock); > - > - return spec; > -} > - > -cl_event get_current_event(cl_command_queue queue) -{ > - thread_spec_data* spec = __create_thread_spec_data(queue, 1); > - int *magic = pthread_getspecific(thread_magic_key); > - assert(spec && magic && spec->thread_magic == *magic); > - return spec->current_event; > -} > - > -cl_event get_last_event(cl_command_queue queue) -{ > - thread_spec_data* spec = __create_thread_spec_data(queue, 1); > - int *magic = pthread_getspecific(thread_magic_key); > - assert(spec && magic && spec->thread_magic == *magic); > - return spec->last_event; > -} > - > -void set_current_event(cl_command_queue queue, cl_event e) -{ > - thread_spec_data* spec = __create_thread_spec_data(queue, 1); > - int *magic = pthread_getspecific(thread_magic_key); > - assert(spec && magic && spec->thread_magic == *magic); > - spec->current_event = e; > -} > - > -void set_last_event(cl_command_queue queue, cl_event e) -{ > - thread_spec_data* spec = __create_thread_spec_data(queue, 1); > - int *magic = pthread_getspecific(thread_magic_key); > - assert(spec && magic && spec->thread_magic == *magic); > - spec->last_event = e; > -} > - > -void* cl_thread_data_create(void) > -{ > - queue_thread_private* thread_private = CALLOC(queue_thread_private); > - > - if (thread_private == NULL) > - return NULL; > - > - if (thread_slot_map == NULL) { > - pthread_mutex_lock(&thread_queue_map_lock); > - thread_slot_map = calloc(thread_array_num, sizeof(int)); > - pthread_mutex_unlock(&thread_queue_map_lock); > - > - } > - > - pthread_mutex_init(&thread_private->thread_data_lock, NULL); > - > - pthread_mutex_lock(&thread_private->thread_data_lock); > - thread_private->threads_data = malloc(thread_array_num * sizeof(void > *)); > - memset(thread_private->threads_data, 0, sizeof(void*) * > thread_array_num); > - thread_private->threads_data_num = thread_array_num; > - pthread_mutex_unlock(&thread_private->thread_data_lock); > - > - return thread_private; > -} > - > -cl_gpgpu cl_get_thread_gpgpu(cl_command_queue queue) -{ > - thread_spec_data* spec = __create_thread_spec_data(queue, 1); > - if(!spec) > - return NULL; > - int *magic = pthread_getspecific(thread_magic_key); > - assert(magic); > - > - if (!spec->thread_magic && spec->thread_magic != *magic) { > - //We may get the slot from last thread. So free the resource. > - spec->valid = 0; > - } > - > - if (!spec->valid) { > - if (spec->thread_batch_buf) { > - cl_gpgpu_unref_batch_buf(spec->thread_batch_buf); > - spec->thread_batch_buf = NULL; > - } > - if (spec->gpgpu) { > - cl_gpgpu_delete(spec->gpgpu); > - spec->gpgpu = NULL; > - } > - TRY_ALLOC_NO_ERR(spec->gpgpu, cl_gpgpu_new(queue->ctx->drv)); > - spec->valid = 1; > - } > - > - error: > - return spec->gpgpu; > -} > - > -void cl_set_thread_batch_buf(cl_command_queue queue, void* buf) -{ > - thread_spec_data* spec = __create_thread_spec_data(queue, 1); > - int *magic = pthread_getspecific(thread_magic_key); > - > - assert(spec && magic && spec->thread_magic == *magic); > - > - if (spec->thread_batch_buf) { > - cl_gpgpu_unref_batch_buf(spec->thread_batch_buf); > - } > - spec->thread_batch_buf = buf; > -} > - > -void* cl_get_thread_batch_buf(cl_command_queue queue) { > - thread_spec_data* spec = __create_thread_spec_data(queue, 1); > - int *magic = pthread_getspecific(thread_magic_key); > - > - assert(spec && magic && spec->thread_magic == *magic); > - > - return spec->thread_batch_buf; > -} > - > -void cl_invalid_thread_gpgpu(cl_command_queue queue) -{ > - int *id = pthread_getspecific(thread_id_key); > - queue_thread_private *thread_private = ((queue_thread_private > *)(queue->thread_data)); > - thread_spec_data* spec = NULL; > - > - pthread_mutex_lock(&thread_private->thread_data_lock); > - assert(id); > - spec = thread_private->threads_data[*id]; > - assert(spec); > - pthread_mutex_unlock(&thread_private->thread_data_lock); > - > - if (!spec->valid) { > - return; > - } > - > - assert(spec->gpgpu); > - cl_gpgpu_delete(spec->gpgpu); > - spec->gpgpu = NULL; > - spec->valid = 0; > -} > - > -cl_gpgpu cl_thread_gpgpu_take(cl_command_queue queue) -{ > - int *id = pthread_getspecific(thread_id_key); > - queue_thread_private *thread_private = ((queue_thread_private > *)(queue->thread_data)); > - thread_spec_data* spec = NULL; > - > - pthread_mutex_lock(&thread_private->thread_data_lock); > - assert(id); > - spec = thread_private->threads_data[*id]; > - assert(spec); > - pthread_mutex_unlock(&thread_private->thread_data_lock); > - > - if (!spec->valid) > - return NULL; > - > - assert(spec->gpgpu); > - cl_gpgpu gpgpu = spec->gpgpu; > - spec->gpgpu = NULL; > - spec->valid = 0; > - return gpgpu; > -} > - > -/* The destructor for clean the thread specific data. */ -void > cl_thread_data_destroy(cl_command_queue queue) -{ > - int i = 0; > - queue_thread_private *thread_private = ((queue_thread_private > *)(queue->thread_data)); > - int threads_data_num; > - thread_spec_data** threads_data; > - > - pthread_mutex_lock(&thread_private->thread_data_lock); > - threads_data_num = thread_private->threads_data_num; > - threads_data = thread_private->threads_data; > - thread_private->threads_data_num = 0; > - thread_private->threads_data = NULL; > - pthread_mutex_unlock(&thread_private->thread_data_lock); > - cl_free(thread_private); > - queue->thread_data = NULL; > - > - for (i = 0; i < threads_data_num; i++) { > - if (threads_data[i] != NULL && threads_data[i]->thread_batch_buf) { > - cl_gpgpu_unref_batch_buf(threads_data[i]->thread_batch_buf); > - threads_data[i]->thread_batch_buf = NULL; > - } > - > - if (threads_data[i] != NULL && threads_data[i]->valid) { > - cl_gpgpu_delete(threads_data[i]->gpgpu); > - threads_data[i]->gpgpu = NULL; > - threads_data[i]->valid = 0; > - } > - cl_free(threads_data[i]); > - } > - > - cl_free(threads_data); > -} > diff --git a/src/cl_thread.h b/src/cl_thread.h deleted file mode 100644 index > d77526b..0000000 > --- a/src/cl_thread.h > +++ /dev/null > @@ -1,52 +0,0 @@ > -/* > - * Copyright © 2012 Intel Corporation > - * > - * This library is free software; you can redistribute it and/or > - * modify it under the terms of the GNU Lesser General Public > - * License as published by the Free Software Foundation; either > - * version 2.1 of the License, or (at your option) any later version. > - * > - * This library is distributed in the hope that it will be useful, > - * but WITHOUT ANY WARRANTY; without even the implied warranty of > - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > GNU > - * Lesser General Public License for more details. > - * > - * You should have received a copy of the GNU Lesser General Public > - * License along with this library. If not, see > <http://www.gnu.org/licenses/>. > - * > - */ > - > -#ifndef __CL_THREAD_H__ > -#define __CL_THREAD_H__ > - > -#include <pthread.h> > -#include "cl_internals.h" > -#include "cl_command_queue.h" > - > -/* Create the thread specific data. */ > -void* cl_thread_data_create(void); > - > -/* The destructor for clean the thread specific data. */ -void > cl_thread_data_destroy(cl_command_queue queue); > - > -/* Used to get the gpgpu struct of each thread. */ -cl_gpgpu > cl_get_thread_gpgpu(cl_command_queue queue); > - > -/* Used to release the gpgpu struct of each thread. */ -void > cl_invalid_thread_gpgpu(cl_command_queue queue); > - > -/* Used to set the batch buffer of each thread. */ -void > cl_set_thread_batch_buf(cl_command_queue queue, void* buf); > - > -/* Used to get the batch buffer of each thread. */ > -void* cl_get_thread_batch_buf(cl_command_queue queue); > - > -/* take current gpgpu from the thread gpgpu pool. */ -cl_gpgpu > cl_thread_gpgpu_take(cl_command_queue queue); > - > -cl_event get_current_event(cl_command_queue queue); -cl_event > get_last_event(cl_command_queue queue); -void > set_current_event(cl_command_queue queue, cl_event e); -void > set_last_event(cl_command_queue queue, cl_event e); > - > -#endif /* __CL_THREAD_H__ */ > -- > 2.7.4 > >
_______________________________________________ Beignet mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/beignet
