func (this *kernel) EnqueueTask(queue CommandQueue,
event_wait_list []Event) (Event, error) {
var errCode cl.CL_int
var event_id cl.CL_event
numEvents := cl.CL_uint(len(event_wait_list))
events := make([]cl.CL_event, numEvents)
for i := cl.CL_uint(0); i < numEvents; i++ {
events[i] = event_wait_list[i].GetID()
}
if errCode = cl.CLEnqueueTask(queue.GetID(),
this.kernel_id,
numEvents,
events,
&event_id); errCode != cl.CL_SUCCESS {
return nil, fmt.Errorf("EnqueueTask failure with errcode_ret %d: %s", errCode, cl.ERROR_CODES_STRINGS[-errCode])
} else {
return &event{event_id}, nil
}
}
func TestQueue(t *testing.T) {
/* Host/device data structures */
var platform [1]cl.CL_platform_id
var device [1]cl.CL_device_id
var context cl.CL_context
var queue cl.CL_command_queue
var err cl.CL_int
/* Program/kernel data structures */
var program cl.CL_program
var program_buffer [1][]byte
var program_log interface{}
var program_size [1]cl.CL_size_t
var log_size cl.CL_size_t
var kernel cl.CL_kernel
/* Access the first installed platform */
err = cl.CLGetPlatformIDs(1, platform[:], nil)
if err < 0 {
t.Errorf("Couldn't find any platforms")
}
/* Access the first GPU/CPU */
err = cl.CLGetDeviceIDs(platform[0], cl.CL_DEVICE_TYPE_GPU, 1, device[:], nil)
if err == cl.CL_DEVICE_NOT_FOUND {
err = cl.CLGetDeviceIDs(platform[0], cl.CL_DEVICE_TYPE_CPU, 1, device[:], nil)
}
if err < 0 {
t.Errorf("Couldn't find any devices")
}
/* Create a context */
context = cl.CLCreateContext(nil, 1, device[:], nil, nil, &err)
if err < 0 {
t.Errorf("Couldn't create a context")
}
/* Read each program file and place content into buffer array */
program_handle, err1 := os.Open("blank.cl")
if err1 != nil {
t.Errorf("Couldn't find the program file")
}
defer program_handle.Close()
fi, err2 := program_handle.Stat()
if err2 != nil {
t.Errorf("Couldn't find the program stat")
}
program_size[0] = cl.CL_size_t(fi.Size())
program_buffer[0] = make([]byte, program_size[0])
read_size, err3 := program_handle.Read(program_buffer[0])
if err3 != nil || cl.CL_size_t(read_size) != program_size[0] {
t.Errorf("read file error or file size wrong")
}
/* Create program from file */
program = cl.CLCreateProgramWithSource(context, 1,
program_buffer[:], program_size[:], &err)
if err < 0 {
t.Errorf("Couldn't create the program")
}
/* Build program */
err = cl.CLBuildProgram(program, 1, device[:], nil, nil, nil)
if err < 0 {
/* Find size of log and print to std output */
cl.CLGetProgramBuildInfo(program, device[0], cl.CL_PROGRAM_BUILD_LOG,
0, nil, &log_size)
//program_log = (char*) malloc(log_size+1);
//program_log[log_size] = '\0';
cl.CLGetProgramBuildInfo(program, device[0], cl.CL_PROGRAM_BUILD_LOG,
log_size, &program_log, nil)
t.Errorf("%s\n", program_log)
//free(program_log);
}
/* Create the kernel */
kernel = cl.CLCreateKernel(program, []byte("blank"), &err)
if err < 0 {
t.Errorf("Couldn't create the kernel")
}
/* Create the command queue */
queue = cl.CLCreateCommandQueue(context, device[0], 0, &err)
if err < 0 {
t.Errorf("Couldn't create the command queue")
}
/* Enqueue the kernel execution command */
err = cl.CLEnqueueTask(queue, kernel, 0, nil, nil)
if err < 0 {
t.Errorf("Couldn't enqueue the kernel execution command")
} else {
t.Logf("Successfully queued kernel.\n")
}
/* Deallocate resources */
cl.CLReleaseCommandQueue(queue)
cl.CLReleaseKernel(kernel)
cl.CLReleaseProgram(program)
cl.CLReleaseContext(context)
}
func main() {
/* OpenCL data structures */
var device []cl.CL_device_id
var context cl.CL_context
var queue cl.CL_command_queue
var program *cl.CL_program
var kernel cl.CL_kernel
var err cl.CL_int
/* Data and buffers */
var select1 [4]float32
var select2 [2]cl.CL_uchar
var select1_buffer, select2_buffer cl.CL_mem
/* Create a context */
device = utils.Create_device()
context = cl.CLCreateContext(nil, 1, device[:], nil, nil, &err)
if err < 0 {
println("Couldn't create a context")
return
}
/* Create a kernel */
program = utils.Build_program(context, device[:], PROGRAM_FILE, nil)
kernel = cl.CLCreateKernel(*program, KERNEL_FUNC, &err)
if err < 0 {
println("Couldn't create a kernel")
return
}
/* Create a write-only buffer to hold the output data */
select1_buffer = cl.CLCreateBuffer(context, cl.CL_MEM_WRITE_ONLY,
cl.CL_size_t(unsafe.Sizeof(select1)), nil, &err)
if err < 0 {
println("Couldn't create a buffer")
return
}
select2_buffer = cl.CLCreateBuffer(context, cl.CL_MEM_WRITE_ONLY,
cl.CL_size_t(unsafe.Sizeof(select2)), nil, &err)
/* Create kernel argument */
err = cl.CLSetKernelArg(kernel, 0, cl.CL_size_t(unsafe.Sizeof(select1_buffer)), unsafe.Pointer(&select1_buffer))
if err < 0 {
println("Couldn't set a kernel argument")
return
}
cl.CLSetKernelArg(kernel, 1, cl.CL_size_t(unsafe.Sizeof(select2_buffer)), unsafe.Pointer(&select2_buffer))
/* Create a command queue */
queue = cl.CLCreateCommandQueue(context, device[0], 0, &err)
if err < 0 {
println("Couldn't create a command queue")
return
}
/* Enqueue kernel */
err = cl.CLEnqueueTask(queue, kernel, 0, nil, nil)
if err < 0 {
println("Couldn't enqueue the kernel")
return
}
/* Read and print the result */
err = cl.CLEnqueueReadBuffer(queue, select1_buffer, cl.CL_TRUE, 0,
cl.CL_size_t(unsafe.Sizeof(select1)), unsafe.Pointer(&select1), 0, nil, nil)
if err < 0 {
println("Couldn't read the buffer")
return
}
cl.CLEnqueueReadBuffer(queue, select2_buffer, cl.CL_TRUE, 0,
cl.CL_size_t(unsafe.Sizeof(select2)), unsafe.Pointer(&select2), 0, nil, nil)
fmt.Printf("select: ")
for i := 0; i < 3; i++ {
fmt.Printf("%.2f, ", select1[i])
}
fmt.Printf("%.2f\n", select1[3])
fmt.Printf("bitselect: %X, %X\n", select2[0], select2[1])
/* Deallocate resources */
cl.CLReleaseMemObject(select1_buffer)
cl.CLReleaseMemObject(select2_buffer)
cl.CLReleaseKernel(kernel)
cl.CLReleaseCommandQueue(queue)
cl.CLReleaseProgram(*program)
cl.CLReleaseContext(context)
}
func main() {
/* Host/device data structures */
var device []cl.CL_device_id
var context cl.CL_context
var queue cl.CL_command_queue
var program *cl.CL_program
var kernel cl.CL_kernel
var err cl.CL_int
/* Data and buffers */
var test [16]byte
var test_buffer cl.CL_mem
/* Create a context */
device = utils.Create_device()
context = cl.CLCreateContext(nil, 1, device[:], nil, nil, &err)
if err < 0 {
println("Couldn't create a context")
return
}
/* Build the program and create a kernel */
program = utils.Build_program(context, device[:], PROGRAM_FILE, nil)
kernel = cl.CLCreateKernel(*program, KERNEL_FUNC, &err)
if err < 0 {
println("Couldn't create a kernel")
return
}
/* Create a write-only buffer to hold the output data */
test_buffer = cl.CLCreateBuffer(context, cl.CL_MEM_WRITE_ONLY,
cl.CL_size_t(unsafe.Sizeof(test)), nil, &err)
if err < 0 {
println("Couldn't create a buffer")
return
}
/* Create kernel argument */
err = cl.CLSetKernelArg(kernel, 0, cl.CL_size_t(unsafe.Sizeof(test_buffer)), unsafe.Pointer(&test_buffer))
if err < 0 {
println("Couldn't set a kernel argument")
return
}
/* Create a command queue */
queue = cl.CLCreateCommandQueue(context, device[0], 0, &err)
if err < 0 {
println("Couldn't create a command queue")
return
}
/* Enqueue kernel */
err = cl.CLEnqueueTask(queue, kernel, 0, nil, nil)
if err < 0 {
println("Couldn't enqueue the kernel")
return
}
/* Read and print the result */
err = cl.CLEnqueueReadBuffer(queue, test_buffer, cl.CL_TRUE, 0,
cl.CL_size_t(unsafe.Sizeof(test)), unsafe.Pointer(&test), 0, nil, nil)
if err < 0 {
println("Couldn't read the buffer")
return
}
for i := 0; i < 15; i++ {
fmt.Printf("0x%X, ", test[i])
}
fmt.Printf("0x%X\n", test[15])
/* Deallocate resources */
cl.CLReleaseMemObject(test_buffer)
cl.CLReleaseKernel(kernel)
cl.CLReleaseCommandQueue(queue)
cl.CLReleaseProgram(*program)
cl.CLReleaseContext(context)
}
func main() {
/* OpenCL data structures */
var device []cl.CL_device_id
var context cl.CL_context
var queue cl.CL_command_queue
var program *cl.CL_program
var kernel cl.CL_kernel
var err cl.CL_int
/* Data and events */
var data []float32
var data_buffer cl.CL_mem
var user_event, kernel_event, read_event [1]cl.CL_event
/* Initialize data */
data = make([]float32, 4)
for i := 0; i < 4; i++ {
data[i] = float32(i) * 1.0
}
/* Create a device and context */
device = utils.Create_device()
context = cl.CLCreateContext(nil, 1, device[:], nil, nil, &err)
if err < 0 {
println("Couldn't create a context")
return
}
/* Build the program and create a kernel */
program = utils.Build_program(context, device[:], PROGRAM_FILE, nil)
kernel = cl.CLCreateKernel(*program, KERNEL_FUNC, &err)
if err < 0 {
println("Couldn't create a kernel")
return
}
/* Create a buffer to hold data */
data_buffer = cl.CLCreateBuffer(context,
cl.CL_MEM_READ_WRITE|cl.CL_MEM_COPY_HOST_PTR,
cl.CL_size_t(unsafe.Sizeof(data[0]))*4, unsafe.Pointer(&data[0]), &err)
if err < 0 {
println("Couldn't create a buffer")
return
}
/* Create kernel argument */
err = cl.CLSetKernelArg(kernel, 0, cl.CL_size_t(unsafe.Sizeof(data_buffer)), unsafe.Pointer(&data_buffer))
if err < 0 {
println("Couldn't set a kernel argument")
return
}
/* Create a command queue */
queue = cl.CLCreateCommandQueue(context, device[0],
cl.CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err)
if err < 0 {
println("Couldn't create a command queue")
return
}
/* Configure events */
user_event[0] = cl.CLCreateUserEvent(context, &err)
if err < 0 {
println("Couldn't enqueue the kernel")
return
}
/* Enqueue kernel */
err = cl.CLEnqueueTask(queue, kernel, 1, user_event[:], &kernel_event[0])
if err < 0 {
println("Couldn't enqueue the kernel")
return
}
/* Read the buffer */
err = cl.CLEnqueueReadBuffer(queue, data_buffer, cl.CL_FALSE, 0,
cl.CL_size_t(unsafe.Sizeof(data[0]))*4, unsafe.Pointer(&data[0]), 1, kernel_event[:], &read_event[0])
if err < 0 {
println("Couldn't read the buffer")
return
}
/* Set callback for event */
err = cl.CLSetEventCallback(read_event[0], cl.CL_COMPLETE,
read_complete, unsafe.Pointer(&data))
if err < 0 {
println("Couldn't set callback for event")
return
}
/* Sleep for a second to demonstrate the that commands haven't
started executing. Then prompt user */
time.Sleep(1)
fmt.Printf("Old data: %4.2f, %4.2f, %4.2f, %4.2f\n",
data[0], data[1], data[2], data[3])
fmt.Printf("Press ENTER to continue.\n")
//getchar();
reader := bufio.NewReader(os.Stdin)
reader.ReadString('\n')
/* Set user event to success */
cl.CLSetUserEventStatus(user_event[0], cl.CL_SUCCESS)
/* Deallocate resources */
cl.CLReleaseEvent(read_event[0])
cl.CLReleaseEvent(kernel_event[0])
cl.CLReleaseEvent(user_event[0])
cl.CLReleaseMemObject(data_buffer)
cl.CLReleaseKernel(kernel)
cl.CLReleaseCommandQueue(queue)
cl.CLReleaseProgram(*program)
cl.CLReleaseContext(context)
}
func main() {
/* OpenCL data structures */
var device []cl.CL_device_id
var context cl.CL_context
var queue cl.CL_command_queue
var program *cl.CL_program
var kernel cl.CL_kernel
var err cl.CL_int
/* Data and buffers */
var a float32 = 6.0
var b float32 = 2.0
var result float32
var a_buffer, b_buffer, output_buffer cl.CL_mem
/* Extension data */
var sizeofuint cl.CL_uint
var addr_data interface{}
var ext_data interface{}
fp64_ext := "cl_khr_fp64"
var ext_size cl.CL_size_t
var options []byte
/* Create a device and context */
device = utils.Create_device()
context = cl.CLCreateContext(nil, 1, device[:], nil, nil, &err)
if err < 0 {
println("Couldn't create a context")
return
}
/* Obtain the device data */
if cl.CLGetDeviceInfo(device[0], cl.CL_DEVICE_ADDRESS_BITS,
cl.CL_size_t(unsafe.Sizeof(sizeofuint)), &addr_data, nil) < 0 {
println("Couldn't read extension data")
return
}
fmt.Printf("Address width: %v\n", addr_data.(cl.CL_uint))
/* Define "FP_64" option if doubles are supported */
cl.CLGetDeviceInfo(device[0], cl.CL_DEVICE_EXTENSIONS,
0, nil, &ext_size)
// ext_data = (char*)malloc(ext_size + 1);
// ext_data[ext_size] = '\0';
cl.CLGetDeviceInfo(device[0], cl.CL_DEVICE_EXTENSIONS,
ext_size, &ext_data, nil)
if strings.Contains(ext_data.(string), fp64_ext) {
fmt.Printf("The %s extension is supported.\n", fp64_ext)
options = []byte("-DFP_64 ")
} else {
fmt.Printf("The %s extension is not supported. %s\n", fp64_ext, ext_data.(string))
}
/* Build the program and create the kernel */
program = utils.Build_program(context, device[:], PROGRAM_FILE, options)
kernel = cl.CLCreateKernel(*program, KERNEL_FUNC, &err)
if err < 0 {
println("Couldn't create a kernel")
return
}
/* Create CL buffers to hold input and output data */
a_buffer = cl.CLCreateBuffer(context, cl.CL_MEM_READ_ONLY|
cl.CL_MEM_COPY_HOST_PTR, cl.CL_size_t(unsafe.Sizeof(a)), unsafe.Pointer(&a), &err)
if err < 0 {
println("Couldn't create a memory object")
return
}
b_buffer = cl.CLCreateBuffer(context, cl.CL_MEM_READ_ONLY|
cl.CL_MEM_COPY_HOST_PTR, cl.CL_size_t(unsafe.Sizeof(b)), unsafe.Pointer(&b), nil)
output_buffer = cl.CLCreateBuffer(context, cl.CL_MEM_WRITE_ONLY,
cl.CL_size_t(unsafe.Sizeof(b)), nil, nil)
/* Create kernel arguments */
err = cl.CLSetKernelArg(kernel, 0, cl.CL_size_t(unsafe.Sizeof(a_buffer)), unsafe.Pointer(&a_buffer))
if err < 0 {
println("Couldn't set a kernel argument")
return
}
cl.CLSetKernelArg(kernel, 1, cl.CL_size_t(unsafe.Sizeof(b_buffer)), unsafe.Pointer(&b_buffer))
cl.CLSetKernelArg(kernel, 2, cl.CL_size_t(unsafe.Sizeof(output_buffer)), unsafe.Pointer(&output_buffer))
/* Create a command queue */
queue = cl.CLCreateCommandQueue(context, device[0], 0, &err)
if err < 0 {
println("Couldn't create a command queue")
return
}
/* Enqueue kernel */
err = cl.CLEnqueueTask(queue, kernel, 0, nil, nil)
if err < 0 {
println("Couldn't enqueue the kernel")
return
}
/* Read and print the result */
err = cl.CLEnqueueReadBuffer(queue, output_buffer, cl.CL_TRUE, 0,
cl.CL_size_t(unsafe.Sizeof(result)), unsafe.Pointer(&result), 0, nil, nil)
if err < 0 {
println("Couldn't read the output buffer")
return
}
fmt.Printf("The kernel result is %f\n", result)
/* Deallocate resources */
cl.CLReleaseMemObject(a_buffer)
cl.CLReleaseMemObject(b_buffer)
cl.CLReleaseMemObject(output_buffer)
cl.CLReleaseKernel(kernel)
cl.CLReleaseCommandQueue(queue)
cl.CLReleaseProgram(*program)
cl.CLReleaseContext(context)
}
func main() {
/* OpenCL data structures */
var device []cl.CL_device_id
var context cl.CL_context
var queue cl.CL_command_queue
var program *cl.CL_program
var kernel cl.CL_kernel
var err cl.CL_int
/* Data and buffers */
var data_one, data_two, result_array [100]float32
var buffer_one, buffer_two cl.CL_mem
var mapped_memory unsafe.Pointer
/* Initialize arrays */
for i := 0; i < 100; i++ {
data_one[i] = 1.0 * float32(i)
data_two[i] = -1.0 * float32(i)
result_array[i] = 0.0
}
/* Create a device and context */
device = utils.Create_device()
context = cl.CLCreateContext(nil, 1, device[:], nil, nil, &err)
if err < 0 {
println("Couldn't create a context")
return
}
/* Build the program and create the kernel */
program = utils.Build_program(context, device[:], PROGRAM_FILE, nil)
kernel = cl.CLCreateKernel(*program, []byte(KERNEL_FUNC), &err)
if err < 0 {
println("Couldn't create a kernel")
return
}
/* Create buffers */
buffer_one = cl.CLCreateBuffer(context, cl.CL_MEM_READ_WRITE|
cl.CL_MEM_COPY_HOST_PTR, cl.CL_size_t(unsafe.Sizeof(data_one)), unsafe.Pointer(&data_one[0]), &err)
if err < 0 {
println("Couldn't create buffer object 1")
return
}
buffer_two = cl.CLCreateBuffer(context, cl.CL_MEM_READ_WRITE|
cl.CL_MEM_COPY_HOST_PTR, cl.CL_size_t(unsafe.Sizeof(data_two)), unsafe.Pointer(&data_two), &err)
if err < 0 {
println("Couldn't create buffer object 2")
return
}
/* Set buffers as arguments to the kernel */
err = cl.CLSetKernelArg(kernel, 0, cl.CL_size_t(unsafe.Sizeof(buffer_one)), unsafe.Pointer(&buffer_one))
err |= cl.CLSetKernelArg(kernel, 1, cl.CL_size_t(unsafe.Sizeof(buffer_two)), unsafe.Pointer(&buffer_two))
if err < 0 {
println("Couldn't set the buffer as the kernel argument")
return
}
/* Create a command queue */
queue = cl.CLCreateCommandQueue(context, device[0], 0, &err)
if err < 0 {
println("Couldn't create a command queue")
return
}
/* Enqueue kernel */
err = cl.CLEnqueueTask(queue, kernel, 0, nil, nil)
if err < 0 {
println("Couldn't enqueue the kernel")
return
}
/* Enqueue command to copy buffer one to buffer two */
err = cl.CLEnqueueCopyBuffer(queue, buffer_one, buffer_two, 0, 0,
cl.CL_size_t(unsafe.Sizeof(data_one)), 0, nil, nil)
if err < 0 {
println("Couldn't perform the buffer copy")
return
}
/* Enqueue command to map buffer two to host memory */
mapped_memory = cl.CLEnqueueMapBuffer(queue, buffer_two, cl.CL_TRUE,
cl.CL_MAP_READ, 0, cl.CL_size_t(unsafe.Sizeof(data_two)), 0, nil, nil, &err)
if err < 0 {
println("Couldn't map the buffer to host memory")
return
}
/* Transfer memory and unmap the buffer */
C.memcpy(unsafe.Pointer(&result_array[0]), mapped_memory, C.size_t(unsafe.Sizeof(data_two)))
err = cl.CLEnqueueUnmapMemObject(queue, buffer_two, mapped_memory,
0, nil, nil)
if err < 0 {
println("Couldn't unmap the buffer")
return
}
/* Display updated buffer */
for i := 0; i < 10; i++ {
for j := 0; j < 10; j++ {
fmt.Printf("%6.1f", result_array[j+i*10])
}
fmt.Printf("\n")
}
/* Deallocate resources */
cl.CLReleaseMemObject(buffer_one)
cl.CLReleaseMemObject(buffer_two)
cl.CLReleaseKernel(kernel)
cl.CLReleaseCommandQueue(queue)
cl.CLReleaseProgram(*program)
cl.CLReleaseContext(context)
}
func main() {
/* OpenCL data structures */
var device []cl.CL_device_id
var context cl.CL_context
var queue cl.CL_command_queue
var program *cl.CL_program
var kernel cl.CL_kernel
var err cl.CL_int
/* Data and buffers */
var full_matrix, zero_matrix [80]float32
var sizeoffloat32 = cl.CL_size_t(unsafe.Sizeof(full_matrix[0]))
var buffer_origin = [3]cl.CL_size_t{5 * sizeoffloat32, 3, 0}
var host_origin = [3]cl.CL_size_t{1 * sizeoffloat32, 1, 0}
var region = [3]cl.CL_size_t{4 * sizeoffloat32, 4, 1}
var matrix_buffer cl.CL_mem
/* Initialize data */
for i := 0; i < 80; i++ {
full_matrix[i] = float32(i) * 1.0
zero_matrix[i] = 0.0
}
/* Create a device and context */
device = utils.Create_device()
context = cl.CLCreateContext(nil, 1, device[:], nil, nil, &err)
if err < 0 {
println("Couldn't create a context")
return
}
/* Build the program and create the kernel */
program = utils.Build_program(context, device[:], PROGRAM_FILE, nil)
if program == nil {
println("Couldn't build program")
return
}
kernel = cl.CLCreateKernel(*program, []byte(KERNEL_FUNC), &err)
if err < 0 {
println("Couldn't create a kernel")
return
}
/* Create a buffer to hold 80 floats */
matrix_buffer = cl.CLCreateBuffer(context, cl.CL_MEM_READ_WRITE|
cl.CL_MEM_COPY_HOST_PTR, cl.CL_size_t(unsafe.Sizeof(full_matrix)), unsafe.Pointer(&full_matrix[0]), &err)
if err < 0 {
println("Couldn't create a buffer object")
return
}
/* Set buffer as argument to the kernel */
err = cl.CLSetKernelArg(kernel, 0, cl.CL_size_t(unsafe.Sizeof(matrix_buffer)), unsafe.Pointer(&matrix_buffer))
if err < 0 {
println("Couldn't set the buffer as the kernel argument")
return
}
/* Create a command queue */
queue = cl.CLCreateCommandQueue(context, device[0], 0, &err)
if err < 0 {
println("Couldn't create a command queue")
return
}
/* Enqueue kernel */
err = cl.CLEnqueueTask(queue, kernel, 0, nil, nil)
if err < 0 {
println("Couldn't enqueue the kernel")
return
}
/* Enqueue command to write to buffer */
err = cl.CLEnqueueWriteBuffer(queue, matrix_buffer, cl.CL_TRUE, 0,
cl.CL_size_t(unsafe.Sizeof(full_matrix)), unsafe.Pointer(&full_matrix[0]), 0, nil, nil)
if err < 0 {
println("Couldn't write to the buffer object")
return
}
/* Enqueue command to read rectangle of data */
err = cl.CLEnqueueReadBufferRect(queue, matrix_buffer, cl.CL_TRUE,
buffer_origin, host_origin, region, 10*sizeoffloat32, 0,
10*sizeoffloat32, 0, unsafe.Pointer(&zero_matrix[0]), 0, nil, nil)
if err < 0 {
println("Couldn't read the rectangle from the buffer object")
return
}
/* Display updated buffer */
for i := 0; i < 8; i++ {
for j := 0; j < 10; j++ {
fmt.Printf("%6.1f", zero_matrix[j+i*10])
}
fmt.Printf("\n")
}
/* Deallocate resources */
cl.CLReleaseMemObject(matrix_buffer)
cl.CLReleaseKernel(kernel)
cl.CLReleaseCommandQueue(queue)
cl.CLReleaseProgram(*program)
cl.CLReleaseContext(context)
}
func main() {
/* OpenCL data structures */
var device []cl.CL_device_id
var context cl.CL_context
var queue cl.CL_command_queue
var program *cl.CL_program
var kernel cl.CL_kernel
var err cl.CL_int
/* Data and events */
var num_vectors cl.CL_int
var data [NUM_BYTES]byte
var data_buffer cl.CL_mem
var prof_event cl.CL_event
var total_time cl.CL_ulong
var time_start, time_end interface{}
var mapped_memory unsafe.Pointer
/* Create a device and context */
device = utils.Create_device()
context = cl.CLCreateContext(nil, 1, device[:], nil, nil, &err)
if err < 0 {
println("Couldn't create a context")
return
}
/* Build the program and create a kernel */
program = utils.Build_program(context, device[:], PROGRAM_FILE, nil)
kernel = cl.CLCreateKernel(*program, KERNEL_FUNC, &err)
if err < 0 {
println("Couldn't create a kernel")
return
}
/* Create a buffer to hold data */
data_buffer = cl.CLCreateBuffer(context, cl.CL_MEM_WRITE_ONLY,
cl.CL_size_t(unsafe.Sizeof(data[0]))*NUM_BYTES, nil, &err)
if err < 0 {
println("Couldn't create a buffer")
return
}
/* Create kernel argument */
err = cl.CLSetKernelArg(kernel, 0, cl.CL_size_t(unsafe.Sizeof(data_buffer)), unsafe.Pointer(&data_buffer))
if err < 0 {
println("Couldn't set a kernel argument")
return
}
/* Tell kernel number of char16 vectors */
num_vectors = NUM_BYTES / 16
cl.CLSetKernelArg(kernel, 1, cl.CL_size_t(unsafe.Sizeof(num_vectors)), unsafe.Pointer(&num_vectors))
/* Create a command queue */
queue = cl.CLCreateCommandQueue(context, device[0],
cl.CL_QUEUE_PROFILING_ENABLE, &err)
if err < 0 {
println("Couldn't create a command queue")
return
}
total_time = 0.0
for i := 0; i < NUM_ITERATIONS; i++ {
/* Enqueue kernel */
err = cl.CLEnqueueTask(queue, kernel, 0, nil, nil)
if err < 0 {
println("Couldn't enqueue the kernel")
return
}
if PROFILE_READ == 1 {
/* Read the buffer */
err = cl.CLEnqueueReadBuffer(queue, data_buffer, cl.CL_TRUE, 0,
cl.CL_size_t(unsafe.Sizeof(data[0]))*NUM_BYTES, unsafe.Pointer(&data[0]), 0, nil, &prof_event)
if err < 0 {
println("Couldn't read the buffer")
return
}
} else {
/* Create memory map */
mapped_memory = cl.CLEnqueueMapBuffer(queue, data_buffer, cl.CL_TRUE,
cl.CL_MAP_READ, 0, cl.CL_size_t(unsafe.Sizeof(data[0]))*NUM_BYTES, 0, nil, &prof_event, &err)
if err < 0 {
println("Couldn't map the buffer to host memory")
return
}
}
/* Get profiling information */
cl.CLGetEventProfilingInfo(prof_event, cl.CL_PROFILING_COMMAND_START,
cl.CL_size_t(unsafe.Sizeof(total_time)), &time_start, nil)
cl.CLGetEventProfilingInfo(prof_event, cl.CL_PROFILING_COMMAND_END,
cl.CL_size_t(unsafe.Sizeof(total_time)), &time_end, nil)
total_time += time_end.(cl.CL_ulong) - time_start.(cl.CL_ulong)
if PROFILE_READ == 0 {
/* Unmap the buffer */
err = cl.CLEnqueueUnmapMemObject(queue, data_buffer, mapped_memory,
0, nil, nil)
if err < 0 {
println("Couldn't unmap the buffer")
return
}
}
}
if PROFILE_READ == 1 {
fmt.Printf("Average read time: %v\n", total_time/NUM_ITERATIONS)
} else {
fmt.Printf("Average map time: %v\n", total_time/NUM_ITERATIONS)
}
/* Deallocate resources */
cl.CLReleaseEvent(prof_event)
cl.CLReleaseMemObject(data_buffer)
cl.CLReleaseKernel(kernel)
cl.CLReleaseCommandQueue(queue)
cl.CLReleaseProgram(*program)
cl.CLReleaseContext(context)
}
func main() {
/* OpenCL data structures */
var device []cl.CL_device_id
var context cl.CL_context
var queue cl.CL_command_queue
var program *cl.CL_program
var kernel cl.CL_kernel
var err cl.CL_int
/* Data and buffers */
var r_coords = [4]float32{2, 1, 3, 4}
var angles = [4]float32{3 * M_PI / 8, 3 * M_PI / 4, 4 * M_PI / 3, 11 * M_PI / 6}
var x_coords, y_coords [4]float32
var r_coords_buffer, angles_buffer,
x_coords_buffer, y_coords_buffer cl.CL_mem
/* Create a device and context */
device = utils.Create_device()
context = cl.CLCreateContext(nil, 1, device[:], nil, nil, &err)
if err < 0 {
println("Couldn't create a context")
return
}
/* Create a kernel */
program = utils.Build_program(context, device[:], PROGRAM_FILE, nil)
kernel = cl.CLCreateKernel(*program, KERNEL_FUNC, &err)
if err < 0 {
println("Couldn't create a kernel")
return
}
/* Create a write-only buffer to hold the output data */
r_coords_buffer = cl.CLCreateBuffer(context, cl.CL_MEM_READ_ONLY|cl.CL_MEM_COPY_HOST_PTR,
cl.CL_size_t(unsafe.Sizeof(r_coords)), unsafe.Pointer(&r_coords[0]), &err)
if err < 0 {
println("Couldn't create a buffer")
return
}
angles_buffer = cl.CLCreateBuffer(context, cl.CL_MEM_READ_ONLY|cl.CL_MEM_COPY_HOST_PTR,
cl.CL_size_t(unsafe.Sizeof(angles)), unsafe.Pointer(&angles[0]), &err)
x_coords_buffer = cl.CLCreateBuffer(context, cl.CL_MEM_READ_WRITE,
cl.CL_size_t(unsafe.Sizeof(x_coords)), nil, &err)
y_coords_buffer = cl.CLCreateBuffer(context, cl.CL_MEM_READ_WRITE,
cl.CL_size_t(unsafe.Sizeof(y_coords)), nil, &err)
/* Create kernel argument */
err = cl.CLSetKernelArg(kernel, 0, cl.CL_size_t(unsafe.Sizeof(r_coords_buffer)), unsafe.Pointer(&r_coords_buffer))
if err < 0 {
println("Couldn't set a kernel argument")
return
}
cl.CLSetKernelArg(kernel, 1, cl.CL_size_t(unsafe.Sizeof(angles_buffer)), unsafe.Pointer(&angles_buffer))
cl.CLSetKernelArg(kernel, 2, cl.CL_size_t(unsafe.Sizeof(x_coords_buffer)), unsafe.Pointer(&x_coords_buffer))
cl.CLSetKernelArg(kernel, 3, cl.CL_size_t(unsafe.Sizeof(y_coords_buffer)), unsafe.Pointer(&y_coords_buffer))
/* Create a command queue */
queue = cl.CLCreateCommandQueue(context, device[0], 0, &err)
if err < 0 {
println("Couldn't create a command queue")
return
}
/* Enqueue kernel */
err = cl.CLEnqueueTask(queue, kernel, 0, nil, nil)
if err < 0 {
println("Couldn't enqueue the kernel")
return
}
/* Read and print the result */
err = cl.CLEnqueueReadBuffer(queue, x_coords_buffer, cl.CL_TRUE, 0,
cl.CL_size_t(unsafe.Sizeof(x_coords)), unsafe.Pointer(&x_coords), 0, nil, nil)
if err < 0 {
println("Couldn't read the buffer")
return
}
cl.CLEnqueueReadBuffer(queue, y_coords_buffer, cl.CL_TRUE, 0,
cl.CL_size_t(unsafe.Sizeof(y_coords)), unsafe.Pointer(&y_coords), 0, nil, nil)
/* Display the results */
for i := 0; i < 4; i++ {
fmt.Printf("(%6.3f, %6.3f)\n", x_coords[i], y_coords[i])
}
/* Deallocate resources */
cl.CLReleaseMemObject(r_coords_buffer)
cl.CLReleaseMemObject(angles_buffer)
cl.CLReleaseMemObject(x_coords_buffer)
cl.CLReleaseMemObject(y_coords_buffer)
cl.CLReleaseKernel(kernel)
cl.CLReleaseCommandQueue(queue)
cl.CLReleaseProgram(*program)
cl.CLReleaseContext(context)
}