reduce.h

Go to the documentation of this file.

/* Copyright (c) 2014, 2015 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_REDUCE_H
#define CLOGS_REDUCE_H

#include <clogs/visibility_push.h>
#include <CL/cl.hpp>
#include <cstddef>
#include <clogs/visibility_pop.h>

#include <clogs/core.h>
#include <clogs/platform.h>
#include <clogs/tune.h>

namespace clogs
{

class ReduceProblem;

namespace detail
{
    class Reduce;
    class ReduceProblem;

    const ReduceProblem &getDetail(const clogs::ReduceProblem &);
} // namespace detail

class Reduce;

class CLOGS_API ReduceProblem
{
private:
    detail::ReduceProblem *detail_;
    friend const detail::ReduceProblem &detail::getDetail(const clogs::ReduceProblem &);

public:
    ReduceProblem();
    ~ReduceProblem();
    ReduceProblem(const ReduceProblem &);
    ReduceProblem &operator=(const ReduceProblem &);

    void setType(const Type &type);

    void setTunePolicy(const TunePolicy &tunePolicy);
};

class CLOGS_API Reduce : public Algorithm
{
private:
    detail::Reduce *getDetail() const;
    detail::Reduce *getDetailNonNull() const;
    void construct(
        cl_context context, cl_device_id device, const ReduceProblem &problem,
        cl_int &err, const char *&errStr);
    void moveAssign(Reduce &other);
    friend void swap(Reduce &, Reduce &);

protected:
    void enqueue(cl_command_queue commandQueue,
                 cl_mem inBuffer,
                 cl_mem outBuffer,
                 ::size_t first,
                 ::size_t elements,
                 ::size_t outPosition,
                 cl_uint numEvents,
                 const cl_event *events,
                 cl_event *event,
                 cl_int &err,
                 const char *&errStr);

    void enqueue(cl_command_queue commandQueue,
                 bool blocking,
                 cl_mem inBuffer,
                 void *out,
                 ::size_t first,
                 ::size_t elements,
                 cl_uint numEvents,
                 const cl_event *events,
                 cl_event *event,
                 cl_int &err,
                 const char *&errStr);

public:
    Reduce();

#ifdef CLOGS_HAVE_RVALUE_REFERENCES
    Reduce(Reduce &&other) CLOGS_NOEXCEPT
    {
        moveConstruct(other);
    }

    Reduce &operator=(Reduce &&other) CLOGS_NOEXCEPT
    {
        moveAssign(other);
        return *this;
    }
#endif

    Reduce(const cl::Context &context, const cl::Device &device, const ReduceProblem &problem)
    {
        int err;
        const char *errStr;
        construct(context(), device(), problem, err, errStr);
        detail::handleError(err, errStr);
    }

    Reduce(cl_context context, cl_device_id device, const ReduceProblem &problem)
    {
        int err;
        const char *errStr;
        construct(context, device, problem, err, errStr);
        detail::handleError(err, errStr);
    }

    ~Reduce(); 

    void enqueue(const cl::CommandQueue &commandQueue,
                 const cl::Buffer &inBuffer,
                 const cl::Buffer &outBuffer,
                 ::size_t first,
                 ::size_t elements,
                 ::size_t outPosition,
                 const VECTOR_CLASS<cl::Event> *events = NULL,
                 cl::Event *event = NULL)
    {
        cl_event outEvent;
        int err;
        const char *errStr;
        detail::UnwrapArray<cl::Event> rawEvents(events);
        enqueue(commandQueue(), inBuffer(), outBuffer(), first, elements, outPosition,
                rawEvents.size(), rawEvents.data(),
                event != NULL ? &outEvent : NULL,
                err, errStr);
        detail::handleError(err, errStr);
        if (event != NULL)
            *event = outEvent; // steals the reference
    }

    void enqueue(cl_command_queue commandQueue,
                 cl_mem inBuffer,
                 cl_mem outBuffer,
                 ::size_t first,
                 ::size_t elements,
                 ::size_t outPosition,
                 cl_uint numEvents = 0,
                 const cl_event *events = NULL,
                 cl_event *event = NULL)
    {
        cl_int err;
        const char *errStr;
        enqueue(commandQueue, inBuffer, outBuffer, first, elements, outPosition,
                numEvents, events, event, err, errStr);
        detail::handleError(err, errStr);
    }

    void enqueue(const cl::CommandQueue &commandQueue,
                 bool blocking,
                 const cl::Buffer &inBuffer,
                 void *out,
                 ::size_t first,
                 ::size_t elements,
                 const VECTOR_CLASS<cl::Event> *events = NULL,
                 cl::Event *event = NULL)
    {
        cl_event outEvent;
        cl_int err;
        const char *errStr;
        detail::UnwrapArray<cl::Event> rawEvents(events);
        enqueue(commandQueue(), blocking, inBuffer(), out, first, elements,
                rawEvents.size(), rawEvents.data(),
                event != NULL ? &outEvent : NULL,
                err, errStr);
        detail::handleError(err, errStr);
        if (event != NULL)
            *event = outEvent; // steals the reference
    }

    void enqueue(cl_command_queue commandQueue,
                 bool blocking,
                 cl_mem inBuffer,
                 void *out,
                 ::size_t first,
                 ::size_t elements,
                 cl_uint numEvents = 0,
                 const cl_event *events = NULL,
                 cl_event *event = NULL)
    {
        cl_int err;
        const char *errStr;
        enqueue(commandQueue, blocking, inBuffer, out, first, elements,
                numEvents, events, event, err, errStr);
        detail::handleError(err, errStr);
    }
};

void swap(Reduce &a, Reduce &b);

} // namespace clogs

#endif /* !CLOGS_REDUCE_H */