[Compute] Hi-level OpenCL

Judging from the flat API, the necessary classes are more or less the following:

1. CommandQueue
2. ComputeContext
3. Device
4. Event
5. Kernel
6. Memory
7. Platform
8. Profiler
9. Program
10. Sampler

plus any other helper class we might need.

It might be a good idea to have an abstract ComputeResource class that will act as the foundation of all Compute classes. Something like this:

    public abstract class ComputeResource : IDisposable
    {
        #region Fields
 
        IntPtr handle;
        bool disposed;
 
        #endregion
 
        #region Protected Members
 
        protected IntPtr Handle { get { return handle; } set { handle = value; } }
 
        protected bool Disposed { get { return disposed; } set { disposed = value; } }
 
        #endregion
 
        #region IDisposable Members
 
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
 
        protected abstract void Dispose(bool manual);
 
        ~ComputeResource()
        {
            Dispose(false);
        }
 
        #endregion
    }

Inheriting classes should set the Handle property and override Dispose(bool). For example:

    public sealed class CommandQueue : ComputeResource
    {
        #region Constructors
 
        public CommandQueue(ComputeContext context, Device device, CL10.CommandQueueFlags properties)
        {
            CL10.ErrorCode error_code;
            Handle = CL10.CL.CreateCommandQueue(context.Handle, device.Handle, properties, out error_code);
            if (error_code != CL10.ErrorCode.Success)
                throw new Exception(error_code.ToString());    // Todo: Create exception types.
        }
 
        #endregion
 
        #region IDisposable
 
        protected override Dispose(bool manual)
        {
            if (!Disposed)
            {
                 if (manual)
                     // dispose resource
                 else
                     // log disposal failure, if resource can't be disposed from a different thread
             }
        }
 
        #endregion
    }

One question is whether we should expose CL10 enums directly to the user. The reason is that OpenCL 1.1 will be released at some future time (potentially soon). Ideally, the high-level classes will act as an abstraction and will work with both OpenCL 1.0 and 1.1. Thoughts?

Edit: added Dispose override to CommandQueue example.

Naming might change (prepending Compute...) so that we don't mix with other devices and events but yes, that list makes up the core of CL.
++

If not than we need a cross-version enums layer too...
Let's ignore that until we have more concrete information on the evolution model. If necessary, this will be relatively easy to refactor.

[Error checking]
Parameters should be always validated for correctness and errors should be caught and converted to exceptions. It's probably best to have a helper class do the conversion, instead of sprinkling every method with if (error != 0) throw new Compute*Exception().

[Callbacks]
Callbacks are mapped to delegates and can be called from unmanaged code asynchronously. The only requirements are that:

1. The signatures and calling convention match what the unmanaged code expects.
2. No exceptions are generated inside the delegate implementation.

For example, void (*pfn_notify)(const char *, const void *, size_t, void *) would map to:

[UnmanagedFunctionPointer(CallingConvention=CallingConvention.Cdecl)]
public delegate void NotifyFunction(string errorInfo, IntPtr privateData, IntPtr countBytes, IntPtr userData);

(Disclaimer: untested code, I *think* this correct)

It might be possible to provide something better than raw IntPtr parameters, but this remains to be determined.

[Managing resources]
I was reading a recent comment on SlimDX (C++/CLI DirectX wrappers), which face a similar design issue with COM objects which are reference counted. IIRC, their solution was to avoid reference counting and rely on the .Net GC and the IDisposable pattern completely.

We can follow a similar approach: place a call to the Retain*() method in the object constructor and the Release*() method in the Dispose(bool) method. The user then simply needs to call Dispose() when done with an object, while the GC will take care of dead references automatically (in the latter case, we can either log an error or have the finalizer call the Release*() method - depending on whether Release*() calls are thread-safe.)

I'm not too keen on the ComputeContext acting as a factory. I was playing with such a design for OpenGL object the past few months, but ultimately scrapped it in favor of explicit constructors. For example:

using (var device = new ComputeDevice(...));
using (var context = new ComputeContext(device, ...));
using (var queue = new ComputeQueue(context, device, ...));
{
    ...
}

The advantage is that you avoid the explosion of factory methods inside the ComputeContext class - every class is now responsible for constructing itself. The ComputeContext can still keep track of allocated objects if desired, but I don't think this will be necessary.

I know it's been some time since my last post. So I wanted to drop a line about me being alive and my progress.
A couple of issues I've had so far are slowly being ironed out. I hope to lay down an alpha version in 10-15 days. If everything goes well, that is.
The interface is about 90% done. Implementation itself 70%.
Cheers.

Actually there is something I could use some help with. I'm investigating the possibility of reducing the amount of unsafe code. It's all over the place with 50% of it being redundant. Consider the following:

internal unsafe delegate int CLGetInfo<ParamType>( 
    IntPtr handle, 
    long paramName, 
    IntPtr paramValueSize, 
    ParamType paramValue, 
    IntPtr* paramValueSizeRet );
 
internal static ParamType GetStructInfo<ParamType>( 
    ComputeObject computeObject,
    long paramName,
    CLGetInfo<ParamType> clGetInfo ) where ParamType: struct
{
    ParamType result = new ParamType();
    int error = 0;
    unsafe
    { 
        error = clGetInfo( 
            computeObject.Handle, 
            paramName, 
            new IntPtr( Marshal.SizeOf( typeof( ParamType ) ) ), 
            result, 
            ( IntPtr* )null ); 
    }
    ComputeTools.CheckError( error );
    return result;
}

What I'm trying to do here is have a method which takes a couple of parameters and a delegate and then makes the appropriate CL call. For instance: every OpenCL object has some kind of cl_int clGet*ObjectNameHere*Info(...) with the same parameter types. This makes up a set of methods which can be handled the same. In this case instead of calling clGetInfo with fish and chips around, I'd call its "general method" which would take care of everything. Were it possible to handle classes of methods instead of separate CL calls themselves the whole thing would be less error prone and more easily maintainable.
Two things preventing me from implementing the above:
1) clGetInfos differ due to different enum types. Very ironic since dedicated enums are there as helpers. If it was all long that'd be great. Such as the paramName type in the delegate above. Other workarounds I've tried such as adding another type to the delegate's generic push me on the thin ice part of my knowledge.
2) I don't know how to pass around a method which has overloads. How do I choose between them?
Do I make sense?

Edit: How are the bindings generated? One size fits all (GL,ES,AL,CL) generator?