Golang C.cl_uint函数代码示例

func CreateContextUnsafe(properties *C.cl_context_properties, devices []*Device, pfn_notify CL_ctx_notify, user_data unsafe.Pointer) (*Context, error) {
	deviceIds := buildDeviceIdList(devices)
	var err C.cl_int
	var clContext C.cl_context
	if pfn_notify != nil {
		var c_user_data []unsafe.Pointer
		c_user_data = make([]unsafe.Pointer, 2)
		c_user_data[0] = user_data
		c_user_data[1] = unsafe.Pointer(&pfn_notify)

		ctx_notify[c_user_data[1]] = pfn_notify

		clContext = C.CLCreateContext(properties, C.cl_uint(len(devices)), &deviceIds[0], unsafe.Pointer(&c_user_data), &err)
	} else {
		clContext = C.clCreateContext(properties, C.cl_uint(len(devices)), &deviceIds[0], nil, nil, &err)
	}
	if err != C.CL_SUCCESS {
		return nil, toError(err)
	}
	if clContext == nil {
		return nil, ErrUnknown
	}
	context := &Context{clContext: clContext, devices: devices}
	runtime.SetFinalizer(context, releaseContext)
	return context, nil
}

func CLGetPlatformIDs(num_entries CL_uint,
	platforms []CL_platform_id,
	num_platforms *CL_uint) CL_int {

	if (num_entries == 0 && platforms != nil) || (num_platforms == nil && platforms == nil) {
		return CL_INVALID_VALUE
	} else {
		var c_errcode_ret C.cl_int
		var c_num_platforms C.cl_uint

		if platforms == nil {
			c_errcode_ret = C.clGetPlatformIDs(C.cl_uint(num_entries),
				nil,
				&c_num_platforms)
		} else {
			c_platforms := make([]C.cl_platform_id, len(platforms))
			c_errcode_ret = C.clGetPlatformIDs(C.cl_uint(num_entries),
				&c_platforms[0],
				&c_num_platforms)
			if c_errcode_ret == C.CL_SUCCESS {
				for i := 0; i < len(platforms); i++ {
					platforms[i].cl_platform_id = c_platforms[i]
				}
			}
		}

		if num_platforms != nil {
			*num_platforms = CL_uint(c_num_platforms)
		}
		return CL_int(c_errcode_ret)
	}
}

func CLCreateKernelsInProgram(program CL_program,
	num_kernels CL_uint,
	kernels []CL_kernel,
	num_kernels_ret *CL_uint) CL_int {

	if (num_kernels == 0 && kernels != nil) || (num_kernels_ret == nil && kernels == nil) {
		return CL_INVALID_VALUE
	} else {
		var c_num_kernels_ret C.cl_uint
		var c_errcode_ret C.cl_int

		if kernels == nil {
			c_errcode_ret = C.clCreateKernelsInProgram(program.cl_program,
				C.cl_uint(num_kernels),
				nil,
				&c_num_kernels_ret)
		} else {
			c_kernels := make([]C.cl_kernel, len(kernels))
			c_errcode_ret = C.clCreateKernelsInProgram(program.cl_program,
				C.cl_uint(num_kernels),
				&c_kernels[0],
				&c_num_kernels_ret)
			if c_errcode_ret == C.CL_SUCCESS {
				for i := 0; i < len(kernels); i++ {
					kernels[i].cl_kernel = c_kernels[i]
				}
			}
		}
		if num_kernels_ret != nil {
			*num_kernels_ret = CL_uint(c_num_kernels_ret)
		}

		return CL_int(c_errcode_ret)
	}
}

