aboutsummaryrefslogtreecommitdiffstats
path: root/Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/types.go
diff options
context:
space:
mode:
Diffstat (limited to 'Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/types.go')
-rw-r--r--Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/types.go487
1 files changed, 487 insertions, 0 deletions
diff --git a/Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/types.go b/Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/types.go
new file mode 100644
index 000000000..00c846ce7
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/Gustav-Simonsson/go-opencl/cl/types.go
@@ -0,0 +1,487 @@
+package cl
+
+// #ifdef __APPLE__
+// #include "OpenCL/opencl.h"
+// #else
+// #include "cl.h"
+// #endif
+import "C"
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+ "runtime"
+ "strings"
+ "unsafe"
+)
+
+var (
+ ErrUnknown = errors.New("cl: unknown error") // Generally an unexpected result from an OpenCL function (e.g. CL_SUCCESS but null pointer)
+)
+
+type ErrOther int
+
+func (e ErrOther) Error() string {
+ return fmt.Sprintf("cl: error %d", int(e))
+}
+
+var (
+ ErrDeviceNotFound = errors.New("cl: Device Not Found")
+ ErrDeviceNotAvailable = errors.New("cl: Device Not Available")
+ ErrCompilerNotAvailable = errors.New("cl: Compiler Not Available")
+ ErrMemObjectAllocationFailure = errors.New("cl: Mem Object Allocation Failure")
+ ErrOutOfResources = errors.New("cl: Out Of Resources")
+ ErrOutOfHostMemory = errors.New("cl: Out Of Host Memory")
+ ErrProfilingInfoNotAvailable = errors.New("cl: Profiling Info Not Available")
+ ErrMemCopyOverlap = errors.New("cl: Mem Copy Overlap")
+ ErrImageFormatMismatch = errors.New("cl: Image Format Mismatch")
+ ErrImageFormatNotSupported = errors.New("cl: Image Format Not Supported")
+ ErrBuildProgramFailure = errors.New("cl: Build Program Failure")
+ ErrMapFailure = errors.New("cl: Map Failure")
+ ErrMisalignedSubBufferOffset = errors.New("cl: Misaligned Sub Buffer Offset")
+ ErrExecStatusErrorForEventsInWaitList = errors.New("cl: Exec Status Error For Events In Wait List")
+ ErrCompileProgramFailure = errors.New("cl: Compile Program Failure")
+ ErrLinkerNotAvailable = errors.New("cl: Linker Not Available")
+ ErrLinkProgramFailure = errors.New("cl: Link Program Failure")
+ ErrDevicePartitionFailed = errors.New("cl: Device Partition Failed")
+ ErrKernelArgInfoNotAvailable = errors.New("cl: Kernel Arg Info Not Available")
+ ErrInvalidValue = errors.New("cl: Invalid Value")
+ ErrInvalidDeviceType = errors.New("cl: Invalid Device Type")
+ ErrInvalidPlatform = errors.New("cl: Invalid Platform")
+ ErrInvalidDevice = errors.New("cl: Invalid Device")
+ ErrInvalidContext = errors.New("cl: Invalid Context")
+ ErrInvalidQueueProperties = errors.New("cl: Invalid Queue Properties")
+ ErrInvalidCommandQueue = errors.New("cl: Invalid Command Queue")
+ ErrInvalidHostPtr = errors.New("cl: Invalid Host Ptr")
+ ErrInvalidMemObject = errors.New("cl: Invalid Mem Object")
+ ErrInvalidImageFormatDescriptor = errors.New("cl: Invalid Image Format Descriptor")
+ ErrInvalidImageSize = errors.New("cl: Invalid Image Size")
+ ErrInvalidSampler = errors.New("cl: Invalid Sampler")
+ ErrInvalidBinary = errors.New("cl: Invalid Binary")
+ ErrInvalidBuildOptions = errors.New("cl: Invalid Build Options")
+ ErrInvalidProgram = errors.New("cl: Invalid Program")
+ ErrInvalidProgramExecutable = errors.New("cl: Invalid Program Executable")
+ ErrInvalidKernelName = errors.New("cl: Invalid Kernel Name")
+ ErrInvalidKernelDefinition = errors.New("cl: Invalid Kernel Definition")
+ ErrInvalidKernel = errors.New("cl: Invalid Kernel")
+ ErrInvalidArgIndex = errors.New("cl: Invalid Arg Index")
+ ErrInvalidArgValue = errors.New("cl: Invalid Arg Value")
+ ErrInvalidArgSize = errors.New("cl: Invalid Arg Size")
+ ErrInvalidKernelArgs = errors.New("cl: Invalid Kernel Args")
+ ErrInvalidWorkDimension = errors.New("cl: Invalid Work Dimension")
+ ErrInvalidWorkGroupSize = errors.New("cl: Invalid Work Group Size")
+ ErrInvalidWorkItemSize = errors.New("cl: Invalid Work Item Size")
+ ErrInvalidGlobalOffset = errors.New("cl: Invalid Global Offset")
+ ErrInvalidEventWaitList = errors.New("cl: Invalid Event Wait List")
+ ErrInvalidEvent = errors.New("cl: Invalid Event")
+ ErrInvalidOperation = errors.New("cl: Invalid Operation")
+ ErrInvalidGlObject = errors.New("cl: Invalid Gl Object")
+ ErrInvalidBufferSize = errors.New("cl: Invalid Buffer Size")
+ ErrInvalidMipLevel = errors.New("cl: Invalid Mip Level")
+ ErrInvalidGlobalWorkSize = errors.New("cl: Invalid Global Work Size")
+ ErrInvalidProperty = errors.New("cl: Invalid Property")
+ ErrInvalidImageDescriptor = errors.New("cl: Invalid Image Descriptor")
+ ErrInvalidCompilerOptions = errors.New("cl: Invalid Compiler Options")
+ ErrInvalidLinkerOptions = errors.New("cl: Invalid Linker Options")
+ ErrInvalidDevicePartitionCount = errors.New("cl: Invalid Device Partition Count")
+)
+var errorMap = map[C.cl_int]error{
+ C.CL_SUCCESS: nil,
+ C.CL_DEVICE_NOT_FOUND: ErrDeviceNotFound,
+ C.CL_DEVICE_NOT_AVAILABLE: ErrDeviceNotAvailable,
+ C.CL_COMPILER_NOT_AVAILABLE: ErrCompilerNotAvailable,
+ C.CL_MEM_OBJECT_ALLOCATION_FAILURE: ErrMemObjectAllocationFailure,
+ C.CL_OUT_OF_RESOURCES: ErrOutOfResources,
+ C.CL_OUT_OF_HOST_MEMORY: ErrOutOfHostMemory,
+ C.CL_PROFILING_INFO_NOT_AVAILABLE: ErrProfilingInfoNotAvailable,
+ C.CL_MEM_COPY_OVERLAP: ErrMemCopyOverlap,
+ C.CL_IMAGE_FORMAT_MISMATCH: ErrImageFormatMismatch,
+ C.CL_IMAGE_FORMAT_NOT_SUPPORTED: ErrImageFormatNotSupported,
+ C.CL_BUILD_PROGRAM_FAILURE: ErrBuildProgramFailure,
+ C.CL_MAP_FAILURE: ErrMapFailure,
+ C.CL_MISALIGNED_SUB_BUFFER_OFFSET: ErrMisalignedSubBufferOffset,
+ C.CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST: ErrExecStatusErrorForEventsInWaitList,
+ C.CL_INVALID_VALUE: ErrInvalidValue,
+ C.CL_INVALID_DEVICE_TYPE: ErrInvalidDeviceType,
+ C.CL_INVALID_PLATFORM: ErrInvalidPlatform,
+ C.CL_INVALID_DEVICE: ErrInvalidDevice,
+ C.CL_INVALID_CONTEXT: ErrInvalidContext,
+ C.CL_INVALID_QUEUE_PROPERTIES: ErrInvalidQueueProperties,
+ C.CL_INVALID_COMMAND_QUEUE: ErrInvalidCommandQueue,
+ C.CL_INVALID_HOST_PTR: ErrInvalidHostPtr,
+ C.CL_INVALID_MEM_OBJECT: ErrInvalidMemObject,
+ C.CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: ErrInvalidImageFormatDescriptor,
+ C.CL_INVALID_IMAGE_SIZE: ErrInvalidImageSize,
+ C.CL_INVALID_SAMPLER: ErrInvalidSampler,
+ C.CL_INVALID_BINARY: ErrInvalidBinary,
+ C.CL_INVALID_BUILD_OPTIONS: ErrInvalidBuildOptions,
+ C.CL_INVALID_PROGRAM: ErrInvalidProgram,
+ C.CL_INVALID_PROGRAM_EXECUTABLE: ErrInvalidProgramExecutable,
+ C.CL_INVALID_KERNEL_NAME: ErrInvalidKernelName,
+ C.CL_INVALID_KERNEL_DEFINITION: ErrInvalidKernelDefinition,
+ C.CL_INVALID_KERNEL: ErrInvalidKernel,
+ C.CL_INVALID_ARG_INDEX: ErrInvalidArgIndex,
+ C.CL_INVALID_ARG_VALUE: ErrInvalidArgValue,
+ C.CL_INVALID_ARG_SIZE: ErrInvalidArgSize,
+ C.CL_INVALID_KERNEL_ARGS: ErrInvalidKernelArgs,
+ C.CL_INVALID_WORK_DIMENSION: ErrInvalidWorkDimension,
+ C.CL_INVALID_WORK_GROUP_SIZE: ErrInvalidWorkGroupSize,
+ C.CL_INVALID_WORK_ITEM_SIZE: ErrInvalidWorkItemSize,
+ C.CL_INVALID_GLOBAL_OFFSET: ErrInvalidGlobalOffset,
+ C.CL_INVALID_EVENT_WAIT_LIST: ErrInvalidEventWaitList,
+ C.CL_INVALID_EVENT: ErrInvalidEvent,
+ C.CL_INVALID_OPERATION: ErrInvalidOperation,
+ C.CL_INVALID_GL_OBJECT: ErrInvalidGlObject,
+ C.CL_INVALID_BUFFER_SIZE: ErrInvalidBufferSize,
+ C.CL_INVALID_MIP_LEVEL: ErrInvalidMipLevel,
+ C.CL_INVALID_GLOBAL_WORK_SIZE: ErrInvalidGlobalWorkSize,
+ C.CL_INVALID_PROPERTY: ErrInvalidProperty,
+}
+
+func toError(code C.cl_int) error {
+ if err, ok := errorMap[code]; ok {
+ return err
+ }
+ return ErrOther(code)
+}
+
+type LocalMemType int
+
+const (
+ LocalMemTypeNone LocalMemType = C.CL_NONE
+ LocalMemTypeGlobal LocalMemType = C.CL_GLOBAL
+ LocalMemTypeLocal LocalMemType = C.CL_LOCAL
+)
+
+var localMemTypeMap = map[LocalMemType]string{
+ LocalMemTypeNone: "None",
+ LocalMemTypeGlobal: "Global",
+ LocalMemTypeLocal: "Local",
+}
+
+func (t LocalMemType) String() string {
+ name := localMemTypeMap[t]
+ if name == "" {
+ name = "Unknown"
+ }
+ return name
+}
+
+type ExecCapability int
+
+const (
+ ExecCapabilityKernel ExecCapability = C.CL_EXEC_KERNEL // The OpenCL device can execute OpenCL kernels.
+ ExecCapabilityNativeKernel ExecCapability = C.CL_EXEC_NATIVE_KERNEL // The OpenCL device can execute native kernels.
+)
+
+func (ec ExecCapability) String() string {
+ var parts []string
+ if ec&ExecCapabilityKernel != 0 {
+ parts = append(parts, "Kernel")
+ }
+ if ec&ExecCapabilityNativeKernel != 0 {
+ parts = append(parts, "NativeKernel")
+ }
+ if parts == nil {
+ return ""
+ }
+ return strings.Join(parts, "|")
+}
+
+type MemCacheType int
+
+const (
+ MemCacheTypeNone MemCacheType = C.CL_NONE
+ MemCacheTypeReadOnlyCache MemCacheType = C.CL_READ_ONLY_CACHE
+ MemCacheTypeReadWriteCache MemCacheType = C.CL_READ_WRITE_CACHE
+)
+
+func (ct MemCacheType) String() string {
+ switch ct {
+ case MemCacheTypeNone:
+ return "None"
+ case MemCacheTypeReadOnlyCache:
+ return "ReadOnly"
+ case MemCacheTypeReadWriteCache:
+ return "ReadWrite"
+ }
+ return fmt.Sprintf("Unknown(%x)", int(ct))
+}
+
+type MemFlag int
+
+const (
+ MemReadWrite MemFlag = C.CL_MEM_READ_WRITE
+ MemWriteOnly MemFlag = C.CL_MEM_WRITE_ONLY
+ MemReadOnly MemFlag = C.CL_MEM_READ_ONLY
+ MemUseHostPtr MemFlag = C.CL_MEM_USE_HOST_PTR
+ MemAllocHostPtr MemFlag = C.CL_MEM_ALLOC_HOST_PTR
+ MemCopyHostPtr MemFlag = C.CL_MEM_COPY_HOST_PTR
+
+ MemWriteOnlyHost MemFlag = C.CL_MEM_HOST_WRITE_ONLY
+ MemReadOnlyHost MemFlag = C.CL_MEM_HOST_READ_ONLY
+ MemNoAccessHost MemFlag = C.CL_MEM_HOST_NO_ACCESS
+)
+
+type MemObjectType int
+
+const (
+ MemObjectTypeBuffer MemObjectType = C.CL_MEM_OBJECT_BUFFER
+ MemObjectTypeImage2D MemObjectType = C.CL_MEM_OBJECT_IMAGE2D
+ MemObjectTypeImage3D MemObjectType = C.CL_MEM_OBJECT_IMAGE3D
+)
+
+type MapFlag int
+
+const (
+ // This flag specifies that the region being mapped in the memory object is being mapped for reading.
+ MapFlagRead MapFlag = C.CL_MAP_READ
+ MapFlagWrite MapFlag = C.CL_MAP_WRITE
+ MapFlagWriteInvalidateRegion MapFlag = C.CL_MAP_WRITE_INVALIDATE_REGION
+)
+
+func (mf MapFlag) toCl() C.cl_map_flags {
+ return C.cl_map_flags(mf)
+}
+
+type ChannelOrder int
+
+const (
+ ChannelOrderR ChannelOrder = C.CL_R
+ ChannelOrderA ChannelOrder = C.CL_A
+ ChannelOrderRG ChannelOrder = C.CL_RG
+ ChannelOrderRA ChannelOrder = C.CL_RA
+ ChannelOrderRGB ChannelOrder = C.CL_RGB
+ ChannelOrderRGBA ChannelOrder = C.CL_RGBA
+ ChannelOrderBGRA ChannelOrder = C.CL_BGRA
+ ChannelOrderARGB ChannelOrder = C.CL_ARGB
+ ChannelOrderIntensity ChannelOrder = C.CL_INTENSITY
+ ChannelOrderLuminance ChannelOrder = C.CL_LUMINANCE
+ ChannelOrderRx ChannelOrder = C.CL_Rx
+ ChannelOrderRGx ChannelOrder = C.CL_RGx
+ ChannelOrderRGBx ChannelOrder = C.CL_RGBx
+)
+
+var channelOrderNameMap = map[ChannelOrder]string{
+ ChannelOrderR: "R",
+ ChannelOrderA: "A",
+ ChannelOrderRG: "RG",
+ ChannelOrderRA: "RA",
+ ChannelOrderRGB: "RGB",
+ ChannelOrderRGBA: "RGBA",
+ ChannelOrderBGRA: "BGRA",
+ ChannelOrderARGB: "ARGB",
+ ChannelOrderIntensity: "Intensity",
+ ChannelOrderLuminance: "Luminance",
+ ChannelOrderRx: "Rx",
+ ChannelOrderRGx: "RGx",
+ ChannelOrderRGBx: "RGBx",
+}
+
+func (co ChannelOrder) String() string {
+ name := channelOrderNameMap[co]
+ if name == "" {
+ name = fmt.Sprintf("Unknown(%x)", int(co))
+ }
+ return name
+}
+
+type ChannelDataType int
+
+const (
+ ChannelDataTypeSNormInt8 ChannelDataType = C.CL_SNORM_INT8
+ ChannelDataTypeSNormInt16 ChannelDataType = C.CL_SNORM_INT16
+ ChannelDataTypeUNormInt8 ChannelDataType = C.CL_UNORM_INT8
+ ChannelDataTypeUNormInt16 ChannelDataType = C.CL_UNORM_INT16
+ ChannelDataTypeUNormShort565 ChannelDataType = C.CL_UNORM_SHORT_565
+ ChannelDataTypeUNormShort555 ChannelDataType = C.CL_UNORM_SHORT_555
+ ChannelDataTypeUNormInt101010 ChannelDataType = C.CL_UNORM_INT_101010
+ ChannelDataTypeSignedInt8 ChannelDataType = C.CL_SIGNED_INT8
+ ChannelDataTypeSignedInt16 ChannelDataType = C.CL_SIGNED_INT16
+ ChannelDataTypeSignedInt32 ChannelDataType = C.CL_SIGNED_INT32
+ ChannelDataTypeUnsignedInt8 ChannelDataType = C.CL_UNSIGNED_INT8
+ ChannelDataTypeUnsignedInt16 ChannelDataType = C.CL_UNSIGNED_INT16
+ ChannelDataTypeUnsignedInt32 ChannelDataType = C.CL_UNSIGNED_INT32
+ ChannelDataTypeHalfFloat ChannelDataType = C.CL_HALF_FLOAT
+ ChannelDataTypeFloat ChannelDataType = C.CL_FLOAT
+)
+
+var channelDataTypeNameMap = map[ChannelDataType]string{
+ ChannelDataTypeSNormInt8: "SNormInt8",
+ ChannelDataTypeSNormInt16: "SNormInt16",
+ ChannelDataTypeUNormInt8: "UNormInt8",
+ ChannelDataTypeUNormInt16: "UNormInt16",
+ ChannelDataTypeUNormShort565: "UNormShort565",
+ ChannelDataTypeUNormShort555: "UNormShort555",
+ ChannelDataTypeUNormInt101010: "UNormInt101010",
+ ChannelDataTypeSignedInt8: "SignedInt8",
+ ChannelDataTypeSignedInt16: "SignedInt16",
+ ChannelDataTypeSignedInt32: "SignedInt32",
+ ChannelDataTypeUnsignedInt8: "UnsignedInt8",
+ ChannelDataTypeUnsignedInt16: "UnsignedInt16",
+ ChannelDataTypeUnsignedInt32: "UnsignedInt32",
+ ChannelDataTypeHalfFloat: "HalfFloat",
+ ChannelDataTypeFloat: "Float",
+}
+
+func (ct ChannelDataType) String() string {
+ name := channelDataTypeNameMap[ct]
+ if name == "" {
+ name = fmt.Sprintf("Unknown(%x)", int(ct))
+ }
+ return name
+}
+
+type ImageFormat struct {
+ ChannelOrder ChannelOrder
+ ChannelDataType ChannelDataType
+}
+
+func (f ImageFormat) toCl() C.cl_image_format {
+ var format C.cl_image_format
+ format.image_channel_order = C.cl_channel_order(f.ChannelOrder)
+ format.image_channel_data_type = C.cl_channel_type(f.ChannelDataType)
+ return format
+}
+
+type ProfilingInfo int
+
+const (
+ // A 64-bit value that describes the current device time counter in
+ // nanoseconds when the command identified by event is enqueued in
+ // a command-queue by the host.
+ ProfilingInfoCommandQueued ProfilingInfo = C.CL_PROFILING_COMMAND_QUEUED
+ // A 64-bit value that describes the current device time counter in
+ // nanoseconds when the command identified by event that has been
+ // enqueued is submitted by the host to the device associated with the command-queue.
+ ProfilingInfoCommandSubmit ProfilingInfo = C.CL_PROFILING_COMMAND_SUBMIT
+ // A 64-bit value that describes the current device time counter in
+ // nanoseconds when the command identified by event starts execution on the device.
+ ProfilingInfoCommandStart ProfilingInfo = C.CL_PROFILING_COMMAND_START
+ // A 64-bit value that describes the current device time counter in
+ // nanoseconds when the command identified by event has finished
+ // execution on the device.
+ ProfilingInfoCommandEnd ProfilingInfo = C.CL_PROFILING_COMMAND_END
+)
+
+type CommmandExecStatus int
+
+const (
+ CommmandExecStatusComplete CommmandExecStatus = C.CL_COMPLETE
+ CommmandExecStatusRunning CommmandExecStatus = C.CL_RUNNING
+ CommmandExecStatusSubmitted CommmandExecStatus = C.CL_SUBMITTED
+ CommmandExecStatusQueued CommmandExecStatus = C.CL_QUEUED
+)
+
+type Event struct {
+ clEvent C.cl_event
+}
+
+func releaseEvent(ev *Event) {
+ if ev.clEvent != nil {
+ C.clReleaseEvent(ev.clEvent)
+ ev.clEvent = nil
+ }
+}
+
+func (e *Event) Release() {
+ releaseEvent(e)
+}
+
+func (e *Event) GetEventProfilingInfo(paramName ProfilingInfo) (int64, error) {
+ var paramValue C.cl_ulong
+ if err := C.clGetEventProfilingInfo(e.clEvent, C.cl_profiling_info(paramName), C.size_t(unsafe.Sizeof(paramValue)), unsafe.Pointer(&paramValue), nil); err != C.CL_SUCCESS {
+ return 0, toError(err)
+ }
+ return int64(paramValue), nil
+}
+
+// Sets the execution status of a user event object.
+//
+// `status` specifies the new execution status to be set and
+// can be CL_COMPLETE or a negative integer value to indicate
+// an error. A negative integer value causes all enqueued commands
+// that wait on this user event to be terminated. clSetUserEventStatus
+// can only be called once to change the execution status of event.
+func (e *Event) SetUserEventStatus(status int) error {
+ return toError(C.clSetUserEventStatus(e.clEvent, C.cl_int(status)))
+}
+
+// Waits on the host thread for commands identified by event objects in
+// events to complete. A command is considered complete if its execution
+// status is CL_COMPLETE or a negative value. The events specified in
+// event_list act as synchronization points.
+//
+// If the cl_khr_gl_event extension is enabled, event objects can also be
+// used to reflect the status of an OpenGL sync object. The sync object
+// in turn refers to a fence command executing in an OpenGL command
+// stream. This provides another method of coordinating sharing of buffers
+// and images between OpenGL and OpenCL.
+func WaitForEvents(events []*Event) error {
+ return toError(C.clWaitForEvents(C.cl_uint(len(events)), eventListPtr(events)))
+}
+
+func newEvent(clEvent C.cl_event) *Event {
+ ev := &Event{clEvent: clEvent}
+ runtime.SetFinalizer(ev, releaseEvent)
+ return ev
+}
+
+func eventListPtr(el []*Event) *C.cl_event {
+ if el == nil {
+ return nil
+ }
+ elist := make([]C.cl_event, len(el))
+ for i, e := range el {
+ elist[i] = e.clEvent
+ }
+ return (*C.cl_event)(&elist[0])
+}
+
+func clBool(b bool) C.cl_bool {
+ if b {
+ return C.CL_TRUE
+ }
+ return C.CL_FALSE
+}
+
+func sizeT3(i3 [3]int) [3]C.size_t {
+ var val [3]C.size_t
+ val[0] = C.size_t(i3[0])
+ val[1] = C.size_t(i3[1])
+ val[2] = C.size_t(i3[2])
+ return val
+}
+
+type MappedMemObject struct {
+ ptr unsafe.Pointer
+ size int
+ rowPitch int
+ slicePitch int
+}
+
+func (mb *MappedMemObject) ByteSlice() []byte {
+ var byteSlice []byte
+ sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&byteSlice))
+ sliceHeader.Cap = mb.size
+ sliceHeader.Len = mb.size
+ sliceHeader.Data = uintptr(mb.ptr)
+ return byteSlice
+}
+
+func (mb *MappedMemObject) Ptr() unsafe.Pointer {
+ return mb.ptr
+}
+
+func (mb *MappedMemObject) Size() int {
+ return mb.size
+}
+
+func (mb *MappedMemObject) RowPitch() int {
+ return mb.rowPitch
+}
+
+func (mb *MappedMemObject) SlicePitch() int {
+ return mb.slicePitch
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-27 00:03:27 +0800