void
pocl_check_and_invalidate_cache (cl_program program,
int device_i, const char* device_tmpdir)
{
int cache_dirty = 0;
char *content = NULL, *s_ptr, *ss_ptr;
int read = 0;
POCL_LOCK(cache_lock);
if (!pocl_get_bool_option("POCL_KERNEL_CACHE", POCL_BUILD_KERNEL_CACHE))
{
cache_dirty = 1;
goto bottom;
}
/* If program contains "#include", disable caching
Included headers might get modified, force recompilation in all the cases
Yes, this is a very dirty way to find "# include"
but we can live with this for now
*/
if (!pocl_get_bool_option("POCL_KERNEL_CACHE_IGNORE_INCLUDES", 0) &&
program->source)
{
for (s_ptr = program->source; (*s_ptr); s_ptr++)
{
if ((*s_ptr) == '#')
{
/* Skip all the white-spaces between # & include */
for (ss_ptr = s_ptr+1; *ss_ptr == ' '; ss_ptr++) ;
if (strncmp(ss_ptr, "include", 7) == 0)
cache_dirty = 1;
}
}
}
bottom:
if (cache_dirty)
{
pocl_remove_directory(device_tmpdir);
mkdir(device_tmpdir, S_IRWXU);
}
POCL_UNLOCK(cache_lock);
}
void pocl_cache_cleanup_cachedir(cl_program program) {
unsigned i;
if (!pocl_get_bool_option("POCL_KERNEL_CACHE", POCL_BUILD_KERNEL_CACHE)) {
for (i=0; i< program->num_devices; i++) {
if (program->build_hash[i][0] == 0)
continue;
void* lock = acquire_program_lock(program, i, 0);
if (!lock)
return;
char cachedir[POCL_FILENAME_LENGTH];
program_device_dir(cachedir, program, i, "");
pocl_rm_rf(cachedir);
release_lock(lock);
}
}
}
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);
}
/**
* Generate code from the final bitcode using the LLVM
* tools.
*
* Uses an existing (cached) one, if available.
*
* @param tmpdir The directory of the work-group function bitcode.
* @param return the generated binary filename.
*/
const char*
llvm_codegen (const char* tmpdir, cl_kernel kernel, cl_device_id device) {
const char* pocl_verbose_ptr =
pocl_get_string_option("POCL_VERBOSE", (char*)NULL);
int pocl_verbose = pocl_verbose_ptr && *pocl_verbose_ptr;
char command[COMMAND_LENGTH];
char bytecode[POCL_FILENAME_LENGTH];
char objfile[POCL_FILENAME_LENGTH];
char* module = (char*) malloc(min(POCL_FILENAME_LENGTH,
strlen(tmpdir) + strlen(kernel->function_name) + 5)); // strlen of / .so 4+1
int error;
cl_program program = kernel->program;
error = snprintf
(module, POCL_FILENAME_LENGTH,
"%s/%s.so", tmpdir, kernel->function_name);
assert (error >= 0);
error = snprintf
(objfile, POCL_FILENAME_LENGTH,
"%s/%s.so.o", tmpdir, kernel->function_name);
assert (error >= 0);
if (access (module, F_OK) != 0)
{
error = snprintf (bytecode, POCL_FILENAME_LENGTH,
"%s/%s", tmpdir, POCL_PARALLEL_BC_FILENAME);
assert (error >= 0);
error = pocl_llvm_codegen( kernel, device, bytecode, objfile);
assert (error == 0);
// clang is used as the linker driver in LINK_CMD
error = snprintf (command, COMMAND_LENGTH,
#ifndef ANDROID
LINK_CMD " " HOST_CLANG_FLAGS " " HOST_LD_FLAGS " -o %s %s",
#else
ANDROID_POCL_PREFIX"/bin/ld " HOST_LD_FLAGS " -o %s %s "
" /system/lib/crtend_so.o /system/lib/crtbegin_so.o -ldl -lc ",
#endif
module, objfile);
assert (error >= 0);
if (pocl_verbose) {
fprintf(stderr, "[pocl] executing [%s]\n", command);
fflush(stderr);
}
error = system (command);
assert (error == 0);
/* Save space in kernel cache */
if (!pocl_get_bool_option("POCL_LEAVE_KERNEL_COMPILER_TEMP_FILES", 0))
{
pocl_remove_file(objfile);
pocl_remove_file(bytecode);
}
}
return module;
}
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);
}