func (k *Kernel) SetArg(index uint, arg interface{}) error {
	var ret C.cl_int

	switch t := arg.(type) {
	case *Buffer: // can't use *Image here, compiler bug?
		ret = C.clSetKernelArg(k.id, C.cl_uint(index), C.size_t(unsafe.Sizeof(t.id)), unsafe.Pointer(&t.id))
	case *Image:
		ret = C.clSetKernelArg(k.id, C.cl_uint(index), C.size_t(unsafe.Sizeof(t.id)), unsafe.Pointer(&t.id))
	case float32:
		ret = C.clSetKernelArg(k.id, C.cl_uint(index), C.size_t(4), unsafe.Pointer(&t))
	case []float32:
		ret = C.clSetKernelArg(k.id, C.cl_uint(index), C.size_t(len(t)*4), unsafe.Pointer(&t[0]))
	case *float32:
		var p *C.float
		ret = C.clSetKernelArg(k.id, C.cl_uint(index), C.size_t(unsafe.Sizeof(p)), unsafe.Pointer(&t))

	default:
		return Cl_error(C.CL_INVALID_VALUE)
	}

	if ret != C.CL_SUCCESS {
		return Cl_error(ret)
	}
	return nil
}

func (p *Program) CompileProgramWithCallback(devices []*Device, options string, program_headers []*ProgramHeaders, user_data unsafe.Pointer) error {
	var cOptions *C.char
	if options != "" {
		cOptions = C.CString(options)
		defer C.free(unsafe.Pointer(cOptions))
	}
	var deviceList []C.cl_device_id
	var deviceListPtr *C.cl_device_id
	numDevices := C.cl_uint(len(devices))
	if devices != nil && len(devices) > 0 {
		deviceList = buildDeviceIdList(devices)
		deviceListPtr = &deviceList[0]
	}
	num_headers := len(program_headers)
	cHeaders := make([]C.cl_program, num_headers)
	cHeader_names := make([]*C.char, num_headers)
	for idx, ph := range program_headers {
		chs := ph.codes
		chn := C.CString(ph.names)
		cHeaders[idx] = chs.clProgram
		cHeader_names[idx] = chn
		defer C.free(chs)
		defer C.free(chn)
	}
	err := C.CLCompileProgram(p.clProgram, numDevices, deviceListPtr, cOptions, C.cl_uint(num_headers), &cHeaders[0], &cHeader_names[0], user_data)
	if err != C.CL_SUCCESS {
		buffer := make([]byte, 4096)
		var bLen C.size_t
		var err C.cl_int

		for _, dev := range p.devices {
			for i := 2; i >= 0; i-- {
				err = C.clGetProgramBuildInfo(p.clProgram, dev.id, C.CL_PROGRAM_BUILD_LOG, C.size_t(len(buffer)), unsafe.Pointer(&buffer[0]), &bLen)
				if err == C.CL_INVALID_VALUE && i > 0 && bLen < 1024*1024 {
					// INVALID_VALUE probably means our buffer isn't large enough
					buffer = make([]byte, bLen)
				} else {
					break
				}
			}
			if err != C.CL_SUCCESS {
				return toError(err)
			}

			if bLen > 1 {
				return BuildError{
					Device:  dev,
					Message: string(buffer[:bLen-1]),
				}
			}
		}

		return BuildError{
			Device:  nil,
			Message: "build failed and produced no log entries",
		}
	}
	return nil
}

