void pocl_init_mem_manager (void)
{
static unsigned int init_done = 0;
static pocl_lock_t pocl_init_lock = POCL_LOCK_INITIALIZER;
POCL_LOCK(pocl_init_lock);
if (!mm)
{
mm = calloc (1, sizeof (pocl_mem_manager));
POCL_INIT_LOCK (mm->event_lock);
POCL_INIT_LOCK (mm->cmd_lock);
}
POCL_UNLOCK(pocl_init_lock);
}
void
pocl_basic_init (cl_device_id device, const char* parameters)
{
struct data *d;
static int first_basic_init = 1;
static int device_number = 0;
if (first_basic_init)
{
pocl_init_dlhandle_cache();
first_basic_init = 0;
}
device->global_mem_id = 0;
d = (struct data *) calloc (1, sizeof (struct data));
d->current_kernel = NULL;
d->current_dlhandle = 0;
device->data = d;
/* hwloc probes OpenCL device info at its initialization in case
the OpenCL extension is enabled. This causes to printout
an unimplemented property error because hwloc is used to
initialize global_mem_size which it is not yet. Just put
a nonzero there for now. */
device->global_mem_size = 1;
pocl_topology_detect_device_info(device);
POCL_INIT_LOCK (d->cq_lock);
pocl_cpuinfo_detect_device_info(device);
pocl_set_buffer_image_limits(device);
/* in case hwloc doesn't provide a PCI ID, let's generate
a vendor id that hopefully is unique across vendors. */
const char *magic = "pocl";
if (device->vendor_id == 0)
device->vendor_id =
magic[0] | magic[1] << 8 | magic[2] << 16 | magic[3] << 24;
device->vendor_id += device_number;
device_number++;
/* The basic driver represents only one "compute unit" as
it doesn't exploit multiple hardware threads. Multiple
basic devices can be still used for task level parallelism
using multiple OpenCL devices. */
device->max_compute_units = 1;
if(device->llvm_cpu && (!strcmp(device->llvm_cpu, "(unknown)")))
device->llvm_cpu = NULL;
// work-around LLVM bug where sizeof(long)=4
#ifdef _CL_DISABLE_LONG
device->has_64bit_long=0;
#endif
}
void pocl_init_queue_list()
{
POCL_INIT_LOCK(queue_lock);
POCL_LOCK(queue_lock);
// will probably never need a realloc, but still
queue_alloc = QUEUE_ALLOC_SIZE;
queue_list = calloc(queue_alloc, sizeof(cl_command_queue));
if (!queue_list)
POCL_ABORT("unable to allocate queue list!");
//atexit(pocl_finish_all_queues);
POCL_UNLOCK(queue_lock);
}
cl_event pocl_mem_manager_new_event ()
{
cl_event ev = NULL;
POCL_LOCK (mm->event_lock);
if (ev = mm->event_list)
{
LL_DELETE (mm->event_list, ev);
POCL_UNLOCK (mm->event_lock);
POCL_INIT_LOCK (ev->pocl_lock);
ev->pocl_refcount = 1; /* no need to lock because event is not in use */
return ev;
}
POCL_UNLOCK (mm->event_lock);
ev = calloc (1, sizeof (struct _cl_event));
POCL_INIT_OBJECT(ev);
ev->pocl_refcount = 1;
return ev;
}
void
pocl_init_devices()
{
static unsigned int init_done = 0;
static pocl_lock_t pocl_init_lock = POCL_LOCK_INITIALIZER;
int i, j, dev_index;
char env_name[1024];
char dev_name[MAX_DEV_NAME_LEN] = {0};
unsigned int device_count[POCL_NUM_DEVICE_TYPES];
if (init_done == 0)
POCL_INIT_LOCK(pocl_init_lock);
POCL_LOCK(pocl_init_lock);
if (init_done)
{
POCL_UNLOCK(pocl_init_lock);
return;
}
/* Set a global debug flag, so we don't have to call pocl_get_bool_option
* everytime we use the debug macros */
#ifdef POCL_DEBUG_MESSAGES
pocl_debug_messages = pocl_get_bool_option("POCL_DEBUG", 0);
#endif
/* Init operations */
for (i = 0; i < POCL_NUM_DEVICE_TYPES; ++i)
{
pocl_devices_init_ops[i](&pocl_device_ops[i]);
assert(pocl_device_ops[i].device_name != NULL);
/* Probe and add the result to the number of probbed devices */
assert(pocl_device_ops[i].probe);
device_count[i] = pocl_device_ops[i].probe(&pocl_device_ops[i]);
pocl_num_devices += device_count[i];
}
assert(pocl_num_devices > 0);
pocl_devices = calloc(pocl_num_devices, sizeof(struct _cl_device_id));
if (pocl_devices == NULL)
POCL_ABORT("Can not allocate memory for devices\n");
dev_index = 0;
/* Init infos for each probbed devices */
for (i = 0; i < POCL_NUM_DEVICE_TYPES; ++i)
{
assert(pocl_device_ops[i].init);
for (j = 0; j < device_count[i]; ++j)
{
pocl_devices[dev_index].ops = &pocl_device_ops[i];
/* The default value for the global memory space identifier is
the same as the device id. The device instance can then override
it to point to some other device's global memory id in case of
a shared global memory. */
pocl_devices[dev_index].global_mem_id = dev_index;
pocl_device_ops[i].init_device_infos(&pocl_devices[dev_index]);
pocl_device_common_init(&pocl_devices[dev_index]);
str_toupper(dev_name, pocl_device_ops[i].device_name);
/* Check if there are device-specific parameters set in the
POCL_DEVICEn_PARAMETERS env. */
if (snprintf (env_name, 1024, "POCL_%s%d_PARAMETERS", dev_name, j) < 0)
POCL_ABORT("Unable to generate the env string.");
pocl_devices[dev_index].ops->init(&pocl_devices[dev_index], getenv(env_name));
if (dev_index == 0)
pocl_devices[dev_index].type |= CL_DEVICE_TYPE_DEFAULT;
++dev_index;
}
}
init_done = 1;
POCL_UNLOCK(pocl_init_lock);
}
void
pocl_init_devices()
{
static unsigned int init_done = 0;
static unsigned int init_in_progress = 0;
static pocl_lock_t pocl_init_lock = POCL_LOCK_INITIALIZER;
unsigned i, j, dev_index;
char env_name[1024];
char dev_name[MAX_DEV_NAME_LEN] = {0};
unsigned int device_count[POCL_NUM_DEVICE_TYPES];
/* This is a workaround to a nasty problem with libhwloc: When
initializing basic, it calls libhwloc to query device info.
In case libhwloc has the OpenCL plugin installed, it initializes
it and it leads to initializing pocl again which leads to an
infinite loop. */
if (init_in_progress)
return;
init_in_progress = 1;
if (init_done == 0)
POCL_INIT_LOCK(pocl_init_lock);
POCL_LOCK(pocl_init_lock);
if (init_done)
{
POCL_UNLOCK(pocl_init_lock);
return;
}
/* Set a global debug flag, so we don't have to call pocl_get_bool_option
* everytime we use the debug macros */
#ifdef POCL_DEBUG_MESSAGES
pocl_debug_messages = pocl_get_bool_option("POCL_DEBUG", 0);
#endif
pocl_cache_init_topdir();
pocl_init_queue_list();
/* Init operations */
for (i = 0; i < POCL_NUM_DEVICE_TYPES; ++i)
{
pocl_devices_init_ops[i](&pocl_device_ops[i]);
assert(pocl_device_ops[i].device_name != NULL);
/* Probe and add the result to the number of probbed devices */
assert(pocl_device_ops[i].probe);
device_count[i] = pocl_device_ops[i].probe(&pocl_device_ops[i]);
pocl_num_devices += device_count[i];
}
assert(pocl_num_devices > 0);
pocl_devices = (struct _cl_device_id*) calloc(pocl_num_devices, sizeof(struct _cl_device_id));
if (pocl_devices == NULL)
POCL_ABORT("Can not allocate memory for devices\n");
dev_index = 0;
/* Init infos for each probed devices */
for (i = 0; i < POCL_NUM_DEVICE_TYPES; ++i)
{
assert(pocl_device_ops[i].init);
for (j = 0; j < device_count[i]; ++j)
{
pocl_devices[dev_index].ops = &pocl_device_ops[i];
pocl_devices[dev_index].dev_id = dev_index;
/* The default value for the global memory space identifier is
the same as the device id. The device instance can then override
it to point to some other device's global memory id in case of
a shared global memory. */
pocl_devices[dev_index].global_mem_id = dev_index;
pocl_device_ops[i].init_device_infos(&pocl_devices[dev_index]);
pocl_device_common_init(&pocl_devices[dev_index]);
str_toupper(dev_name, pocl_device_ops[i].device_name);
/* Check if there are device-specific parameters set in the
POCL_DEVICEn_PARAMETERS env. */
if (snprintf (env_name, 1024, "POCL_%s%d_PARAMETERS", dev_name, j) < 0)
POCL_ABORT("Unable to generate the env string.");
pocl_devices[dev_index].ops->init(&pocl_devices[dev_index], getenv(env_name));
if (dev_index == 0)
pocl_devices[dev_index].type |= CL_DEVICE_TYPE_DEFAULT;
pocl_devices[dev_index].cache_dir_name = strdup(pocl_devices[dev_index].long_name);
pocl_string_to_dirname(pocl_devices[dev_index].cache_dir_name);
++dev_index;
}
}
init_done = 1;
POCL_UNLOCK(pocl_init_lock);
}
