int main_init(int argc, char *argv[])
{
printf("Version : %s-%s\n", GIT_TAG, GIT_REV);
printf("GL Vendor : %s\n", glGetString(GL_VENDOR) );
printf("GL Renderer: %s\n", glGetString(GL_RENDERER) );
printf("GL Version : %s\n", glGetString(GL_VERSION) );
printf("SL Version : %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION) );
int glver[2];
glGetIntegerv(GL_MAJOR_VERSION, &glver[0]);
glGetIntegerv(GL_MINOR_VERSION, &glver[1]);
printf("GL3 Version: %d.%d\n", glver[0], glver[1]);
#ifndef __APPLE__
if(!GLEW_VERSION_4_3)
{
printf("Fatal: OpenGL 4.3 Required.\n");
return 1;
}
gpuinfo_init();
#endif
ocl_init();
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 50.0 };
GLfloat light_position[] = { -100.0, -100.0, -100.0, 0.0 };
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
time_start = sys_time();
http_init();
// voxel_init();
return gui_init(argc, argv);
}
int main(int argc, char ** argv) {
size_t i, e;
size_t global_offset = 0;
size_t global_size = ELEMENTS;
size_t local_size;
size_t work_group_elements;
size_t single_elements;
float * h0_array = (float *)malloc(ELEMENTS*sizeof(float));
float * h1_array = (float *)malloc(ELEMENTS*sizeof(float));
float * h2_array = (float *)malloc(ELEMENTS*sizeof(float));
float * h3_array = (float *)malloc(ELEMENTS*sizeof(float));
cl_mem d0_array;
cl_mem d1_array;
cl_mem d2_array;
cl_mem d3_array;
ocl_event_t event;
ocl_event_wait_list_t wait_list;
ocl_kernel_hints_t hints;
ocl_init();
ocl_add_program(OCL_DEFAULT_DEVICE, "program", kernel, NULL);
ocl_add_kernel(OCL_DEFAULT_DEVICE, "program", "test", "test");
ocl_create_buffer_raw(OCL_DEFAULT_DEVICE, ELEMENTS*sizeof(float),
CL_MEM_READ_ONLY, NULL, &d0_array);
ocl_create_buffer_raw(OCL_DEFAULT_DEVICE, ELEMENTS*sizeof(float),
CL_MEM_READ_ONLY, NULL, &d1_array);
ocl_create_buffer_raw(OCL_DEFAULT_DEVICE, ELEMENTS*sizeof(float),
CL_MEM_READ_ONLY, NULL, &d2_array);
ocl_create_buffer_raw(OCL_DEFAULT_DEVICE, ELEMENTS*sizeof(float),
CL_MEM_READ_ONLY, NULL, &d3_array);
ocl_set_kernel_arg("program", "test", 0, sizeof(cl_mem), &d0_array);
ocl_set_kernel_arg("program", "test", 1, sizeof(cl_mem), &d1_array);
ocl_set_kernel_arg("program", "test", 2, sizeof(cl_mem), &d2_array);
ocl_set_kernel_arg("program", "test", 3, sizeof(cl_mem), &d3_array);
ocl_kernel_hints(OCL_DEFAULT_DEVICE, "program", "test", &hints);
ocl_ndrange_hints(global_size, hints.max_work_group_size, 0.5, 0.5,
&local_size, &work_group_elements, &single_elements);
for(i=0; i<ITERATIONS; ++i) {
if(i%OUTPUT == 0) {
printf("iteration: %d allocations: %d\n",
(int)i, (int)num_allocations());
} // if
// initialize data
for(e=0; e<ELEMENTS; ++e) {
h0_array[e] = 0.0;
h1_array[e] = 0.0;
h2_array[e] = 0.0;
h3_array[e] = 0.0;
} // for
ocl_initialize_event(&event);
ocl_initialize_event_wait_list(&wait_list, NULL, 0);
// write
ocl_enqueue_write_buffer_raw(OCL_DEFAULT_DEVICE, d0_array,
0, 0, ELEMENTS*sizeof(float), h0_array, &event);
ocl_add_event_to_wait_list(&wait_list, &event);
ocl_enqueue_write_buffer_raw(OCL_DEFAULT_DEVICE, d1_array,
0, 0, ELEMENTS*sizeof(float), h1_array, &event);
ocl_add_event_to_wait_list(&wait_list, &event);
ocl_enqueue_write_buffer_raw(OCL_DEFAULT_DEVICE, d2_array,
0, 0, ELEMENTS*sizeof(float), h2_array, &event);
ocl_add_event_to_wait_list(&wait_list, &event);
ocl_enqueue_write_buffer_raw(OCL_DEFAULT_DEVICE, d3_array,
0, 0, ELEMENTS*sizeof(float), h3_array, &event);
ocl_add_event_to_wait_list(&wait_list, &event);
ocl_wait_for_events(&wait_list);
ocl_clear_event_wait_list(&wait_list);
// kernel
ocl_enqueue_kernel_ndrange(OCL_DEFAULT_DEVICE, "program",
"test", 1, &global_offset, &global_size, &local_size, &event);
ocl_finish(OCL_DEFAULT_DEVICE);
// read
ocl_enqueue_read_buffer_raw(OCL_DEFAULT_DEVICE, d0_array,
0, 0, ELEMENTS*sizeof(float), h0_array, &event);
ocl_add_event_to_wait_list(&wait_list, &event);
ocl_enqueue_read_buffer_raw(OCL_DEFAULT_DEVICE, d1_array,
0, 0, ELEMENTS*sizeof(float), h1_array, &event);
ocl_add_event_to_wait_list(&wait_list, &event);
ocl_enqueue_read_buffer_raw(OCL_DEFAULT_DEVICE, d2_array,
0, 0, ELEMENTS*sizeof(float), h2_array, &event);
ocl_add_event_to_wait_list(&wait_list, &event);
ocl_enqueue_read_buffer_raw(OCL_DEFAULT_DEVICE, d3_array,
0, 0, ELEMENTS*sizeof(float), h3_array, &event);
ocl_add_event_to_wait_list(&wait_list, &event);
ocl_wait_for_events(&wait_list);
ocl_clear_event_wait_list(&wait_list);
for(e=0; e<ELEMENTS; ++e) {
if(h0_array[e] != (float)e ||
h1_array[e] != (float)(e*2) ||
h2_array[e] != (float)(e*3) ||
h3_array[e] != (float)(e*4)) {
fprintf(stderr, "Bad value!");
exit(1);
} // if
} // for
} // for
ocl_finalize();
free(h0_array);
free(h1_array);
free(h2_array);
free(h3_array);
return 0;
} // main
int main(int argc, char ** argv) {
/*-------------------------------------------------------------------------*
* Variables
*-------------------------------------------------------------------------*/
size_t i;
size_t global_offset = 0;
size_t global_size = 1;
size_t local_size = 1;
float * h_array = (float *)malloc(ELEMENTS*sizeof(float));
/*-------------------------------------------------------------------------*
* OpenCL memory objects
*-------------------------------------------------------------------------*/
cl_mem d_elements;
cl_mem d_array;
cl_mem d_acc;
ocl_event_t event;
/*-------------------------------------------------------------------------*
* Initialize host data
*-------------------------------------------------------------------------*/
for(i=0; i<ELEMENTS; ++i) {
h_array[i] = 1.0;
} // for
/*-------------------------------------------------------------------------*
* Initialize the OpenCL layer
*-------------------------------------------------------------------------*/
ocl_init();
/*-------------------------------------------------------------------------*
* Assemble program source
*-------------------------------------------------------------------------*/
char * performance_source = NULL;
ocl_add_from_file("T_U.cl", &performance_source, 0);
ocl_add_from_file("T_RS.cl", &performance_source, 0);
/*-------------------------------------------------------------------------*
* Add programs and compile
*-------------------------------------------------------------------------*/
ocl_add_program(OCL_DEFAULT_DEVICE, "program",
performance_source, NULL);
/*-------------------------------------------------------------------------*
* Add kernels
*-------------------------------------------------------------------------*/
ocl_add_kernel(OCL_DEFAULT_DEVICE, "program", "reduce_serial", "reduce");
/*-------------------------------------------------------------------------*
* Create device data
*-------------------------------------------------------------------------*/
// create device-side array
ocl_create_buffer_raw(OCL_DEFAULT_DEVICE, ELEMENTS*sizeof(float),
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, h_array, &d_array);
// create device-side element count
int elements = ELEMENTS;
ocl_create_buffer_raw(OCL_DEFAULT_DEVICE, sizeof(int),
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, &elements, &d_elements);
// create device-side accumulation
float acc = 0.0;
ocl_create_buffer_raw(OCL_DEFAULT_DEVICE, sizeof(float),
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, &acc, &d_acc);
/*-------------------------------------------------------------------------*
* Set kernel arguments
*-------------------------------------------------------------------------*/
ocl_set_kernel_arg("program", "reduce", 0, sizeof(cl_mem), &d_elements);
ocl_set_kernel_arg("program", "reduce", 1, sizeof(cl_mem), &d_array);
ocl_set_kernel_arg("program", "reduce", 2, sizeof(cl_mem), &d_acc);
/*-------------------------------------------------------------------------*
* Execute main reduction
*-------------------------------------------------------------------------*/
// initialize event for timings
ocl_initialize_event(&event);
/*-------------------------------------------------------------------------*
* Execute the serial reduction
*-------------------------------------------------------------------------*/
ocl_enqueue_kernel_ndrange(OCL_DEFAULT_DEVICE, "program", "reduce",
1, &global_offset, &global_size, &local_size, &event);
// block for execution completion
ocl_finish(OCL_DEFAULT_DEVICE);
/*-------------------------------------------------------------------------*
* Read accumulation from the device
*-------------------------------------------------------------------------*/
ocl_enqueue_read_buffer_raw(OCL_DEFAULT_DEVICE, d_acc, 1, global_offset,
sizeof(float), &acc, &event);
// block for read completion
ocl_finish(OCL_DEFAULT_DEVICE);
/*-------------------------------------------------------------------------*
* Print the results
*-------------------------------------------------------------------------*/
printf("acc: %f\n\n", acc);
/*-------------------------------------------------------------------------*
* Cleanup
*-------------------------------------------------------------------------*/
free(performance_source);
free(h_array);
/*-------------------------------------------------------------------------*
* Shutdown the OpenCL layer
*-------------------------------------------------------------------------*/
ocl_finalize();
return 0;
} // main