func CLEnqueueMigrateMemObjects(command_queue CL_command_queue,
	num_mem_objects CL_uint,
	mem_objects []CL_mem,
	flags CL_mem_migration_flags,
	num_events_in_wait_list CL_uint,
	event_wait_list []CL_event,
	event *CL_event) CL_int {

	if num_mem_objects == 0 || mem_objects == nil || int(num_mem_objects) != len(mem_objects) {
		return CL_INVALID_VALUE
	}

	if (num_events_in_wait_list == 0 && event_wait_list != nil) ||
		(num_events_in_wait_list != 0 && event_wait_list == nil) ||
		int(num_events_in_wait_list) != len(event_wait_list) {
		return CL_INVALID_EVENT_WAIT_LIST
	}

	var c_mem_objects []C.cl_mem
	var c_event C.cl_event
	var c_errcode_ret C.cl_int

	c_mem_objects = make([]C.cl_mem, len(mem_objects))
	for i := 0; i < len(mem_objects); i++ {
		c_mem_objects[i] = mem_objects[i].cl_mem
	}

	if num_events_in_wait_list != 0 {
		var c_event_wait_list []C.cl_event
		c_event_wait_list = make([]C.cl_event, num_events_in_wait_list)
		for i := 0; i < int(num_events_in_wait_list); i++ {
			c_event_wait_list[i] = event_wait_list[i].cl_event
		}

		c_errcode_ret = C.clEnqueueMigrateMemObjects(command_queue.cl_command_queue,
			C.cl_uint(num_mem_objects),
			&c_mem_objects[0],
			C.cl_mem_migration_flags(flags),
			C.cl_uint(num_events_in_wait_list),
			&c_event_wait_list[0],
			&c_event)
	} else {
		c_errcode_ret = C.clEnqueueMigrateMemObjects(command_queue.cl_command_queue,
			C.cl_uint(num_mem_objects),
			&c_mem_objects[0],
			C.cl_mem_migration_flags(flags),
			0,
			nil,
			&c_event)
	}

	if event != nil {
		event.cl_event = c_event
	}

	return CL_int(c_errcode_ret)
}

func (ctx *Context) LinkProgramWithCallback(programs []*Program, devices []*Device, options string, user_data unsafe.Pointer) (*Program, error) {
	var cOptions *C.char
	if options != "" {
		cOptions = C.CString(options)
		defer C.free(unsafe.Pointer(cOptions))
	}
	var deviceList []C.cl_device_id
	var deviceListPtr *C.cl_device_id
	numDevices := C.cl_uint(len(devices))
	if devices != nil && len(devices) > 0 {
		deviceList = buildDeviceIdList(devices)
		deviceListPtr = &deviceList[0]
	}
	programList := make([]C.cl_program, len(programs))
	for idx, progId := range programs {
		programList[idx] = progId.clProgram
	}
	var err C.cl_int
	programExe := C.CLLinkProgram(ctx.clContext, numDevices, deviceListPtr, cOptions, C.cl_uint(len(programs)), &programList[0], user_data, &err)
	p := &Program{clProgram: programExe, devices: devices}
	if err != C.CL_SUCCESS {
		buffer := make([]byte, 4096)
		var bLen C.size_t
		var err C.cl_int

		for _, dev := range p.devices {
			for i := 2; i >= 0; i-- {
				err = C.clGetProgramBuildInfo(p.clProgram, dev.id, C.CL_PROGRAM_BUILD_LOG, C.size_t(len(buffer)), unsafe.Pointer(&buffer[0]), &bLen)
				if err == C.CL_INVALID_VALUE && i > 0 && bLen < 1024*1024 {
					// INVALID_VALUE probably means our buffer isn't large enough
					buffer = make([]byte, bLen)
				} else {
					break
				}
			}
			if err != C.CL_SUCCESS {
				return nil, toError(err)
			}

			if bLen > 1 {
				return nil, BuildError{
					Device:  dev,
					Message: string(buffer[:bLen-1]),
				}
			}
		}

		return nil, BuildError{
			Device:  nil,
			Message: "build failed and produced no log entries",
		}
	}
	return p, nil
}

func (k *Kernel) ArgName(index int) (string, error) {
	var strC [1024]byte
	var strN C.size_t
	// get the size of the string
	if err := C.clGetKernelArgInfo(k.clKernel, C.cl_uint(index), C.CL_KERNEL_ARG_NAME, 8, nil, &strN); err != C.CL_SUCCESS {
		return "", toError(err)
	}
	if err := C.clGetKernelArgInfo(k.clKernel, C.cl_uint(index), C.CL_KERNEL_ARG_NAME, strN, unsafe.Pointer(&strC[0]), &strN); err != C.CL_SUCCESS {
		return "", toError(err)
	}
	return string(strC[:strN]), nil
}

