scan.h

Go to the documentation of this file.

/* Copyright (c) 2012, 2014 University of Cape Town
 * 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_SCAN_H
#define CLOGS_SCAN_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 ScanProblem;

namespace detail
{
    class ScanProblem;
    class Scan;

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

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

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

    void setType(const Type &type);

    void setTunePolicy(const TunePolicy &tunePolicy);
};

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

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


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

    void moveAssign(Scan &other);

public:
    Scan();

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

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

    Scan(const cl::Context &context, const cl::Device &device, const Type &type)
    {
        cl_int err;
        const char *errStr;
        ScanProblem problem;
        problem.setType(type);
        construct(context(), device(), problem, err, errStr);
        detail::handleError(err, errStr);
    }

    Scan(const cl::Context &context, const cl::Device &device, const ScanProblem &problem)
    {
        cl_int err;
        const char *errStr;
        construct(context(), device(), problem, err, errStr);
        detail::handleError(err, errStr);
    }

    ~Scan(); 

    void enqueue(const cl::CommandQueue &commandQueue,
                 const cl::Buffer &buffer,
                 ::size_t elements,
                 const void *offset = NULL,
                 const VECTOR_CLASS<cl::Event> *events = NULL,
                 cl::Event *event = NULL)
    {
        enqueue(commandQueue, buffer, buffer, elements, offset, events, event);
    }

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

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

    void enqueue(const cl::CommandQueue &commandQueue,
                 const cl::Buffer &buffer,
                 ::size_t elements,
                 const cl::Buffer &offsetBuffer,
                 cl_uint offsetIndex,
                 const VECTOR_CLASS<cl::Event> *events = NULL,
                 cl::Event *event = NULL)
    {
        enqueue(commandQueue, buffer, buffer, elements, offsetBuffer, offsetIndex, events, event);
    }

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

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

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

} // namespace clogs

#endif /* !CLOGS_SCAN_H */