示例#1
0
// get .cl root path
char*
HGPU_io_path_get_root(void){
    HGPU_io_path_get(&HGPU_io_path_current);
    HGPU_io_path_get(&HGPU_io_path_root);
    char* j_prev = HGPU_io_path_root;
    char* j_cur  = HGPU_io_path_root;
    bool flag_found = false;
    while((!flag_found)&&(j_cur)){
        sprintf_s(HGPU_io_path_root,HGPU_FILENAME_MAX,"%s%s",HGPU_io_path_current, HGPU_PATH_SEPARATOR_LINUX);
        j_cur = strstr(j_prev+1, HGPU_PATH_SEPARATOR_LINUX);
        if((j_cur) && (j_cur>j_prev)) {
            j_prev=j_cur;
            sprintf_s(j_cur+1,HGPU_FILENAME_MAX-(j_cur+1-HGPU_io_path_root),"%s",HGPU_GPU_ROOT_FILE);

            if (HGPU_io_file_check_existence(HGPU_io_path_root)) {
                sprintf_s(j_cur,HGPU_FILENAME_MAX-(j_cur+1-HGPU_io_path_root),"%s", HGPU_PATH_SEPARATOR_LINUX);
                flag_found = true;
            }
        }
    }
    if (!flag_found) {
        HGPU_io_path_root[0] = 0;
        HGPU_error_message(HGPU_ERROR_PATH_NOT_FOUND_ROOT,"could not determine OpenCL kernels root path (file hgpucl.txt not found)");
    }
    return HGPU_io_path_root;
}
示例#2
0
// get path
void
HGPU_io_path_get(char** path){
    if (!path) HGPU_error(HGPU_ERROR_ARRAY_OUT_OF_BOUND);
    size_t path_length = HGPU_FILENAME_MAX;
    char* path_new = *path;
    if (!path_new) HGPU_string_resize(&path_new,path_length);
    if (!GetCurrentDir(path_new,(int) path_length)) HGPU_error_message(HGPU_ERROR_DEVICE_INITIALIZATION_FAILED,"could not obtain inf path");
    HGPU_io_path_set_separator(&path_new,path_length);
    *path = path_new;
}
示例#3
0
// write buffer into binary file
void
HGPU_io_file_write_binary(const char* file_name,const unsigned char* buffer,const size_t bytes_to_write){
    FILE* file_for_write;
    fopen_s(&file_for_write,file_name,"wb");
    if(file_for_write){
        fwrite(buffer,sizeof(unsigned char),bytes_to_write,file_for_write);
        if (fclose(file_for_write)) HGPU_error_note(HGPU_ERROR_FILE_NOT_CLOSED,"the file was not closed");
    } else
        HGPU_error_message(HGPU_ERROR_FILE_NOT_FOUND,"error writting binary file");
}
示例#4
0
static void
HGPU_PRNG_RANMAR_init_GPU(HGPU_GPU_context* context,void* PRNG_state,HGPU_PRNG_parameters* PRNG_parameters){
    HGPU_PRNG_RANMAR_state_t* state = (HGPU_PRNG_RANMAR_state_t*) PRNG_state;

    size_t seeds_size              = HGPU_GPU_context_buffer_size_align(context,PRNG_parameters->instances * 2);
    size_t seed_table_size         = HGPU_GPU_context_buffer_size_align(context,PRNG_parameters->instances * 2 * (97+1)); // 97 - size of seed table, 1 - size of indices
    size_t randoms_size            = HGPU_GPU_context_buffer_size_align(context,PRNG_parameters->instances * PRNG_parameters->samples);
    cl_uint4*  PRNG_seeds           = (cl_uint4*)  calloc(seeds_size,sizeof(cl_uint4));
    cl_float4* PRNG_seed_table_float4= (cl_float4*) calloc(seed_table_size,sizeof(cl_float4));
    cl_float4*  PRNG_randoms        = NULL;
    cl_double4* PRNG_randoms_double = NULL;
    if (PRNG_parameters->precision==HGPU_precision_double)
        PRNG_randoms_double = (cl_double4*) calloc(randoms_size,sizeof(cl_double4));
    else
        PRNG_randoms        = (cl_float4*)  calloc(randoms_size,sizeof(cl_float4));
    if ((!PRNG_seeds) || (!PRNG_seed_table_float4) || ((!PRNG_randoms_double) && (!PRNG_randoms)))
        HGPU_error_message(HGPU_ERROR_NO_MEMORY,"could not allocate memory for randoms");

    for (unsigned int i=0; i<(seeds_size>>1); i++) {
        PRNG_seeds[i].s[0] = HGPU_PRNG_rand32bit() % HGPU_PRNG_RANMAR_init_1;
        PRNG_seeds[i].s[1] = HGPU_PRNG_rand32bit() % HGPU_PRNG_RANMAR_init_1;
        PRNG_seeds[i].s[2] = HGPU_PRNG_rand32bit() % HGPU_PRNG_RANMAR_init_1;
        PRNG_seeds[i].s[3] = HGPU_PRNG_rand32bit() % HGPU_PRNG_RANMAR_init_1;
    }

    for (unsigned int i=(seeds_size>>1); i<seeds_size; i++) {
        PRNG_seeds[i].s[0] = HGPU_PRNG_rand32bit() % HGPU_PRNG_RANMAR_init_2;
        PRNG_seeds[i].s[1] = HGPU_PRNG_rand32bit() % HGPU_PRNG_RANMAR_init_2;
        PRNG_seeds[i].s[2] = HGPU_PRNG_rand32bit() % HGPU_PRNG_RANMAR_init_2;
        PRNG_seeds[i].s[3] = HGPU_PRNG_rand32bit() % HGPU_PRNG_RANMAR_init_2;
    }

    PRNG_seeds[0].s[0] = state->seed1; // setup first thread as CPU
    PRNG_seeds[PRNG_parameters->instances].s[0] = state->seed2; // setup first thread as CPU

    unsigned int seeds_id      = 0;
    unsigned int seed_table_id = 0;
    unsigned int randoms_id    = 0;

    seeds_id = HGPU_GPU_context_buffer_init(context,PRNG_seeds,HGPU_GPU_buffer_type_io,seeds_size,sizeof(cl_uint4));
    HGPU_GPU_context_buffer_set_name(context,seeds_id,(char*) "(RANMAR) PRNG_input_seeds");

    seed_table_id = HGPU_GPU_context_buffer_init(context,PRNG_seed_table_float4,HGPU_GPU_buffer_type_io,seed_table_size,sizeof(cl_float4));
    HGPU_GPU_context_buffer_set_name(context,seed_table_id,(char*) "(RANMAR) PRNG_seed_table");

    if (PRNG_parameters->precision==HGPU_precision_double)
        randoms_id = HGPU_GPU_context_buffer_init(context,PRNG_randoms_double,HGPU_GPU_buffer_type_io,randoms_size,sizeof(cl_double4));
    else
        randoms_id = HGPU_GPU_context_buffer_init(context,PRNG_randoms,HGPU_GPU_buffer_type_io,randoms_size,sizeof(cl_float4));
    HGPU_GPU_context_buffer_set_name(context,randoms_id,(char*) "(RANMAR) PRNG_randoms");

    PRNG_parameters->id_buffer_input_seeds = seeds_id;
    PRNG_parameters->id_buffer_seeds       = seed_table_id;
    PRNG_parameters->id_buffer_randoms     = randoms_id;
}
示例#5
0
// write buffer into file with path
void
HGPU_io_file_write_with_path(const char* file_path,const char* file_name,const char* buffer){
    char* filename_with_path = (char*) calloc(HGPU_FILENAME_MAX,sizeof(char));
    if (!filename_with_path) HGPU_error(HGPU_ERROR_NO_MEMORY);
    HGPU_io_path_join_filename(&filename_with_path,HGPU_FILENAME_MAX,file_path,file_name);
    FILE* file_for_write;
    fopen_s(&file_for_write,filename_with_path,"w+");
    free(filename_with_path);
    if(file_for_write){
        fprintf(file_for_write,buffer);
        if (fclose(file_for_write)) HGPU_error_note(HGPU_ERROR_FILE_NOT_CLOSED,"the file was not closed");
    } else
        HGPU_error_message(HGPU_ERROR_FILE_NOT_FOUND,"error writting file");
}
示例#6
0
// read file into buffer
char*
HGPU_io_file_read(const char* file_name){	
    FILE* file_to_read;
    char buffer[HGPU_FILENAME_MAX];
    sprintf_s(buffer,sizeof(buffer),"%s",file_name);
    fopen_s(&file_to_read,buffer,"r");
    if(!file_to_read){
        HGPU_error_message(HGPU_ERROR_FILE_NOT_FOUND,".cl-file not found");
        return NULL;
    }
    fseek (file_to_read, 0, SEEK_END);
    unsigned int file_length = ftell(file_to_read);
    fseek (file_to_read, 0 , SEEK_SET);
    char* cl_kernels_source = (char*) calloc(file_length + 2, sizeof(char));
    if (!cl_kernels_source) HGPU_error(HGPU_ERROR_NO_MEMORY);
    unsigned int file_read_length = (unsigned int) fread(cl_kernels_source, sizeof(char), file_length, file_to_read);
    if (!file_read_length) free(cl_kernels_source);
    if (fclose(file_to_read)) HGPU_error_note(HGPU_ERROR_FILE_NOT_CLOSED,"the file was not closed");
    return cl_kernels_source;
}
示例#7
0
static void
HGPU_PRNG_CONSTANT_init_GPU(HGPU_GPU_context* context,void*,HGPU_PRNG_parameters* PRNG_parameters){
    size_t randoms_size             = HGPU_GPU_context_buffer_size_align(context,PRNG_parameters->instances * PRNG_parameters->samples);
    cl_float4*  PRNG_randoms        = NULL;
    cl_double4* PRNG_randoms_double = NULL;
    if (PRNG_parameters->precision==HGPU_precision_double)
        PRNG_randoms_double = (cl_double4*) calloc(randoms_size,sizeof(cl_double4));
    else
        PRNG_randoms        = (cl_float4*)  calloc(randoms_size,sizeof(cl_float4));
    if ((!PRNG_randoms_double) && (!PRNG_randoms))
        HGPU_error_message(HGPU_ERROR_NO_MEMORY,"could not allocate memory for randoms");

    unsigned int randoms_id = 0;

    if (PRNG_parameters->precision==HGPU_precision_double)
        randoms_id = HGPU_GPU_context_buffer_init(context,PRNG_randoms_double,HGPU_GPU_buffer_type_io,randoms_size,sizeof(cl_double4));
    else
        randoms_id = HGPU_GPU_context_buffer_init(context,PRNG_randoms,HGPU_GPU_buffer_type_io,randoms_size,sizeof(cl_float4));
    HGPU_GPU_context_buffer_set_name(context,randoms_id,(char*) "(CONSTANT) PRNG_randoms");

    PRNG_parameters->id_buffer_input_seeds = HGPU_GPU_MAX_BUFFERS;
    PRNG_parameters->id_buffer_seeds       = HGPU_GPU_MAX_BUFFERS;
    PRNG_parameters->id_buffer_randoms     = randoms_id;
}