// see (https://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/climde.html
func (imde ImageDesc) toC() *C.cl_image_desc {
	return &C.cl_image_desc{
		image_type:        C.cl_mem_object_type(imde.imageType),
		image_width:       C.size_t(imde.imageWidth),
		image_height:      C.size_t(imde.imageHeight),
		image_depth:       C.size_t(imde.imageDepth),
		image_array_size:  C.size_t(imde.imageArraySize),
		image_row_pitch:   C.size_t(imde.imageRowPitch),
		image_slice_pitch: C.size_t(imde.imageSlicePitch),
		num_mip_levels:    C.cl_uint(imde.numMipLevels),
		num_samples:       C.cl_uint(imde.numSamples),
		buffer:            C.cl_mem(imde.buffer)}
}

///////////////////////////////////////////////
//OpenCL 1.2
///////////////////////////////////////////////
func CLCreateSubDevices(in_device CL_device_id,
	properties []CL_device_partition_property,
	num_devices CL_uint,
	out_devices []CL_device_id,
	num_devices_ret *CL_uint) CL_int {

	if (num_devices == 0 && out_devices != nil) || (out_devices == nil && num_devices_ret == nil) {
		return CL_INVALID_VALUE
	} else {
		var c_properties []C.cl_device_partition_property
		var c_properties_ptr *C.cl_device_partition_property

		if properties != nil {
			c_properties = make([]C.cl_device_partition_property, len(properties))
			for i := 0; i < len(properties); i++ {
				c_properties[i] = C.cl_device_partition_property(properties[i])
			}
			c_properties_ptr = &c_properties[0]
		} else {
			c_properties_ptr = nil
		}

		var c_errcode_ret C.cl_int
		var c_num_devices_ret C.cl_uint

		if out_devices == nil {
			c_errcode_ret = C.clCreateSubDevices(in_device.cl_device_id,
				c_properties_ptr,
				C.cl_uint(num_devices),
				nil,
				&c_num_devices_ret)
		} else {
			c_out_devices := make([]C.cl_device_id, len(out_devices))
			c_errcode_ret = C.clCreateSubDevices(in_device.cl_device_id,
				c_properties_ptr,
				C.cl_uint(num_devices),
				&c_out_devices[0],
				&c_num_devices_ret)
			if c_errcode_ret == C.CL_SUCCESS {
				for i := 0; i < len(out_devices); i++ {
					out_devices[i].cl_device_id = c_out_devices[i]
				}
			}
		}

		if num_devices_ret != nil {
			*num_devices_ret = CL_uint(c_num_devices_ret)
		}
		return CL_int(c_errcode_ret)
	}
}

func (ctx *Context) CreateProgramWithBuiltInKernels(devices []*Device, kernel_names []string) (*Program, error) {
	cSources := make([]*C.char, 1)
	merge_string := strings.Join(kernel_names, ";")
	cs := C.CString(merge_string)
	cSources[0] = cs
	defer C.free(unsafe.Pointer(cs))
	var deviceList []C.cl_device_id
	var deviceListPtr *C.cl_device_id
	numDevices := C.cl_uint(len(devices))
	if devices != nil && len(devices) > 0 {
		deviceList = buildDeviceIdList(devices)
		deviceListPtr = &deviceList[0]
	}
	var err C.cl_int
	clProgram := C.clCreateProgramWithBuiltInKernels(ctx.clContext, numDevices, deviceListPtr, cSources[0], &err)
	if err != C.CL_SUCCESS {
		return nil, toError(err)
	}
	if clProgram == nil {
		return nil, ErrUnknown
	}
	program := &Program{clProgram: clProgram, devices: ctx.devices}
	runtime.SetFinalizer(program, releaseProgram)
	return program, nil
}

