core.h

Go to the documentation of this file.

/* Copyright (c) 2012-2013 University of Cape Town
 * Copyright (c) 2014, Bruce Merry
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), 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:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * 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
 * AUTHORS 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.
 */

#ifndef CLOGS_CORE_H
#define CLOGS_CORE_H

#include <clogs/visibility_push.h>
#include <CL/cl.hpp>
#include <stdexcept>
#include <string>
#include <vector>
#include <clogs/visibility_pop.h>
#include <clogs/platform.h>

namespace clogs
{

#define CLOGS_VERSION_MAJOR 1
#define CLOGS_VERSION_MINOR 5

class CLOGS_API InternalError : public std::runtime_error
{
public:
    InternalError(const std::string &msg);
};

class CLOGS_API CacheError : public InternalError
{
public:
    CacheError(const std::string &msg);
};

class CLOGS_API TuneError : public InternalError
{
public:
    TuneError(const std::string &msg);
};


#ifdef __CL_ENABLE_EXCEPTIONS
typedef cl::Error Error;
#else
class CLOGS_LOCAL Error
{
private:
    cl_int err_;
    const char *errStr_;

public:
    explicit Error(cl_int err, const char *errStr = NULL) : err_(err), errStr_(errStr)
    {
    }

    virtual const char *what() const
    {
        return errStr_ != NULL ? errStr_ : "";
    }

    cl_int err() const
    {
        return err_;
    }
};
#endif // !__CL_ENABLE_EXCEPTIONS

enum CLOGS_API BaseType
{
    TYPE_VOID,
    TYPE_UCHAR,
    TYPE_CHAR,
    TYPE_USHORT,
    TYPE_SHORT,
    TYPE_UINT,
    TYPE_INT,
    TYPE_ULONG,
    TYPE_LONG,
    TYPE_HALF,
    TYPE_FLOAT,
    TYPE_DOUBLE
};

class CLOGS_API Type
{
private:
    BaseType baseType;    
    unsigned int length;  

public:
    Type();
    Type(BaseType baseType, unsigned int length = 1);

    bool isStorable(const cl::Device &device) const;

    bool isComputable(const cl::Device &device) const;
    bool isIntegral() const;       
    bool isSigned() const;         
    std::string getName() const;   
    ::size_t getSize() const;      
    ::size_t getBaseSize() const;  

    BaseType getBaseType() const;
    unsigned int getLength() const;

    static std::vector<Type> allTypes();
};

namespace detail
{

static inline void handleError(cl_int err, const char *errStr)
{
    if (err != CL_SUCCESS)
        throw Error(err, errStr);
}

template<typename T, bool Thin = sizeof(T) == sizeof(typename T::cl_type)>
class UnwrapArray
{
};

template<typename T>
class UnwrapArray<T, false>
{
private:
    std::vector<typename T::cl_type> raw;

public:
    explicit UnwrapArray(const VECTOR_CLASS<T> *in)
    {
        if (in != NULL)
        {
            raw.reserve(in->size());
            for (std::size_t i = 0; i < in->size(); i++)
                raw.push_back((*in)[i]());
        }
    }

    cl_uint size() const { return raw.size(); }
    const typename T::cl_type *data() const { return raw.empty() ? NULL : &raw[0]; }
};

template<typename T>
class UnwrapArray<T, true>
{
private:
    const typename T::cl_type *data_;
    std::size_t size_;

public:
    explicit UnwrapArray(const VECTOR_CLASS<T> *in)
    {
        if (in != NULL && !in->empty())
        {
            data_ = reinterpret_cast<const typename T::cl_type *>(&(*in)[0]);
            size_ = in->size();
        }
        else
        {
            data_ = NULL;
            size_ = 0;
        }
    }

    cl_uint size() const { return size_; }
    const typename T::cl_type *data() const { return data_; }
};

struct CLOGS_LOCAL CallbackWrapper
{
    void (CL_CALLBACK *callback)(const cl::Event &, void *);
    void (CL_CALLBACK *free)(void *);
    void *userData;
};

static inline void CL_CALLBACK callbackWrapperCall(cl_event event, void *userData)
{
    CallbackWrapper *wrapper = reinterpret_cast<CallbackWrapper *>(userData);
    clRetainEvent(event); // because cl::Event constructor steals a ref
    wrapper->callback(cl::Event(event), wrapper->userData);
}

static inline void CL_CALLBACK callbackWrapperFree(void *userData)
{
    CallbackWrapper *wrapper = reinterpret_cast<CallbackWrapper *>(userData);
    if (wrapper->free)
        wrapper->free(wrapper->userData);
    delete wrapper;
}

static inline CallbackWrapper *makeCallbackWrapper(
    void (CL_CALLBACK *callback)(const cl::Event &, void *),
    void *userData,
    void (CL_CALLBACK *free)(void *))
{
    CallbackWrapper *wrapper = new CallbackWrapper();
    wrapper->callback = callback;
    wrapper->userData = userData;
    wrapper->free = free;
    return wrapper;
}

template<typename T>
static inline void CL_CALLBACK genericCallbackCall(cl_event event, void *userData)
{
    T *self = reinterpret_cast<T *>(userData);
    clRetainEvent(event); // because cl::Event constructor steals a ref
    (*self)(cl::Event(event));
}

template<typename T>
static inline void CL_CALLBACK genericCallbackFree(void *userData)
{
    T *self = reinterpret_cast<T *>(userData);
    delete self;
}

class Algorithm;

} // namespace detail

class CLOGS_API Algorithm
{
private:
    detail::Algorithm *detail_;

    /* Prevent copying */
    Algorithm(const Algorithm &) CLOGS_DELETE_FUNCTION;
    Algorithm &operator=(const Algorithm &) CLOGS_DELETE_FUNCTION;

protected:
    Algorithm();
    ~Algorithm();

    void moveConstruct(Algorithm &other);
    detail::Algorithm *moveAssign(Algorithm &other);
    void swap(Algorithm &other);

    detail::Algorithm *getDetail() const;
    detail::Algorithm *getDetailNonNull() const;
    void setDetail(detail::Algorithm *ptr);

public:
    void setEventCallback(
        void (CL_CALLBACK *callback)(const cl::Event &, void *),
        void *userData,
        void (CL_CALLBACK *free)(void *) = NULL)
    {
        setEventCallback(
            detail::callbackWrapperCall,
            detail::makeCallbackWrapper(callback, userData, free),
            detail::callbackWrapperFree);
    }

    template<typename T>
    void setEventCallback(const T &callback)
    {
        setEventCallback(
            detail::genericCallbackCall<T>,
            new T(callback),
            detail::genericCallbackFree<T>);
    }

    void setEventCallback(
        void (CL_CALLBACK *callback)(cl_event, void *),
        void *userData,
        void (CL_CALLBACK *free)(void *) = NULL);
};

} // namespace clogs

#endif /* !CLOGS_CORE_H */