diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,49 @@ +RENCI Open Source Software License +The University of North Carolina at Chapel Hill + +The University of North Carolina at Chapel Hill (the "Licensor") through +its Renaissance Computing Institute (RENCI) is making an original work of +authorship (the "Software") available through RENCI upon the terms set +forth in this Open Source Software License (this "License"). This License +applies to any Software that has placed the following notice immediately +following the copyright notice for the Software: Licensed under the RENCI +Open Source Software License v. 1.0. + +Licensor grants You, free of charge, a world-wide, royalty-free, +non-exclusive, perpetual, sublicenseable license to do the following to +deal in the Software without restriction, including without limitation the +rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +. Redistributions of source code must retain the above copyright notice, +this list of conditions and the following disclaimers. + +. Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimers in the +documentation and/or other materials provided with the distribution. + +. Neither You nor any sublicensor of the Software may use the names of +Licensor (or any derivative thereof), of RENCI, or of contributors to the +Software without explicit prior written permission. Nothing in this +License shall be deemed to grant any rights to trademarks, copyrights, +patents, trade secrets or any other intellectual property of Licensor +except as expressly stated herein. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE CONTIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +You may use the Software in all ways not otherwise restricted or +conditioned by this License or by law, and Licensor promises not to +interfere with or be responsible for such uses by You. This Software may +be subject to U.S. law dealing with export controls. If you are in the +U.S., please do not mirror this Software unless you fully understand the +U.S. export regulations. Licensees in other countries may face similar +restrictions. In all cases, it is licensee's responsibility to comply +with any export regulations applicable in licensee's jurisdiction. + diff --git a/OpenCLRaw.cabal b/OpenCLRaw.cabal new file mode 100644 --- /dev/null +++ b/OpenCLRaw.cabal @@ -0,0 +1,71 @@ +name: OpenCLRaw +version: 1.0.1000 +cabal-version: >=1.2 +build-type: Simple +license: BSD3 +license-file: LICENSE +copyright: Renaissance Computing Institute +maintainer: J.R. Heard +build-depends: base <= 4.1.0.0, bytestring -any, mtl -any +stability: Experimental +homepage: http://vis.renci.org/jeff/opencl +package-url: +bug-reports: +synopsis: The OpenCL Standard for heterogenous data-parallel computing +description: The OpenCL system for open heterogenous data parallel supercomputing. + + **General Notes on the differences between Haskell and the OpenCL-C implementation** + + * Side-effectful procedures capable of returning an error code only return a Maybe ErrorCode, with Nothing returned upon success + + * Procedures which follow the pattern of returning a pointer to an object and taking a final parameter as an error code instead return Either ErrorCode ObjectType + + * Procedures which prefix with clGetInfo* merely take the object, parameter name, and parameter size to allocate. The allocation handled by OpenCLRaw and returned as a Haskell-managed ForeignPtr () + + * Enumerations and constants are replaced by newtypes for the sake of type-safety. + +category: Graphics +author: J.R. Heard +tested-with: +data-files: +data-dir: "" +extra-source-files: +extra-tmp-files: +exposed-modules: System.OpenCL.Raw.V10.CommandQueue + System.OpenCL.Raw.V10.Context + System.OpenCL.Raw.V10.DeviceInfo + System.OpenCL.Raw.V10.Errors + System.OpenCL.Raw.V10.Etc + System.OpenCL.Raw.V10.EventObject + System.OpenCL.Raw.V10.FlushFinish + System.OpenCL.Raw.V10.Kernel + System.OpenCL.Raw.V10.MemoryObject + System.OpenCL.Raw.V10.OutOfOrder + System.OpenCL.Raw.V10.PlatformInfo + System.OpenCL.Raw.V10.ProgramObject + System.OpenCL.Raw.V10.Sampler + System.OpenCL.Raw.V10.Types + System.OpenCL.Raw.V10 +exposed: True +buildable: True +build-tools: +cpp-options: +cc-options: +ld-options: +pkgconfig-depends: +frameworks: +c-sources: +extensions: +extra-libraries: +extra-lib-dirs: +includes: +install-includes: +include-dirs: +hs-source-dirs: . +other-modules: +ghc-prof-options: +ghc-shared-options: +ghc-options: +hugs-options: +nhc98-options: +jhc-options: diff --git a/Setup.lhs b/Setup.lhs new file mode 100644 --- /dev/null +++ b/Setup.lhs @@ -0,0 +1,6 @@ +#!/usr/bin/runhaskell +> module Main where +> import Distribution.Simple +> main :: IO () +> main = defaultMain + diff --git a/System/OpenCL/Raw/V10.hs b/System/OpenCL/Raw/V10.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10.hs @@ -0,0 +1,76 @@ +{-| + The OpenCL system for open heterogenous data parallel supercomputing. + + Wrapper to the FFI written and maintained by Jeff Heard of the Renaissance Computing Institute + + From the introduction: + + OpenCL (Open Computing Language) is an open royalty-free standard for general purpose + parallel programming across CPUs, GPUs and other processors, giving software developers + portable and efficient access to the power of these heterogeneous processing platforms. + + OpenCL supports a wide range of applications, ranging from embedded and consumer software + to HPC solutions, through a low-level, high-performance, portable abstraction. By creating an + efficient, close-to-the-metal programming interface, OpenCL will form the foundation layer of a + parallel computing ecosystem of platform-independent tools, middleware and applications. + OpenCL is particularly suited to play an increasingly significant role in emerging interactive + graphics applications that combine general parallel compute algorithms with graphics rendering + pipelines. + + OpenCL consists of an API for coordinating parallel computation across + heterogeneous processors; and a cross-platform programming language with a well- + specified computation environment. The OpenCL standard: + + * Supports both data- and task-based parallel programming models + + * Utilizes a subset of ISO C99 with extensions for parallelism + + * Defines consistent numerical requirements based on IEEE 754 + + * Defines a configuration profile for handheld and embedded devices + + * Efficiently interoperates with OpenGL, OpenGL ES and other graphics APIs + + _General Notes on the differences between Haskell and the OpenCL-C implementation_ + + * Side-effectful procedures capable of returning an error code only return a Maybe ErrorCode, with Nothing returned upon success + + * Procedures which follow the pattern of returning a pointer to an object and taking a final parameter as an error code instead + return Either ErrorCode @ObjectType@ + + * Procedures which prefix with clGetInfo* merely take the object, parameter name, and parameter size to allocate. The allocation + handled by OpenCLRaw and returned as a Haskell-managed @ForeignPtr ()@ + + * Enumerations and constants are replaced by newtypes for the sake of type-safety. +-} +module System.OpenCL.Raw.V10 + (module System.OpenCL.Raw.V10.CommandQueue + ,module System.OpenCL.Raw.V10.Context + ,module System.OpenCL.Raw.V10.DeviceInfo + ,module System.OpenCL.Raw.V10.Errors + ,module System.OpenCL.Raw.V10.Etc + ,module System.OpenCL.Raw.V10.EventObject + ,module System.OpenCL.Raw.V10.FlushFinish + ,module System.OpenCL.Raw.V10.Kernel + ,module System.OpenCL.Raw.V10.MemoryObject + ,module System.OpenCL.Raw.V10.OutOfOrder + ,module System.OpenCL.Raw.V10.PlatformInfo + ,module System.OpenCL.Raw.V10.ProgramObject + ,module System.OpenCL.Raw.V10.Sampler + ,module System.OpenCL.Raw.V10.Types) +where + +import System.OpenCL.Raw.V10.CommandQueue +import System.OpenCL.Raw.V10.Context +import System.OpenCL.Raw.V10.DeviceInfo +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Etc +import System.OpenCL.Raw.V10.EventObject +import System.OpenCL.Raw.V10.FlushFinish +import System.OpenCL.Raw.V10.Kernel +import System.OpenCL.Raw.V10.MemoryObject +import System.OpenCL.Raw.V10.OutOfOrder +import System.OpenCL.Raw.V10.PlatformInfo +import System.OpenCL.Raw.V10.ProgramObject +import System.OpenCL.Raw.V10.Sampler +import System.OpenCL.Raw.V10.Types diff --git a/System/OpenCL/Raw/V10/CommandQueue.hs b/System/OpenCL/Raw/V10/CommandQueue.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/CommandQueue.hs @@ -0,0 +1,46 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +{-| + Corresponds to section 5.1, Command Queues of the OpenCL 1.0 specifications. +-} +module System.OpenCL.Raw.V10.CommandQueue + (clCreateCommandQueue + ,clRetainCommandQueue + ,clGetCommandQueueInfo + ,clSetCommandQueueProperty) +where + +import System.OpenCL.Raw.V10.Types +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Utils +import Foreign +import Control.Applicative +import Data.Bits +import Data.Maybe + + +foreign import ccall "clCreateCommandQueue" raw_clCreateCommandQueue :: Context -> DeviceID -> CLbitfield -> Ptr CLint -> IO CommandQueue +clCreateCommandQueue :: Context -> DeviceID -> CommandQueueProperties -> IO (Either ErrorCode CommandQueue) +clCreateCommandQueue ctx devid (CommandQueueProperties properties) = + wrapErrorEither $ raw_clCreateCommandQueue ctx devid properties + +foreign import ccall "clRetainCommandQueue" raw_clRetainCommandQueue :: CommandQueue -> IO CLint +clRetainCommandQueue :: CommandQueue -> IO (Maybe ErrorCode) +clRetainCommandQueue queue = wrapError (raw_clRetainCommandQueue queue) + +foreign import ccall "clReleaseCommandQueue" raw_clReleaseCommandQueue :: CommandQueue -> IO CLint +clReleaseCommandQueue :: CommandQueue -> IO (Maybe ErrorCode) +clReleaseCommandQueue queue = wrapError (raw_clReleaseCommandQueue queue) + +foreign import ccall "clGetCommandQueueInfo" raw_clGetCommandQueueInfo :: CommandQueue -> CLuint -> CLsizei -> Ptr () -> Ptr CLsizei -> IO CLint +clGetCommandQueueInfo :: CommandQueue -> CommandQueueInfo -> CLsizei -> IO (Either ErrorCode (ForeignPtr (), CLsizei)) +clGetCommandQueueInfo ctx (CommandQueueInfo param_name) param_size = wrapGetInfo (raw_clGetCommandQueueInfo ctx param_name) param_size + +foreign import ccall "clSetCommandQueueProperty" raw_clSetCommandQueueProperty :: CommandQueue -> CLbitfield -> CLbool -> Ptr CLbitfield -> IO CLint +clSetCommandQueueProperty :: CommandQueue -> CommandQueueProperties -> Bool -> IO (Either ErrorCode CommandQueueProperties) +clSetCommandQueueProperty queue (CommandQueueProperties properties) enable = alloca $ \old_properties -> do + err <- ErrorCode <$> raw_clSetCommandQueueProperty queue properties (if enable then clTrue else clFalse) old_properties + if err == clSuccess + then Right . CommandQueueProperties <$> peek old_properties + else return . Left $ err + + diff --git a/System/OpenCL/Raw/V10/Context.hs b/System/OpenCL/Raw/V10/Context.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/Context.hs @@ -0,0 +1,62 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +{-| + Conforms to section 4.3 of the OpenCL 1.0 specification +-} +module System.OpenCL.Raw.V10.Context + (clCreateContext + ,ContextCallback + ,clCreateContextFromType + ,clRetainContext + ,clReleaseContext + ,clGetContextInfo + ) +where + +import System.OpenCL.Raw.V10.Types +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Utils +import Foreign +import Foreign.C +import Control.Applicative +import Data.Bits +import Data.Maybe + + +type ContextCallback = (CString -> Ptr () -> CLsizei -> Ptr () -> IO ()) +foreign import ccall "clCreateContext" raw_clCreateContext :: Ptr (Ptr CLint) -> CLuint -> Ptr DeviceID -> FunPtr ContextCallback -> Ptr () -> Ptr CLint -> IO Context +foreign import ccall "wrapper" wrapCreateContextCallback :: ContextCallback -> IO (FunPtr ContextCallback) + +clCreateContext :: [ContextProperties] -> [DeviceID] -> ContextCallback -> Ptr () -> IO (Either ErrorCode Context) +clCreateContext properties devices pfn_notify user_dat = + allocaArray (propertiesN+1) $ \propertiesP -> allocaArray devicesN $ \devicesP -> do + pokeArray0 nullPtr propertiesP properties + pokeArray devicesP devices + fptr <- wrapCreateContextCallback pfn_notify + wrapErrorEither $ raw_clCreateContext propertiesP (fromIntegral devicesN) devicesP fptr user_dat + where propertiesN = length properties + devicesN = length devices + + +foreign import ccall "clCreateContextFromType" raw_clCreateContextFromType :: Ptr ContextProperties -> CLbitfield -> FunPtr ContextCallback -> Ptr a -> Ptr CLint -> IO Context + +clCreateContextFromType :: [ContextProperties] -> DeviceType -> ContextCallback -> Ptr () -> IO (Either ErrorCode Context) +clCreateContextFromType properties (DeviceType device_type) pfn_notify user_data = allocaArray (propertiesN+1) $ \propertiesP -> do + pokeArray0 nullPtr propertiesP properties + fptr <- wrapCreateContextCallback pfn_notify + wrapErrorEither $ raw_clCreateContextFromType propertiesP device_type fptr user_data + where propertiesN = length properties + +foreign import ccall "clRetainContext" raw_clRetainContext :: Context -> IO CLint +clRetainContext :: Context -> IO (Maybe ErrorCode) +clRetainContext ctx = wrapError (raw_clRetainContext ctx) + +foreign import ccall "clReleaseContext" raw_clReleaseContext :: Context -> IO CLint +clReleaseContext :: Context -> IO (Maybe ErrorCode) +clReleaseContext ctx = wrapError (raw_clReleaseContext ctx) + +foreign import ccall "clGetContextInfo" raw_clGetContextInfo :: Context -> CLuint -> CLsizei -> Ptr () -> Ptr CLsizei -> IO CLint +clGetContextInfo :: Context -> ContextInfo -> CLsizei -> IO (Either ErrorCode (ForeignPtr (), CLsizei)) +clGetContextInfo ctx (ContextInfo param_name) param_size = wrapGetInfo (raw_clGetContextInfo ctx param_name) param_size + + + diff --git a/System/OpenCL/Raw/V10/DeviceInfo.hs b/System/OpenCL/Raw/V10/DeviceInfo.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/DeviceInfo.hs @@ -0,0 +1,28 @@ +{-# LANGUAGE ForeignFunctionInterface, ScopedTypeVariables #-} +{-| Conforms to section 4.2 of the OpenCL 1.0 specification -} +module System.OpenCL.Raw.V10.DeviceInfo + (clGetDeviceIDs + ,clGetDeviceInfo) +where + +import System.OpenCL.Raw.V10.Types +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Utils +import Foreign +import Control.Applicative +import Data.Bits + + +foreign import ccall "clGetDeviceIDs" raw_clGetDeviceIDs :: PlatformID -> CLbitfield -> CLuint -> Ptr DeviceID -> Ptr CLuint -> IO CLint +clGetDeviceIDs :: PlatformID -> DeviceType -> CLuint -> IO (Either ErrorCode [DeviceID]) +clGetDeviceIDs platform (DeviceType device_type) num_entries = alloca $ \(devices::Ptr DeviceID) -> alloca $ \(num_devices::Ptr CLuint) -> do + errcode <- ErrorCode <$> raw_clGetDeviceIDs platform device_type num_entries devices num_devices + if errcode == clSuccess + then Right <$> (peek num_devices >>= \num_devicesN -> peekArray (fromIntegral num_devicesN) devices) + else return $ Left errcode + +foreign import ccall "clGetDeviceInfo" raw_clGetDeviceInfo :: DeviceID -> CLuint -> CLsizei -> Ptr () -> Ptr CLsizei -> IO CLint +clGetDeviceInfo :: DeviceID -> DeviceInfo -> CLsizei -> IO (Either ErrorCode (ForeignPtr (), CLsizei)) +clGetDeviceInfo obj (DeviceInfo param_name) param_size = wrapGetInfo (raw_clGetDeviceInfo obj param_name) param_size + + diff --git a/System/OpenCL/Raw/V10/Errors.hs b/System/OpenCL/Raw/V10/Errors.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/Errors.hs @@ -0,0 +1,142 @@ +{-| A collection of all the error codes that OpenCL functions return -} +module System.OpenCL.Raw.V10.Errors where + +import System.OpenCL.Raw.V10.Types + +clSuccess :: ErrorCode +clSuccess = ErrorCode (0) + +clDeviceNotFound :: ErrorCode +clDeviceNotFound = ErrorCode (-1) + +clDeviceNotAvailable :: ErrorCode +clDeviceNotAvailable = ErrorCode (-2) + +clCompilerNotAvailable :: ErrorCode +clCompilerNotAvailable = ErrorCode (-3) + +clMemObjectAllocationFailure :: ErrorCode +clMemObjectAllocationFailure = ErrorCode (-4) + +clOutOfResources :: ErrorCode +clOutOfResources = ErrorCode (-5) + +clOutOfHostMemory :: ErrorCode +clOutOfHostMemory = ErrorCode (-6) + +clProfilingInfoNotAvailable :: ErrorCode +clProfilingInfoNotAvailable = ErrorCode (-7) + +clMemCopyOverlap :: ErrorCode +clMemCopyOverlap = ErrorCode (-8) + +clImageFormatMismatch :: ErrorCode +clImageFormatMismatch = ErrorCode (-9) + +clImageFormatNotSupported :: ErrorCode +clImageFormatNotSupported = ErrorCode (-10) + +clBuildProgramFailure :: ErrorCode +clBuildProgramFailure = ErrorCode (-11) + +clMapFailure :: ErrorCode +clMapFailure = ErrorCode (-12) + +clInvalidValue :: ErrorCode +clInvalidValue = ErrorCode (-30) + +clInvalidDeviceType :: ErrorCode +clInvalidDeviceType = ErrorCode (-31) + +clInvalidPlatform :: ErrorCode +clInvalidPlatform = ErrorCode (-32) + +clInvalidDevice :: ErrorCode +clInvalidDevice = ErrorCode (-33) + +clInvalidContext :: ErrorCode +clInvalidContext = ErrorCode (-34) + +clInvalidQueueProperties :: ErrorCode +clInvalidQueueProperties = ErrorCode (-35) + +clInvalidCommandQueue :: ErrorCode +clInvalidCommandQueue = ErrorCode (-36) + +clInvalidHostPtr :: ErrorCode +clInvalidHostPtr = ErrorCode (-37) + +clInvalidMemObject :: ErrorCode +clInvalidMemObject = ErrorCode (-38) + +clInvalidImageFormatDescriptor :: ErrorCode +clInvalidImageFormatDescriptor = ErrorCode (-39) + +clInvalidImageSize :: ErrorCode +clInvalidImageSize = ErrorCode (-40) + +clInvalidSampler :: ErrorCode +clInvalidSampler = ErrorCode (-41) + +clInvalidBinary :: ErrorCode +clInvalidBinary = ErrorCode (-42) + +clInvalidBuildOptions :: ErrorCode +clInvalidBuildOptions = ErrorCode (-43) + +clInvalidProgram :: ErrorCode +clInvalidProgram = ErrorCode (-44) + +clInvalidProgramExecutable :: ErrorCode +clInvalidProgramExecutable = ErrorCode (-45) + +clInvalidKernelName :: ErrorCode +clInvalidKernelName = ErrorCode (-46) + +clInvalidKernelDefinition :: ErrorCode +clInvalidKernelDefinition = ErrorCode (-47) + +clInvalidKernel :: ErrorCode +clInvalidKernel = ErrorCode (-48) + +clInvalidArgIndex :: ErrorCode +clInvalidArgIndex = ErrorCode (-49) + +clInvalidArgValue :: ErrorCode +clInvalidArgValue = ErrorCode (-50) + +clInvalidArgSize :: ErrorCode +clInvalidArgSize = ErrorCode (-51) + +clInvalidKernelArgs :: ErrorCode +clInvalidKernelArgs = ErrorCode (-52) + +clInvalidWorkDimension :: ErrorCode +clInvalidWorkDimension = ErrorCode (-53) + +clInvalidWorkGroupSize :: ErrorCode +clInvalidWorkGroupSize = ErrorCode (-54) +clInvalidWorkItemSize :: ErrorCode + +clInvalidWorkItemSize = ErrorCode (-55) +clInvalidGlobalOffset :: ErrorCode + +clInvalidGlobalOffset = ErrorCode (-56) +clInvalidEventWaitList :: ErrorCode + +clInvalidEventWaitList = ErrorCode (-57) +clInvalidEvent :: ErrorCode + +clInvalidEvent = ErrorCode (-58) +clInvalidOperation :: ErrorCode + +clInvalidOperation = ErrorCode (-59) +clInvalidGLObject :: ErrorCode + +clInvalidGLObject = ErrorCode (-60) +clInvalidBufferSize :: ErrorCode + +clInvalidBufferSize = ErrorCode (-61) +clInvalidMipLevel = ErrorCode (-62) + + diff --git a/System/OpenCL/Raw/V10/Etc.hs b/System/OpenCL/Raw/V10/Etc.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/Etc.hs @@ -0,0 +1,16 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +{-| Module for querying extensions -} +module System.OpenCL.Raw.V10.Etc + (clGetExtensionFunctionAddress) +where + +import System.OpenCL.Raw.V10.Types +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Utils +import Foreign +import Foreign.C +import Control.Applicative + +foreign import ccall "clGetExtensionFunctionAddress" raw_clGetExtensionFunctionAddress :: CString -> IO (Ptr ()) +clGetExtensionFunctionAddress :: String -> IO (Ptr ()) +clGetExtensionFunctionAddress str = withCString str raw_clGetExtensionFunctionAddress diff --git a/System/OpenCL/Raw/V10/EventObject.hs b/System/OpenCL/Raw/V10/EventObject.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/EventObject.hs @@ -0,0 +1,38 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +{-| Conforms to section 5.7 of the OpenCL 1.0 specification -} +module System.OpenCL.Raw.V10.EventObject + (clWaitForEvents + ,clGetEventInfo + ,clRetainEvent + ,clReleaseEvent + ,clGetEventProfilingInfo) +where + +import System.OpenCL.Raw.V10.Types +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Utils +import System.OpenCL.Raw.V10.Utils +import Foreign +import Control.Applicative + + +foreign import ccall "clWaitForEvents" raw_clWaitForEvents :: CLuint -> Ptr Event -> IO CLint +clWaitForEvents :: [Event] -> IO (Maybe ErrorCode) +clWaitForEvents evts = allocaArray nEvents $ \eventP -> pokeArray eventP evts >> (wrapError $ raw_clWaitForEvents (fromIntegral nEvents) eventP) + where nEvents = length evts + +foreign import ccall "clGetEventInfo" raw_clGetEventInfo :: Event -> CLuint -> CLsizei -> Ptr () -> Ptr CLsizei -> IO CLint +clGetEventInfo :: Event -> EventInfo -> CLsizei -> IO (Either ErrorCode (ForeignPtr (), CLsizei)) +clGetEventInfo obj (EventInfo param_name) param_size = wrapGetInfo (raw_clGetEventInfo obj param_name) param_size + +foreign import ccall "clRetainEvent" raw_clRetainEvent :: Event -> IO CLint +clRetainEvent :: Event -> IO (Maybe ErrorCode) +clRetainEvent evt = wrapError $ raw_clRetainEvent evt + +foreign import ccall "clReleaseEvent" raw_clReleaseEvent :: Event -> IO CLint +clReleaseEvent :: Event -> IO (Maybe ErrorCode) +clReleaseEvent evt = wrapError $ raw_clReleaseEvent evt + +foreign import ccall "clGetEventProfilingInfo" raw_clGetEventProfilingInfo :: Event -> CLuint -> CLsizei -> Ptr () -> Ptr CLsizei -> IO CLint +clGetEventProfilingInfo :: Event -> ProfilingInfo -> CLsizei -> IO (Either ErrorCode (ForeignPtr (), CLsizei)) +clGetEventProfilingInfo obj (ProfilingInfo param_name) param_size = wrapGetInfo (raw_clGetEventProfilingInfo obj param_name) param_size diff --git a/System/OpenCL/Raw/V10/FlushFinish.hs b/System/OpenCL/Raw/V10/FlushFinish.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/FlushFinish.hs @@ -0,0 +1,21 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +{-| Conforms to section 5.10 of the OpenCL 1.0 specification -} +module System.OpenCL.Raw.V10.FlushFinish + (clFlush + ,clFinish) +where + +import System.OpenCL.Raw.V10.Types +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Utils +import Foreign +import Control.Applicative + +foreign import ccall "clFlush" raw_clFlush :: CommandQueue -> IO CLint +clFlush :: CommandQueue -> IO (Maybe ErrorCode) +clFlush queue = wrapError $ raw_clFlush queue + +foreign import ccall "clFinish" raw_clFinish :: CommandQueue -> IO CLint +clFinish :: CommandQueue -> IO (Maybe ErrorCode) +clFinish queue = wrapError $ raw_clFinish queue + diff --git a/System/OpenCL/Raw/V10/Kernel.hs b/System/OpenCL/Raw/V10/Kernel.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/Kernel.hs @@ -0,0 +1,109 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +{-| Conforms to section 5.5 of the OpenCL 1.0 specification -} +module System.OpenCL.Raw.V10.Kernel + (clCreateKernel + ,clCreateKernelsInProgram + ,clRetainKernel + ,clReleaseKernel + ,clGetKernelInfo + ,clGetKernelWorkGroupInfo + ,clEnqueueNDRangeKernel + ,clEnqueueTask + ,clEnqueueNativeKernel) +where + +import System.OpenCL.Raw.V10.Types +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Utils +import Foreign +import Foreign.C +import Control.Applicative +import Data.Maybe + + +foreign import ccall "clCreateKernel" raw_clCreateKernel :: Program -> CString -> Ptr CLint -> IO Kernel +clCreateKernel program kernel_name = wrapErrorEither $ raw_clCreateKernel program kernel_name + +foreign import ccall "clCreateKernelsInProgram" raw_clCreateKernelsInProgram :: Program -> CLuint -> Ptr Kernel -> Ptr CLuint -> IO CLint +clCreateKernelsInProgram :: Program -> CLuint -> IO (Either ErrorCode [Kernel]) +clCreateKernelsInProgram program num_kernels = allocaArray (fromIntegral num_kernels) $ \kernels -> alloca $ \num_kernels_ret -> do + err <- wrapError $ raw_clCreateKernelsInProgram program num_kernels kernels num_kernels_ret + if err== Nothing + then do + nkr <- peek num_kernels_ret + Right <$> peekArray (fromIntegral nkr) kernels + else + return $ Left . fromJust $ err + +foreign import ccall "clRetainKernel" raw_clRetainKernel :: Kernel -> IO CLint +clRetainKernel :: Kernel -> IO (Maybe ErrorCode) +clRetainKernel kernel = wrapError $ raw_clRetainKernel kernel + +foreign import ccall "clReleaseKernel" raw_clReleaseKernel :: Kernel -> IO CLint +clReleaseKernel :: Kernel -> IO (Maybe ErrorCode) +clReleaseKernel kernel = wrapError $ raw_clRetainKernel kernel + +foreign import ccall "clSetKernelArg" raw_clSetKernelArg :: Kernel -> CLuint -> CLsizei -> Ptr () -> IO CLint +clSetKernelArg :: Kernel -> CLuint -> CLsizei -> Ptr () -> IO (Maybe ErrorCode) +clSetKernelArg kernel arg_index arg_size arg_value = + wrapError $ raw_clSetKernelArg kernel arg_index arg_size arg_value + +foreign import ccall "clGetKernelInfo" raw_clGetKernelInfo :: Kernel -> CLuint -> CLsizei -> Ptr () -> Ptr CLsizei -> IO CLint +clGetKernelInfo :: Kernel -> KernelInfo -> CLsizei -> IO (Either ErrorCode (ForeignPtr (), CLsizei)) +clGetKernelInfo kernel (KernelInfo param_name) param_value_size = wrapGetInfo (raw_clGetKernelInfo kernel param_name) param_value_size + +foreign import ccall "clGetKernelWorkGroupInfo" raw_clGetKernelWorkGroupInfo :: Kernel -> DeviceID -> CLuint -> CLsizei -> Ptr () -> Ptr CLsizei -> IO CLint +clGetKernelWorkGroupInfo :: Kernel -> DeviceID -> KernelWorkGroupInfo -> CLsizei -> IO (Either ErrorCode (ForeignPtr (), CLsizei)) +clGetKernelWorkGroupInfo kernel device (KernelWorkGroupInfo param_name) param_value_size = wrapGetInfo (raw_clGetKernelWorkGroupInfo kernel device param_name) param_value_size + +foreign import ccall "clEnqueueNDRangeKernel" raw_clEnqueueNDRangeKernel :: CommandQueue -> Kernel -> CLuint -> Ptr CLsizei -> Ptr CLsizei -> Ptr CLsizei -> CLuint -> Ptr Event -> Ptr Event -> IO CLint +clEnqueueNDRangeKernel :: CommandQueue -> Kernel -> [CLsizei] -> [CLsizei] -> [Event] -> IO (Either ErrorCode Event) +clEnqueueNDRangeKernel queue kernel global_work_sizeL local_work_sizeL event_wait_listL = + allocaArray work_dim $ \global_work_size -> + allocaArray work_dim $ \local_work_size -> + allocaArray num_events_in_wait_list $ \event_wait_list -> + alloca $ \event -> do + pokeArray global_work_size global_work_sizeL + pokeArray local_work_size local_work_sizeL + pokeArray event_wait_list event_wait_listL + err <- wrapError $ raw_clEnqueueNDRangeKernel queue kernel (fromIntegral work_dim) nullPtr global_work_size local_work_size (fromIntegral num_events_in_wait_list) event_wait_list event + if err == Nothing + then Right <$> peek event + else return $ Left . fromJust $ err + where work_dim = length global_work_sizeL + num_events_in_wait_list = length event_wait_listL + +foreign import ccall "clEnqueueTask" raw_clEnqueueTask :: CommandQueue -> Kernel -> CLuint -> Ptr Event -> Ptr Event -> IO CLint +clEnqueueTask :: CommandQueue -> Kernel -> [Event] -> IO (Either ErrorCode Event) +clEnqueueTask queue kernel event_wait_listL = + allocaArray num_events_in_wait_list $ \event_wait_list -> + alloca $ \event -> do + pokeArray event_wait_list event_wait_listL + err <- wrapError $ raw_clEnqueueTask queue kernel (fromIntegral num_events_in_wait_list) event_wait_list event + if err == Nothing + then Right <$> peek event + else return $ Left . fromJust $ err + where num_events_in_wait_list = length event_wait_listL + +type NKCallbackFunction = Ptr () -> IO () +foreign import ccall "wrapper" wrapNativeKernelCallback :: NKCallbackFunction -> IO (FunPtr NKCallbackFunction) +foreign import ccall "clEnqueueNativeKernel" raw_clEnqueueNativeKernel :: FunPtr NKCallbackFunction -> Ptr () -> CLsizei -> CLuint -> Ptr Mem -> Ptr (Ptr ()) -> CLuint -> Ptr Event -> Ptr Event -> IO CLint +clEnqueueNativeKernel :: NKCallbackFunction -> Ptr () -> CLsizei -> [Mem] -> [Ptr ()] -> [Event] -> IO (Either ErrorCode Event) +clEnqueueNativeKernel user_funcF args cb_args mem_listL args_mem_locL event_wait_listL = + allocaArray num_events_in_wait_list $ \event_wait_list -> + allocaArray num_mem_objects $ \mem_list -> + allocaArray (length args_mem_locL) $ \args_mem_loc -> + alloca $ \event -> do + user_func <- wrapNativeKernelCallback user_funcF + pokeArray event_wait_list event_wait_listL + pokeArray mem_list mem_listL + pokeArray args_mem_loc args_mem_locL + err <- wrapError $ raw_clEnqueueNativeKernel user_func args cb_args (fromIntegral num_mem_objects) mem_list args_mem_loc (fromIntegral num_events_in_wait_list) event_wait_list event + if err == Nothing + then Right <$> peek event + else return $ Left . fromJust $ err + where num_events_in_wait_list = length event_wait_listL + num_mem_objects = length mem_listL + + + diff --git a/System/OpenCL/Raw/V10/MemoryObject.hs b/System/OpenCL/Raw/V10/MemoryObject.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/MemoryObject.hs @@ -0,0 +1,232 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +{-| Conforms to section 5.2 of the OpenCL 1.0 specification -} +module System.OpenCL.Raw.V10.MemoryObject + (clCreateBuffer + ,clCreateImage2D + ,clCreateImage3D + ,clRetainMemObject + ,clReleaseMemObject + ,clGetSupportedImageFormats + ,clGetMemObjectInfo + ,clGetImageInfo + ,clEnqueueReadBuffer + ,clEnqueueWriteBuffer + ,clEnqueueCopyBuffer + ,clEnqueueReadImage + ,clEnqueueWriteImage + ,clEnqueueCopyImage + ,clEnqueueCopyImageToBuffer + ,clEnqueueCopyBufferToImage + ,clEnqueueMapBuffer + ,clEnqueueMapImage + ,clEnqueueUnmapMemObject) +where + +import System.OpenCL.Raw.V10.Types +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Utils +import Foreign +import Control.Applicative +import Data.Maybe +import Data.Bits + + +foreign import ccall "clCreateBuffer" raw_clCreateBuffer :: Context -> CLbitfield -> CLsizei -> Ptr () -> Ptr CLint -> IO Mem +clCreateBuffer :: Context -> MemFlags -> CLsizei -> Ptr () -> IO (Either ErrorCode Mem) +clCreateBuffer ctx (MemFlags flags) size host_ptr = wrapErrorEither $ raw_clCreateBuffer ctx flags size host_ptr + +foreign import ccall "clCreateImage2D" raw_clCreateImage2D :: Context -> CLbitfield -> Ptr CLuint -> CLsizei -> CLsizei -> CLsizei -> Ptr () -> Ptr CLint -> IO Mem +clCreateImage2D :: Context -> MemFlags -> ImageFormat -> CLsizei -> CLsizei -> CLsizei -> Ptr () -> IO (Either ErrorCode Mem) +clCreateImage2D ctx (MemFlags memflags) (ChannelOrder corder, ChannelType ctype) image_width image_height image_row_pitch host_ptr = allocaArray 2 $ \image_format -> do + pokeArray image_format [corder,ctype] + wrapErrorEither $ raw_clCreateImage2D ctx memflags image_format image_width image_height image_row_pitch host_ptr + +foreign import ccall "clCreateImage3D" raw_clCreateImage3D :: Context -> CLbitfield -> Ptr CLuint -> CLsizei -> CLsizei -> CLsizei -> CLsizei -> CLsizei -> Ptr () -> Ptr CLint -> IO Mem +clCreateImage3D :: Context -> MemFlags -> ImageFormat -> CLsizei -> CLsizei -> CLsizei -> CLsizei -> CLsizei -> Ptr () -> IO (Either ErrorCode Mem) +clCreateImage3D ctx (MemFlags memflags) (ChannelOrder corder, ChannelType ctype) image_width image_height image_depth image_row_pitch image_slice_pitch host_ptr = allocaArray 2 $ \image_format -> do + pokeArray image_format [corder,ctype] + wrapErrorEither $ raw_clCreateImage3D ctx memflags image_format image_width image_height image_depth image_row_pitch image_slice_pitch host_ptr + +foreign import ccall "clRetainMemObject" raw_clRetainMemObject :: Mem -> IO CLint +clRetainMemObject :: Mem -> IO (Maybe ErrorCode) +clRetainMemObject mem = wrapError $ raw_clRetainMemObject mem + +foreign import ccall "clReleaseMemObject" raw_clReleaseMemObject :: Mem -> IO CLint +clReleaseMemObject :: Mem -> IO (Maybe ErrorCode) +clReleaseMemObject mem = wrapError $ raw_clReleaseMemObject mem + +foreign import ccall "clGetSupportedImageFormats" raw_clGetSupportedImageFormats :: Context -> CLbitfield -> CLuint -> CLuint -> Ptr CLuint -> Ptr CLuint -> IO CLint +clGetSupportedImageFormats :: Context -> MemFlags -> MemObjectType -> IO (Either ErrorCode [ImageFormat]) +clGetSupportedImageFormats ctx (MemFlags flags) (MemObjectType image_type) = allocaArray 512 $ \image_formats -> alloca $ \num_image_formats -> do + err <- wrapError $ raw_clGetSupportedImageFormats ctx flags image_type 512 image_formats num_image_formats + maybe (do num_image_formatsN <- peek num_image_formats + image_formatsN <- peekArray (fromIntegral num_image_formatsN*2) image_formats + let sift (a:b:cs) = (ChannelOrder a,ChannelType b) : sift cs + sift [] = [] + return . Right $ sift image_formatsN ) + (return . Left) + err + +foreign import ccall "clGetMemObjectInfo" raw_clGetMemObjectInfo :: Mem -> CLuint -> CLsizei -> Ptr () -> Ptr CLsizei -> IO CLint +clGetMemObjectInfo :: Mem -> MemInfo -> CLsizei -> IO (Either ErrorCode (ForeignPtr (), CLsizei)) +clGetMemObjectInfo mem (MemInfo param_name) param_value_size = wrapGetInfo (raw_clGetMemObjectInfo mem param_name) param_value_size + +foreign import ccall "clGetImageInfo" raw_clGetImageInfo :: Mem -> CLuint -> CLsizei -> Ptr () -> Ptr CLsizei -> IO CLint +clGetImageInfo :: Mem -> MemInfo -> CLsizei -> IO (Either ErrorCode (ForeignPtr (), CLsizei)) +clGetImageInfo mem (MemInfo param_name) param_value_size = wrapGetInfo (raw_clGetImageInfo mem param_name) param_value_size + +enqueue :: (CommandQueue -> CLuint -> Ptr Event -> Ptr Event -> IO CLint) -> CommandQueue -> [Event] -> IO (Either ErrorCode Event) +enqueue fn queue events = alloca $ \event -> allocaArray events_in_wait_list $ \event_wait_list -> do + pokeArray event_wait_list events + err <- wrapError $ fn queue (fromIntegral events_in_wait_list) event_wait_list event + if err == Nothing + then Right <$> peek event + else return (Left . fromJust $ err) + where events_in_wait_list = length events + + +foreign import ccall "clEnqueueReadBuffer" raw_clEnqueueReadBuffer :: CommandQueue -> Mem -> CLbool -> CLsizei -> CLsizei -> Ptr () -> CLuint -> Ptr Event -> Ptr Event -> IO CLint +clEnqueueReadBuffer buffer blocking_read offset cb ptr = + enqueue (\command_queue num_events_in_wait_list event_wait_list event -> + raw_clEnqueueReadBuffer + command_queue + buffer + (if blocking_read then clTrue else clFalse) + offset + cb + ptr + num_events_in_wait_list + event_wait_list + event) + + +foreign import ccall "clEnqueueWriteBuffer" raw_clEnqueueWriteBuffer :: CommandQueue -> Mem -> CLbool -> CLsizei -> CLsizei -> Ptr () -> CLuint -> Ptr Event -> Ptr Event -> IO CLint +clEnqueueWriteBuffer buffer blocking_write offset cb ptr = + enqueue (\command_queue num_events_in_wait_list event_wait_list event -> + raw_clEnqueueWriteBuffer command_queue buffer (if blocking_write then clTrue else clFalse) offset cb ptr num_events_in_wait_list event_wait_list event) + + +foreign import ccall "clEnqueueCopyBuffer" raw_clEnqueueCopyBuffer :: CommandQueue -> Mem -> Mem -> CLsizei -> CLsizei -> CLsizei -> CLuint -> Ptr Event -> Ptr Event -> IO CLint +clEnqueueCopyBuffer src_buffer dst_buffer src_offset dst_offset cb = + enqueue (\command_queue num_events_in_wait_list event_wait_list event -> + raw_clEnqueueCopyBuffer command_queue src_buffer dst_buffer src_offset dst_offset cb num_events_in_wait_list event_wait_list event) + +type ImageDims = (CLsizei,CLsizei,CLsizei) +foreign import ccall "clEnqueueReadImage" raw_clEnqueueReadImage :: CommandQueue -> Mem -> CLbool -> Ptr CLsizei -> Ptr CLsizei -> CLsizei -> CLsizei -> Ptr () -> CLuint -> Ptr Event -> Ptr Event -> IO CLint +clEnqueueReadImage image blocking_read (oa,ob,oc) (ra,rb,rc) row_pitch slice_pitch ptr = + enqueue (\command_queue num_events_in_wait_list event_wait_list event -> allocaArray 3 $ \origin -> allocaArray 3 $ \region -> do + pokeArray region [ra,rb,rc] + pokeArray origin [oa,ob,oc] + raw_clEnqueueReadImage command_queue image (if blocking_read then clTrue else clFalse) origin region row_pitch slice_pitch ptr num_events_in_wait_list event_wait_list event) + +foreign import ccall "clEnqueueWriteImage" raw_clEnqueueWriteImage :: CommandQueue -> Mem -> CLbool -> Ptr CLsizei -> Ptr CLsizei -> CLsizei -> CLsizei -> Ptr () -> CLuint -> Ptr Event -> Ptr Event -> IO CLint +clEnqueueWriteImage image blocking_read (oa,ob,oc) (ra,rb,rc) row_pitch slice_pitch ptr = + enqueue (\command_queue num_events_in_wait_list event_wait_list event -> allocaArray 3 $ \origin -> allocaArray 3 $ \region -> do + pokeArray region [ra,rb,rc] + pokeArray origin [oa,ob,oc] + raw_clEnqueueWriteImage command_queue image (if blocking_read then clTrue else clFalse) origin region row_pitch slice_pitch ptr num_events_in_wait_list event_wait_list event) + +foreign import ccall "clEnqueueCopyImage" raw_clEnqueueCopyImage :: CommandQueue -> Mem -> Mem -> Ptr CLsizei -> Ptr CLsizei -> Ptr CLsizei -> CLuint -> Ptr Event -> Ptr Event -> IO CLint +clEnqueueCopyImage :: Mem -> Mem -> ImageDims -> ImageDims -> ImageDims -> CommandQueue -> [Event] -> IO (Either ErrorCode Event) +clEnqueueCopyImage src_image dst_image (soa,sob,soc) (doa,dob,doc) (ra,rb,rc) = + enqueue (\command_queue num_events_in_wait_list event_wait_list event -> allocaArray 3 $ \src_origin -> allocaArray 3 $ \dst_origin -> allocaArray 3 $ \region -> do + pokeArray region [ra,rb,rc] + pokeArray src_origin [soa,sob,soc] + pokeArray dst_origin [doa,dob,doc] + raw_clEnqueueCopyImage command_queue src_image dst_image src_origin dst_origin region num_events_in_wait_list event_wait_list event) + + +foreign import ccall "clEnqueueCopyImageToBuffer" raw_clEnqueueCopyImageToBuffer :: CommandQueue -> Mem -> Mem -> Ptr CLsizei -> Ptr CLsizei -> CLsizei -> CLuint -> Ptr Event -> Ptr Event -> IO CLint +clEnqueueCopyImageToBuffer :: Mem -> Mem -> ImageDims -> ImageDims -> CLsizei -> CommandQueue -> [Event] -> IO (Either ErrorCode Event) +clEnqueueCopyImageToBuffer src_image dst_buffer (soa,sob,soc) (ra,rb,rc) dst_offset = + enqueue (\command_queue num_events_in_wait_list event_wait_list event -> allocaArray 3 $ \src_origin -> allocaArray 3 $ \region -> do + pokeArray region [ra,rb,rc] + pokeArray src_origin [soa,sob,soc] + raw_clEnqueueCopyImageToBuffer + command_queue + src_image + dst_buffer + src_origin + region + dst_offset + num_events_in_wait_list + event_wait_list + event) + + +foreign import ccall "clEnqueueCopyBufferToImage" raw_clEnqueueCopyBufferToImage :: CommandQueue -> Mem -> Mem -> CLsizei -> Ptr CLsizei -> Ptr CLsizei -> CLuint -> Ptr Event -> Ptr Event -> IO CLint +clEnqueueCopyBufferToImage :: Mem -> Mem -> CLsizei -> ImageDims -> ImageDims -> CommandQueue -> [Event] -> IO (Either ErrorCode Event) +clEnqueueCopyBufferToImage src_buffer dst_image src_offset (soa,sob,soc) (ra,rb,rc) = + enqueue (\command_queue num_events_in_wait_list event_wait_list event -> allocaArray 3 $ \dst_origin -> allocaArray 3 $ \region -> do + pokeArray region [ra,rb,rc] + pokeArray dst_origin [soa,sob,soc] + raw_clEnqueueCopyBufferToImage + command_queue + src_buffer + dst_image + src_offset + dst_origin + region + num_events_in_wait_list + event_wait_list + event) + + +foreign import ccall "clEnqueueMapBuffer" raw_clEnqueueMapBuffer :: CommandQueue -> Mem -> CLbool -> CLbitfield -> CLsizei -> CLsizei -> CLuint -> Ptr Event -> Ptr Event -> Ptr CLint -> IO (Ptr ()) +clEnqueueMapBuffer :: Mem -> Bool -> MapFlags -> CLsizei -> CLsizei -> CommandQueue -> [Event] -> IO (Either ErrorCode (Ptr (),Event)) +clEnqueueMapBuffer buffer blocking_map (MapFlags map_flags) offset cb command_queue events = + allocaArray num_events_in_wait_list $ \event_wait_list -> alloca $ \event -> do + ret <- wrapErrorEither $ raw_clEnqueueMapBuffer + command_queue + buffer + (if blocking_map then clTrue else clFalse) + map_flags + offset + cb + (fromIntegral num_events_in_wait_list) + event_wait_list + event + case ret of + Left err -> return (Left err) + Right ptr -> peek event >>= \event -> return $ Right (ptr,event) + where num_events_in_wait_list = length events + +foreign import ccall "clEnqueueMapImage" raw_clEnqueueMapImage :: CommandQueue -> Mem -> CLbool -> CLbitfield -> Ptr CLsizei -> Ptr CLsizei -> Ptr CLsizei -> Ptr CLsizei -> CLuint -> Ptr Event -> Ptr Event -> Ptr CLint -> IO (Ptr ()) +clEnqueueMapImage :: Mem -> Bool -> MapFlags -> ImageDims -> ImageDims -> CommandQueue -> [Event] -> IO (Either ErrorCode (Ptr (),CLsizei,CLsizei,Event)) +clEnqueueMapImage buffer blocking_map (MapFlags map_flags) (oa,ob,oc) (ra,rb,rc) command_queue events = + allocaArray num_events_in_wait_list $ \event_wait_list -> + alloca $ \event -> + allocaArray 3 $ \region -> + allocaArray 3 $ \origin -> + alloca $ \image_row_pitch -> + alloca $ \image_slice_pitch -> do + pokeArray origin [oa,ob,oc] + pokeArray region [ra,rb,rc] + ret <- wrapErrorEither $ raw_clEnqueueMapImage + command_queue + buffer + (if blocking_map then clTrue else clFalse) + map_flags + origin + region + image_row_pitch + image_slice_pitch + (fromIntegral num_events_in_wait_list) + event_wait_list + event + case ret of + Left err -> return (Left err) + Right ptr -> do + event' <- peek event + image_row_pitch' <- peek image_row_pitch + image_slice_pitch' <- peek image_slice_pitch + return $ Right (ptr,image_row_pitch',image_slice_pitch', event') + where num_events_in_wait_list = length events + + +foreign import ccall "clEnqueueUnmapMemObject" raw_clEnqueueUnmapMemObject :: CommandQueue -> Mem -> Ptr () -> CLuint -> Ptr Event -> Ptr Event -> IO CLint +clEnqueueUnmapMemObject mem mapped_ptr = enqueue + (\command_queue num_events_in_wait_list event_wait_list event -> + raw_clEnqueueUnmapMemObject command_queue mem mapped_ptr num_events_in_wait_list event_wait_list event) + + diff --git a/System/OpenCL/Raw/V10/OutOfOrder.hs b/System/OpenCL/Raw/V10/OutOfOrder.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/OutOfOrder.hs @@ -0,0 +1,36 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +{-| Conforms to section 5.8 of the OpenCL 1.0 specification -} +module System.OpenCL.Raw.V10.OutOfOrder + (clEnqueueMarker + ,clEnqueueWaitForEvents + ,clEnqueueBarrier) +where + +import System.OpenCL.Raw.V10.Types +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Utils +import Foreign +import Control.Applicative +import Data.Maybe + +foreign import ccall "clEnqueueMarker" raw_clEnqueueMarker :: CommandQueue -> Ptr Event -> IO CLint +clEnqueueMarker :: CommandQueue -> IO (Either ErrorCode Event) +clEnqueueMarker queue = alloca $ \eventP -> do + err <- wrapError $ raw_clEnqueueMarker queue eventP + if err == Nothing + then Right <$> peek eventP + else return $ Left . fromJust $ err + +foreign import ccall "clEnqueueWaitForEvents" raw_clEnqueueWaitForEvents :: CommandQueue -> CLuint -> Ptr Event -> IO CLint +clEnqueueWaitForEvents :: CommandQueue -> [Event] -> IO (Maybe ErrorCode) +clEnqueueWaitForEvents queue events = + allocaArray num_events $ \eventsP -> do + pokeArray eventsP events + wrapError $ raw_clEnqueueWaitForEvents queue (fromIntegral num_events) eventsP + where num_events = length events + +foreign import ccall "clEnqueueBarrier" raw_clEnqueueBarrier :: CommandQueue -> IO CLint +clEnqueueBarrier :: CommandQueue -> IO (Maybe ErrorCode) +clEnqueueBarrier queue = wrapError $ raw_clEnqueueBarrier queue + + diff --git a/System/OpenCL/Raw/V10/PlatformInfo.hs b/System/OpenCL/Raw/V10/PlatformInfo.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/PlatformInfo.hs @@ -0,0 +1,35 @@ +{-# LANGUAGE ForeignFunctionInterface, ScopedTypeVariables #-} +{-| Conforms to section 4.1 of the OpenCL 1.0 specification -} +module System.OpenCL.Raw.V10.PlatformInfo ( + clGetPlatformIDs + , clGetPlatformInfo + ) where + +import System.OpenCL.Raw.V10.Types +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Utils +import Foreign +import Foreign.C +import Control.Applicative +import Data.Maybe + + +foreign import ccall "clGetPlatformIDs" raw_clGetPlatformIDs :: CLuint -> Ptr PlatformID -> Ptr CLuint -> IO CLint + + +clGetPlatformIDs :: CLuint -> IO (Either ErrorCode [PlatformID]) +clGetPlatformIDs num_entries = alloca $ \(platforms::Ptr PlatformID) -> alloca $ \(num_platforms::Ptr CLuint) -> do + errcode <- ErrorCode <$> raw_clGetPlatformIDs (fromIntegral num_entries) platforms num_platforms + if errcode == clSuccess + then Right <$> (peek num_platforms >>= \num_platformsN -> peekArray (fromIntegral num_platformsN) platforms) + else return $ Left errcode + + +foreign import ccall "clGetPlatformInfo" raw_clGetPlatformInfo :: PlatformID -> CLuint -> CSize -> Ptr () -> Ptr CSize -> IO CLint + +clGetPlatformInfo :: PlatformID -> PlatformInfo -> CLsizei -> Ptr () -> IO (Either ErrorCode CLsizei) +clGetPlatformInfo mem (PlatformInfo param_name) param_value_size param_value = alloca $ \param_value_size_ret -> do + err <- wrapError $ raw_clGetPlatformInfo mem param_name param_value_size param_value param_value_size_ret + if err == Nothing + then peek param_value_size_ret >>= return . Right + else return . Left . fromJust $ err diff --git a/System/OpenCL/Raw/V10/ProgramObject.hs b/System/OpenCL/Raw/V10/ProgramObject.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/ProgramObject.hs @@ -0,0 +1,86 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +{-| Conforms to section 5.4 of the OpenCL 1.0 specification -} +module System.OpenCL.Raw.V10.ProgramObject + (clCreateProgramWithSource + ,clCreateProgramWithBinary + ,clRetainProgram + ,clReleaseProgram + ,clBuildProgram + ,clUnloadCompiler + ,clGetProgramInfo + ,clGetProgramBuildInfo) +where + +import Control.Monad.Cont +import System.OpenCL.Raw.V10.Types +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Utils +import Foreign +import Foreign.C +import Control.Applicative +import qualified Data.ByteString as SBS +import qualified Data.ByteString.Internal as SBS + +foreign import ccall "clCreateProgramWithSource" raw_clCreateProgramWithSource :: Context -> CLuint -> Ptr CString -> Ptr CLsizei -> Ptr CLint -> IO Program +clCreateProgramWithSource :: Context -> String -> IO (Either ErrorCode Program) +clCreateProgramWithSource ctx source_code = do + let count = length strings + strings = lines source_code + lengths = (fromIntegral . length) <$> strings + withArray lengths $ (\lengthsP -> + withCStringArray0 strings $ (\stringsP -> + wrapErrorEither $ raw_clCreateProgramWithSource ctx (fromIntegral count) stringsP lengthsP)) + +foreign import ccall "clCreateProgramWithBinary" raw_clCreateProgramWithBinary :: Context -> CLuint -> Ptr DeviceID -> Ptr CLsizei -> Ptr (Ptr Word8) -> Ptr CLint -> Ptr CLint -> IO Program +clCreateProgramWithBinary :: Context -> [(DeviceID,SBS.ByteString)] -> IO (Either ErrorCode Program) +clCreateProgramWithBinary context devbin_pair = + allocaArray num_devices $ \lengths -> + allocaArray num_devices $ \binaries -> + allocaArray num_devices $ \devices -> + alloca $ \binary_status -> + alloca $ \errcode_ret -> do + pokeArray lengths (map (fromIntegral . SBS.length) bins) + pokeArray devices device_list + pokeArray binaries ((unsafeForeignPtrToPtr . bsPtr) `map` bins) + program <- raw_clCreateProgramWithBinary context (fromIntegral num_devices) devices lengths binaries binary_status errcode_ret + errcode <- ErrorCode <$> peek errcode_ret + binstatus <- ErrorCode <$> peek binary_status + if errcode == clSuccess && binstatus == clSuccess + then return $ Right program + else return $ Left (if errcode == clSuccess then binstatus else errcode) + where bsPtr (SBS.PS p _ _) = p + num_devices = length device_list + (device_list,bins) = unzip devbin_pair + +foreign import ccall "clRetainProgram" raw_clRetainProgram :: Program -> IO CLint +clRetainProgram :: Program -> IO (Maybe ErrorCode) +clRetainProgram prog = wrapError $ raw_clRetainProgram prog + +foreign import ccall "clReleaseProgram" raw_clReleaseProgram :: Program -> IO CLint +clReleaseProgram :: Program -> IO (Maybe ErrorCode) +clReleaseProgram prog = wrapError $ raw_clReleaseProgram prog + +type BuildProgramCallback = Program -> Ptr () -> IO () +foreign import ccall "wrapper" wrapBuildProgramCallback :: BuildProgramCallback -> IO (FunPtr BuildProgramCallback) +foreign import ccall "clBuildProgram" raw_clBuildProgram :: Program -> CLuint -> Ptr DeviceID -> CString -> FunPtr BuildProgramCallback -> Ptr () -> IO CLint +clBuildProgram :: Program -> [DeviceID] -> String -> BuildProgramCallback -> Ptr () -> IO (Maybe ErrorCode) +clBuildProgram program devices ops pfn_notifyF user_data = + allocaArray num_devices $ \device_list -> + withCString ops $ \options -> do + pokeArray device_list devices + pfn_notify <- wrapBuildProgramCallback pfn_notifyF + wrapError $ raw_clBuildProgram program (fromIntegral num_devices) device_list options pfn_notify user_data + where num_devices = length devices + +foreign import ccall "clUnloadCompiler" raw_clUnloadCompiler :: IO CLint +clUnloadCompiler :: IO (Maybe ErrorCode) +clUnloadCompiler = wrapError $ raw_clUnloadCompiler + +foreign import ccall "clGetProgamInfo" raw_clGetProgramInfo :: Program -> CLuint -> CLsizei -> Ptr () -> Ptr CLsizei -> IO CLint +clGetProgramInfo :: Program -> ProgramInfo -> CLsizei -> IO (Either ErrorCode (ForeignPtr (), CLsizei)) +clGetProgramInfo program (ProgramInfo param_name) param_value_size = wrapGetInfo (raw_clGetProgramInfo program param_name) param_value_size + +foreign import ccall "clGetProgramBuildInfo" raw_clGetProgramBuildInfo :: Program -> CLuint -> CLsizei -> Ptr () -> Ptr CLsizei -> IO CLint +clGetProgramBuildInfo :: Program -> ProgramBuildInfo -> CLsizei -> IO (Either ErrorCode (ForeignPtr (), CLsizei)) +clGetProgramBuildInfo program (ProgramBuildInfo param_name) param_value_size = wrapGetInfo (raw_clGetProgramInfo program param_name) param_value_size + diff --git a/System/OpenCL/Raw/V10/Sampler.hs b/System/OpenCL/Raw/V10/Sampler.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/Sampler.hs @@ -0,0 +1,51 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +{-| Conforms to section 5.3 of the OpenCL 1.0 specification -} +module System.OpenCL.Raw.V10.Sampler + (clCreateSampler + ,clRetainSampler + ,clReleaseSampler + ,clGetSamplerInfo) +where + +import System.OpenCL.Raw.V10.Types +import System.OpenCL.Raw.V10.Errors +import System.OpenCL.Raw.V10.Utils +import Foreign +import Foreign.C +import Control.Applicative +import Data.Maybe + + + +foreign import ccall "clCreateSampler" raw_clCreateSampler :: Context -> CLbool -> CLuint -> CLuint -> Ptr CLint -> IO Sampler +clCreateSampler :: Context -> Bool -> AddressingMode -> FilterMode -> IO (Either ErrorCode Sampler) +clCreateSampler ctx normalized_coords (AddressingMode addressing_mode) (FilterMode filter_mode) = + wrapErrorEither $ raw_clCreateSampler ctx (if normalized_coords then clTrue else clFalse) addressing_mode filter_mode + +foreign import ccall "clRetainSampler" raw_clRetainSampler :: Sampler -> IO CLint +clRetainSampler :: Sampler -> IO (Maybe ErrorCode) +clRetainSampler sampler = wrapError $ raw_clRetainSampler sampler + +foreign import ccall "clReleaseSampler" raw_clReleaseSampler :: Sampler -> IO CLint +clReleaseSampler :: Sampler -> IO (Maybe ErrorCode) +clReleaseSampler sampler = wrapError $ raw_clReleaseSampler sampler + +foreign import ccall "clGetSamplerInfo" raw_clGetSamplerInfo :: Sampler -> CLuint -> CLsizei -> Ptr () -> Ptr CLsizei -> IO CLint +clGetSamplerInfo :: Sampler -> SamplerInfo -> CLsizei -> Ptr () -> IO (Either ErrorCode CLsizei) +clGetSamplerInfo mem (SamplerInfo param_name) param_value_size param_value = alloca $ \param_value_size_ret -> do + err <- wrapError $ raw_clGetSamplerInfo mem param_name param_value_size param_value param_value_size_ret + if err == Nothing + then peek param_value_size_ret >>= return . Right + else return . Left . fromJust $ err + + + + + + + + + + + + diff --git a/System/OpenCL/Raw/V10/Types.hs b/System/OpenCL/Raw/V10/Types.hs new file mode 100644 --- /dev/null +++ b/System/OpenCL/Raw/V10/Types.hs @@ -0,0 +1,592 @@ +{-| Declaration of types, bounds and constants for OpenCL 1.0 -} +module System.OpenCL.Raw.V10.Types where + +import Foreign.C.Types +import Foreign + +data PlatformIDc = PlatformIDc +data DeviceIDc = DeviceIDc +data Contextc = Contextc +data CommandQueuec = CommandQueuec +data Memc = Memc +data Programc = Programc +data Kernelc = Kernelc +data Eventc = Eventc +data Samplerc = Samplerc + +newtype ChannelOrder = ChannelOrder CLuint +newtype ChannelType = ChannelType CLuint +newtype DeviceType = DeviceType CLbitfield + +newtype ContextInfo = ContextInfo CLuint + +type ContextProperties = Ptr CLint +type PlatformID = Ptr PlatformIDc +type DeviceID = Ptr DeviceIDc +type Context = Ptr Contextc +type CommandQueue = Ptr CommandQueuec +type Mem = Ptr Memc +type Program = Ptr Programc +type Event = Ptr Eventc +type Sampler = Ptr Samplerc +type Kernel = Ptr Kernelc + +type CLsizei = CSize +type CLint = CInt +type CLuint = CUInt +type CLbool = CLuint +type CLulong = CULong +type CLbitfield = CLulong + +data ImageFormatc = ImageFormatc +type ImageFormatp = Ptr ImageFormat +type ImageFormat = (ChannelOrder,ChannelType) + +newtype CommandQueueProperties = CommandQueueProperties CLbitfield +newtype CommandQueueInfo = CommandQueueInfo CLuint +newtype ErrorCode = ErrorCode CLint deriving (Eq,Ord,Show,Read) +newtype EventInfo = EventInfo CLuint +newtype ProfilingInfo = ProfilingInfo CLuint +newtype KernelInfo = KernelInfo CLuint +newtype KernelWorkGroupInfo = KernelWorkGroupInfo CLuint +newtype MapFlags = MapFlags CLbitfield +newtype MemFlags = MemFlags CLbitfield +newtype MemObjectType = MemObjectType CLuint +newtype MemInfo = MemInfo CLuint +newtype ImageInfo = ImageInfo CLuint +newtype PlatformInfo = PlatformInfo CLuint +newtype SamplerInfo = SamplerInfo CLuint +newtype AddressingMode = AddressingMode CLuint +newtype FilterMode = FilterMode CLuint +newtype ProgramInfo = ProgramInfo CLuint +newtype ProgramBuildInfo = ProgramBuildInfo CLuint +newtype BuildStatus = BuildStatus CLint +newtype DeviceInfo = DeviceInfo CLuint +newtype DeviceFPConfig = DeviceFPConfig CLbitfield + +clQueueOutOfOrderExecModeEnable :: CommandQueueProperties +clQueueOutOfOrderExecModeEnable = CommandQueueProperties (1`shiftL`0) + +clQueueProfilingEnable :: CommandQueueProperties +clQueueProfilingEnable = CommandQueueProperties (1`shiftL`1) + +clQueueContext :: CommandQueueInfo +clQueueContext = CommandQueueInfo 0x1090 + +clQueueDevice :: CommandQueueInfo +clQueueDevice = CommandQueueInfo 0x1091 + +clQueueReferenceCount :: CommandQueueInfo +clQueueReferenceCount = CommandQueueInfo 0x1092 + +clQueueProperties :: CommandQueueInfo +clQueueProperties = CommandQueueInfo 0x1093 + +clDeviceType :: DeviceInfo +clDeviceType = DeviceInfo 0x1000 + +clDeviceVendorID :: DeviceInfo +clDeviceVendorID = DeviceInfo 0x1001 + +clDeviceMaxComputeUnits :: DeviceInfo +clDeviceMaxComputeUnits = DeviceInfo 0x1002 + +clDeviceMaxWorkItemDimensions :: DeviceInfo +clDeviceMaxWorkItemDimensions = DeviceInfo 0x1003 + +clDeviceMaxWorkGroupSize :: DeviceInfo +clDeviceMaxWorkGroupSize = DeviceInfo 0x1004 + +clDeviceMaxWorkItemSizes :: DeviceInfo +clDeviceMaxWorkItemSizes = DeviceInfo 0x1005 + +clDevicePreferredVectorWidthChar :: DeviceInfo +clDevicePreferredVectorWidthChar = DeviceInfo 0x1006 + +clDevicePreferredVectorWidthShort :: DeviceInfo +clDevicePreferredVectorWidthShort = DeviceInfo 0x1007 + +clDevicePreferredVectorWidthInt :: DeviceInfo +clDevicePreferredVectorWidthInt = DeviceInfo 0x1008 + +clDevicePreferredVectorWidthLong :: DeviceInfo +clDevicePreferredVectorWidthLong = DeviceInfo 0x1009 + +clDevicePreferredVectorWidthFloat :: DeviceInfo +clDevicePreferredVectorWidthFloat = DeviceInfo 0x100A + +clDevicePreferredVectorWidthDouble :: DeviceInfo +clDevicePreferredVectorWidthDouble = DeviceInfo 0x100B + +clDeviceMaxClockFrequency :: DeviceInfo +clDeviceMaxClockFrequency = DeviceInfo 0x100C + +clDeviceAddressBits :: DeviceInfo +clDeviceAddressBits = DeviceInfo 0x100D + +clDeviceMaxReadImageArgs :: DeviceInfo +clDeviceMaxReadImageArgs = DeviceInfo 0x100E + +clDeviceMaxWriteImageArgs :: DeviceInfo +clDeviceMaxWriteImageArgs = DeviceInfo 0x100F + +clDeviceMaxMemAllocSize :: DeviceInfo +clDeviceMaxMemAllocSize = DeviceInfo 0x1010 + +clDeviceImage2DMaxWidth :: DeviceInfo +clDeviceImage2DMaxWidth = DeviceInfo 0x1011 + +clDeviceImage2DMaxHeight :: DeviceInfo +clDeviceImage2DMaxHeight = DeviceInfo 0x1012 + +clDeviceImage3DMaxWidth :: DeviceInfo +clDeviceImage3DMaxWidth = DeviceInfo 0x1013 + +clDeviceImage3DMaxHeight :: DeviceInfo +clDeviceImage3DMaxHeight = DeviceInfo 0x1014 + +clDeviceImage3DMaxDepth :: DeviceInfo +clDeviceImage3DMaxDepth = DeviceInfo 0x1015 + +clDeviceImageSupport :: DeviceInfo +clDeviceImageSupport = DeviceInfo 0x1016 + +clDeviceMaxParameterSize :: DeviceInfo +clDeviceMaxParameterSize = DeviceInfo 0x1017 + +clDeviceMaxSamplers :: DeviceInfo +clDeviceMaxSamplers = DeviceInfo 0x1018 + +clDeviceMemBaseAddrAlign :: DeviceInfo +clDeviceMemBaseAddrAlign = DeviceInfo 0x1019 + +clDeviceMinDataTypeAlignSize :: DeviceInfo +clDeviceMinDataTypeAlignSize = DeviceInfo 0x101A + +clDeviceSingleFPConfig :: DeviceInfo +clDeviceSingleFPConfig = DeviceInfo 0x101B + +clDeviceGlobalMemCacheType :: DeviceInfo +clDeviceGlobalMemCacheType = DeviceInfo 0x101C + +clDeviceGlobalMemCacheLineSize :: DeviceInfo +clDeviceGlobalMemCacheLineSize = DeviceInfo 0x101D + +clDeviceGlobalMemCacheSize :: DeviceInfo +clDeviceGlobalMemCacheSize = DeviceInfo 0x101E + +clDeviceGlobalMemSize :: DeviceInfo +clDeviceGlobalMemSize = DeviceInfo 0x101F + +clDeviceMaxConstantBuffersize :: DeviceInfo +clDeviceMaxConstantBuffersize = DeviceInfo 0x1020 + +clDeviceMaxConstantArgs :: DeviceInfo +clDeviceMaxConstantArgs = DeviceInfo 0x1021 + +clDeviceMLocalMemType :: DeviceInfo +clDeviceMLocalMemType = DeviceInfo 0x1022 + +clDeviceLocalMemSize :: DeviceInfo +clDeviceLocalMemSize = DeviceInfo 0x1023 + +clDeviceErrorCorrectionSupport :: DeviceInfo +clDeviceErrorCorrectionSupport = DeviceInfo 0x1024 + +clDeviceProfilingTimerResolution :: DeviceInfo +clDeviceProfilingTimerResolution = DeviceInfo 0x1025 + +clDeviceEndianLittle :: DeviceInfo +clDeviceEndianLittle = DeviceInfo 0x1026 + +clDeviceAvailable :: DeviceInfo +clDeviceAvailable = DeviceInfo 0x1027 + +clDeviceCompilerAvailable :: DeviceInfo +clDeviceCompilerAvailable = DeviceInfo 0x1028 + +clDeviceExecutionCapabilities :: DeviceInfo +clDeviceExecutionCapabilities = DeviceInfo 0x1029 + +clDeviceQueueProperties :: DeviceInfo +clDeviceQueueProperties = DeviceInfo 0x102A + +clDeviceName :: DeviceInfo +clDeviceName = DeviceInfo 0x102B + +clDeviceVendor :: DeviceInfo +clDeviceVendor = DeviceInfo 0x102C + +clDriverVersion :: DeviceInfo +clDriverVersion = DeviceInfo 0x102D + +clDeviceProfile :: DeviceInfo +clDeviceProfile = DeviceInfo 0x102E + +clDeviceVersion :: DeviceInfo +clDeviceVersion = DeviceInfo 0x102F + +clDeviceExtensions :: DeviceInfo +clDeviceExtensions = DeviceInfo 0x1030 + +clDevicePlatform :: DeviceInfo +clDevicePlatform = DeviceInfo 0x1031 + + + +clFPDenorm :: DeviceFPConfig +clFPDenorm = DeviceFPConfig (1`shiftL`0) + +clFPInfNan :: DeviceFPConfig +clFPInfNan = DeviceFPConfig (1`shiftL`1) + +clFPRoundToNearest :: DeviceFPConfig +clFPRoundToNearest = DeviceFPConfig (1`shiftL`2) + +clFPRoundToZero :: DeviceFPConfig +clFPRoundToZero = DeviceFPConfig (1`shiftL`3) + +clFPRoundToInf :: DeviceFPConfig +clFPRoundToInf = DeviceFPConfig (1`shiftL`4) + +clFPFMA :: DeviceFPConfig +clFPFMA = DeviceFPConfig (1`shiftL`5) + + + +clEventCommandQueue :: EventInfo +clEventCommandQueue = EventInfo 0x11D0 + +clEventCommandType :: EventInfo +clEventCommandType = EventInfo 0x11D1 + +clEventReferenceCount :: EventInfo +clEventReferenceCount = EventInfo 0x11D2 + +clEventCommandExecutionStatus :: EventInfo +clEventCommandExecutionStatus = EventInfo 0x11D3 + + +clProfilingCommandQueued :: ProfilingInfo +clProfilingCommandQueued = ProfilingInfo 0x1280 + +clProfilingCommandSubmit :: ProfilingInfo +clProfilingCommandSubmit = ProfilingInfo 0x1281 + +clProfilingCommandStart :: ProfilingInfo +clProfilingCommandStart = ProfilingInfo 0x1282 + +clProfilingCommandEnd :: ProfilingInfo +clProfilingCommandEnd = ProfilingInfo 0x1283 + + +clFalse = 0 :: CLbool +clTrue = 1 :: CLbool + + +clDeviceTypeDefault :: DeviceType +clDeviceTypeDefault = DeviceType (1`shiftL`0) + +clDeviceTypeCPU :: DeviceType +clDeviceTypeCPU = DeviceType (1`shiftL`1) + +clDeviceTypeGPU :: DeviceType +clDeviceTypeGPU = DeviceType (1`shiftL`2) + +clDeviceTypeAccelerator :: DeviceType +clDeviceTypeAccelerator = DeviceType (1`shiftL`3) + +clDeviceTypeAll :: DeviceType +clDeviceTypeAll = DeviceType 0xFFFFFFFF + + +clContextReferenceCount :: ContextInfo +clContextReferenceCount = ContextInfo 0x1080 + +clContextDevices :: ContextInfo +clContextDevices = ContextInfo 0x1081 + +clContextProperties :: ContextInfo +clContextProperties = ContextInfo 0x1082 + +clContextPlatform = 0x1084 + + + +clKernelFunctionName :: KernelInfo +clKernelFunctionName = KernelInfo 0x1190 + +clKernelNumFlags :: KernelInfo +clKernelNumFlags = KernelInfo 0x1191 + +clKernelReferenceCount :: KernelInfo +clKernelReferenceCount = KernelInfo 0x1192 + +clKernelContext :: KernelInfo +clKernelContext = KernelInfo 0x1193 + +clKernelProgram :: KernelInfo +clKernelProgram = KernelInfo 0x1194 + + +clKernelWorkGroupSize :: KernelWorkGroupInfo +clKernelWorkGroupSize = KernelWorkGroupInfo 0x11B0 + +clKernelCompileWorkGroupSize :: KernelWorkGroupInfo +clKernelCompileWorkGroupSize = KernelWorkGroupInfo 0x11B1 + +clKernelLocalMemSize :: KernelWorkGroupInfo +clKernelLocalMemSize = KernelWorkGroupInfo 0x11B2 + + + +clMemReadWrite :: MemFlags +clMemReadWrite = MemFlags (1 `shiftL` 0) + +clMemWriteOnly :: MemFlags +clMemWriteOnly = MemFlags (1 `shiftL` 1) + +clMemReadOnly :: MemFlags +clMemReadOnly = MemFlags (1 `shiftL` 2) + +clMemUseHostPtr :: MemFlags +clMemUseHostPtr = MemFlags (1 `shiftL` 3) + +clMemAllocHostPtr :: MemFlags +clMemAllocHostPtr = MemFlags (1 `shiftL` 4) + +clMemCopyHostPtr :: MemFlags +clMemCopyHostPtr = MemFlags (1 `shiftL` 5) + + +clR :: ChannelOrder +clR = ChannelOrder 0x10B0 + +clA :: ChannelOrder +clA = ChannelOrder 0x10B1 + +clRG :: ChannelOrder +clRG = ChannelOrder 0x10B2 + +clRA :: ChannelOrder +clRA = ChannelOrder 0x10B3 + +clRGB :: ChannelOrder +clRGB = ChannelOrder 0x10B4 + +clRGBA :: ChannelOrder +clRGBA = ChannelOrder 0x10B5 + +clBGRA :: ChannelOrder +clBGRA = ChannelOrder 0x10B6 + +clARGB :: ChannelOrder +clARGB = ChannelOrder 0x10B7 + +clIntensity :: ChannelOrder +clIntensity = ChannelOrder 0x10B8 + +clLuminance :: ChannelOrder +clLuminance = ChannelOrder 0x10B9 + + +clSNormInt8 :: ChannelType +clSNormInt8 = ChannelType 0x10D0 + +clSNormInt16 :: ChannelType +clSNormInt16 = ChannelType 0x10D1 + +clUNormInt8 :: ChannelType +clUNormInt8 = ChannelType 0x10D2 + +clUNormInt16 :: ChannelType +clUNormInt16 = ChannelType 0x10D3 + +clUNormShort565 :: ChannelType +clUNormShort565 = ChannelType 0x10D4 + +clUNormShort555 :: ChannelType +clUNormShort555 = ChannelType 0x10D5 + +clUNormInt101010 :: ChannelType +clUNormInt101010 = ChannelType 0x10D6 + +clSignedInt8 :: ChannelType +clSignedInt8 = ChannelType 0x10D7 + +clSignedInt16 :: ChannelType +clSignedInt16 = ChannelType 0x10D8 + +clSignedInt32 :: ChannelType +clSignedInt32 = ChannelType 0x10D9 + +clUnsignedInt8 :: ChannelType +clUnsignedInt8 = ChannelType 0x10DA + +clUnsignedInt16 :: ChannelType +clUnsignedInt16 = ChannelType 0x10DB + +clUnsignedInt32 :: ChannelType +clUnsignedInt32 = ChannelType 0x10DC + +clHalfFloat :: ChannelType +clHalfFloat = ChannelType 0x10DD + +clFloat :: ChannelType +clFloat = ChannelType 0x10DE + + +clMemObjectBuffer :: MemObjectType +clMemObjectBuffer = MemObjectType 0x10F0 + +clMemObjectImage2D :: MemObjectType +clMemObjectImage2D = MemObjectType 0x10F1 + +clMemObjectImage3D :: MemObjectType +clMemObjectImage3D = MemObjectType 0x10F2 + + +clMemType :: MemInfo +clMemType = MemInfo 0x1100 + +clMemFlags :: MemInfo +clMemFlags = MemInfo 0x1101 + +clMemSize :: MemInfo +clMemSize = MemInfo 0x1102 + +clMemHostPtr :: MemInfo +clMemHostPtr = MemInfo 0x1103 + +clMemMapCount :: MemInfo +clMemMapCount = MemInfo 0x1104 + +clMemReferenceCount :: MemInfo +clMemReferenceCount = MemInfo 0x1105 + +clMemContext :: MemInfo +clMemContext = MemInfo 0x1106 + + +clImageFormat :: ImageInfo +clImageFormat = ImageInfo 0x1110 + +clImageElementSize :: ImageInfo +clImageElementSize = ImageInfo 0x1111 + +clImageRowPitch :: ImageInfo +clImageRowPitch = ImageInfo 0x1112 + +clImageSlicePitch :: ImageInfo +clImageSlicePitch = ImageInfo 0x1113 + +clImageWidth :: ImageInfo +clImageWidth = ImageInfo 0x1114 + +clImageHeight :: ImageInfo +clImageHeight = ImageInfo 0x1115 + +clImageDepth :: ImageInfo +clImageDepth = ImageInfo 0x1116 + + +clMapRead :: MapFlags +clMapRead = MapFlags (1 `shiftL` 0) + +clMapWrite :: MapFlags +clMapWrite = MapFlags (1 `shiftL` 1) + + +clPlatformProfile :: PlatformInfo +clPlatformProfile = PlatformInfo 0x0900 + +clPlatformVersion :: PlatformInfo +clPlatformVersion = PlatformInfo 0x0901 + +clPlatformName :: PlatformInfo +clPlatformName = PlatformInfo 0x0902 + +clPlatformVendor :: PlatformInfo +clPlatformVendor = PlatformInfo 0x0903 + + +clPlatformExtensions :: PlatformInfo +clPlatformExtensions = PlatformInfo 0x0904 + +clProgramReferenceCount :: ProgramInfo +clProgramReferenceCount = ProgramInfo 0x1160 + +clProgramContext :: ProgramInfo +clProgramContext = ProgramInfo 0x1161 + +clProgramNumDevices :: ProgramInfo +clProgramNumDevices = ProgramInfo 0x1162 + +clProgramDevices :: ProgramInfo +clProgramDevices = ProgramInfo 0x1163 + +clProgramSource :: ProgramInfo +clProgramSource = ProgramInfo 0x1164 + +clProgramBinarySizes :: ProgramInfo +clProgramBinarySizes = ProgramInfo 0x1165 + +clProgramBinaries :: ProgramInfo +clProgramBinaries = ProgramInfo 0x1166 + + +clProgramBuildStatus :: ProgramBuildInfo +clProgramBuildStatus = ProgramBuildInfo 0x1181 + +clProgramBuildOptions :: ProgramBuildInfo +clProgramBuildOptions = ProgramBuildInfo 0x1182 + +clProgramBuildLog :: ProgramBuildInfo +clProgramBuildLog = ProgramBuildInfo 0x1183 + + +clBuildSuccess :: BuildStatus +clBuildSuccess = BuildStatus 0 + +clBuildNone :: BuildStatus +clBuildNone = BuildStatus (-1) + +clBuildError :: BuildStatus +clBuildError = BuildStatus (-2) + +clBuildInProgress :: BuildStatus +clBuildInProgress = BuildStatus (-3) + + + +clAddressNone :: AddressingMode +clAddressNone = AddressingMode 0x1130 + +clAddressClampToEdge :: AddressingMode +clAddressClampToEdge = AddressingMode 0x1131 + +clAddressClamp :: AddressingMode +clAddressClamp = AddressingMode 0x1132 + +clAddressRepeat :: AddressingMode +clAddressRepeat = AddressingMode 0x1133 + +clFilterNearest = FilterMode 0x1140 +clFilterLinear = FilterMode 0x1141 + + +clSamplerReferenceCount :: SamplerInfo +clSamplerReferenceCount = SamplerInfo 0x1150 + +clSamplerContext :: SamplerInfo +clSamplerContext = SamplerInfo 0x1151 + +clSamplerNormalizedCoords :: SamplerInfo +clSamplerNormalizedCoords = SamplerInfo 0x1152 + +clSamplerAddressingMode :: SamplerInfo +clSamplerAddressingMode = SamplerInfo 0x1153 + +clSamplerFilterMode :: SamplerInfo +clSamplerFilterMode = SamplerInfo 0x1154 +