func (p *Program) BuildProgram(devices []*Device, options string) error {
	var cOptions *C.char
	if options != "" {
		cOptions = C.CString(options)
		defer C.free(unsafe.Pointer(cOptions))
	}
	var deviceList []C.cl_device_id
	var deviceListPtr *C.cl_device_id
	if devices != nil && len(devices) > 0 {
		deviceList = buildDeviceIdList(devices)
		deviceListPtr = &deviceList[0]
	}
	numDevices := C.cl_uint(len(deviceList))

	if err := C.clBuildProgram(p.clProgram, numDevices, deviceListPtr, cOptions, nil, nil); err != C.CL_SUCCESS {
		if err != C.CL_BUILD_PROGRAM_FAILURE {
			return toError(err)
		}
		var bLen C.size_t
		var err C.cl_int
		err = C.clGetProgramBuildInfo(p.clProgram, p.devices[0].id, C.CL_PROGRAM_BUILD_LOG, 0, nil, &bLen)
		if err != C.CL_SUCCESS {
			return toError(err)
		}
		buffer := make([]byte, bLen)
		err = C.clGetProgramBuildInfo(p.clProgram, p.devices[0].id, C.CL_PROGRAM_BUILD_LOG, C.size_t(len(buffer)), unsafe.Pointer(&buffer[0]), &bLen)
		if err != C.CL_SUCCESS {
			return toError(err)
		}
		return BuildError(string(buffer[:bLen-1]))
	}
	return nil
}

// Enqueues a command to unmap a previously mapped region of a memory object.
func (q *CommandQueue) EnqueueUnmapMemObject(buffer *MemObject, mappedObj *MappedMemObject, eventWaitList []*Event) (*Event, error) {
	var event C.cl_event
	if err := C.clEnqueueUnmapMemObject(q.clQueue, buffer.clMem, mappedObj.ptr, C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event); err != C.CL_SUCCESS {
		return nil, toError(err)
	}
	return newEvent(event), nil
}

// Enqueues a command to execute a kernel on a device.
func (q *CommandQueue) EnqueueNDRangeKernel(kernel *Kernel, globalWorkOffset, globalWorkSize, localWorkSize []int, eventWaitList []*Event) (*Event, error) {
	workDim := len(globalWorkSize)
	var globalWorkOffsetList []C.size_t
	var globalWorkOffsetPtr *C.size_t
	if globalWorkOffset != nil {
		globalWorkOffsetList = make([]C.size_t, len(globalWorkOffset))
		for i, off := range globalWorkOffset {
			globalWorkOffsetList[i] = C.size_t(off)
		}
		globalWorkOffsetPtr = &globalWorkOffsetList[0]
	}
	var globalWorkSizeList []C.size_t
	var globalWorkSizePtr *C.size_t
	if globalWorkSize != nil {
		globalWorkSizeList = make([]C.size_t, len(globalWorkSize))
		for i, off := range globalWorkSize {
			globalWorkSizeList[i] = C.size_t(off)
		}
		globalWorkSizePtr = &globalWorkSizeList[0]
	}
	var localWorkSizeList []C.size_t
	var localWorkSizePtr *C.size_t
	if localWorkSize != nil {
		localWorkSizeList = make([]C.size_t, len(localWorkSize))
		for i, off := range localWorkSize {
			localWorkSizeList[i] = C.size_t(off)
		}
		localWorkSizePtr = &localWorkSizeList[0]
	}
	var event C.cl_event
	err := toError(C.clEnqueueNDRangeKernel(q.clQueue, kernel.clKernel, C.cl_uint(workDim), globalWorkOffsetPtr, globalWorkSizePtr, localWorkSizePtr, C.cl_uint(len(eventWaitList)), eventListPtr(eventWaitList), &event))
	return newEvent(event), err
}

func CLSetKernelArgSVMPointer(kernel CL_kernel,
	arg_index CL_uint,
	arg_value unsafe.Pointer) CL_int {
	return CL_int(C.clSetKernelArgSVMPointer(kernel.cl_kernel,
		C.cl_uint(arg_index),
		arg_value))
}