radixsort.h

Go to the documentation of this file.

/* Copyright (c) 2012 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_RADIXSORT_H
#define CLOGS_RADIXSORT_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 RadixsortProblem;

namespace detail
{
    class Radixsort;
    class RadixsortProblem;

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

class Radixsort;

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

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

    void setKeyType(const Type &keyType);

    void setValueType(const Type &valueType);

    void setTunePolicy(const TunePolicy &tunePolicy);
};

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

protected:
    void enqueue(cl_command_queue command_queue,
                 cl_mem keys, cl_mem values,
                 ::size_t elements, unsigned int maxBits,
                 cl_uint numEvents,
                 const cl_event *events,
                 cl_event *event,
                 cl_int &err,
                 const char *&errStr);

    void setTemporaryBuffers(cl_mem keys, cl_mem values,
                             cl_int &err, const char *&errStr);

public:
    Radixsort();

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

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

    Radixsort(const cl::Context &context, const cl::Device &device,
              const Type &keyType, const Type &valueType = Type())
    {
        cl_int err;
        const char *errStr;
        RadixsortProblem problem;
        problem.setKeyType(keyType);
        problem.setValueType(valueType);
        construct(context(), device(), problem, err, errStr);
        detail::handleError(err, errStr);
    }

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

    ~Radixsort(); 

    void enqueue(const cl::CommandQueue &commandQueue,
                 const cl::Buffer &keys, const cl::Buffer &values,
                 ::size_t elements, unsigned int maxBits = 0,
                 const VECTOR_CLASS<cl::Event> *events = NULL,
                 cl::Event *event = NULL)
    {
        cl_int err;
        const char *errStr;
        detail::UnwrapArray<cl::Event> events_(events);
        cl_event outEvent;
        enqueue(commandQueue(), keys(), values(), elements, maxBits,
                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 keys, cl_mem values,
                 ::size_t elements, unsigned int maxBits = 0,
                 cl_uint numEvents = 0,
                 const cl_event *events = NULL,
                 cl_event *event = NULL)
    {
        cl_int err;
        const char *errStr;
        enqueue(commandQueue, keys, values, elements, maxBits, numEvents, events, event,
                err, errStr);
        detail::handleError(err, errStr);
    }

    void setTemporaryBuffers(const cl::Buffer &keys, const cl::Buffer &values)
    {
        cl_int err;
        const char *errStr;
        setTemporaryBuffers(keys(), values(), err, errStr);
        detail::handleError(err, errStr);
    }

    void setTemporaryBuffers(cl_mem keys, cl_mem values)
    {
        cl_int err;
        const char *errStr;
        setTemporaryBuffers(keys, values, err, errStr);
        detail::handleError(err, errStr);
    }
};

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

} // namespace clogs

#endif /* !CLOGS_RADIXSORT_H */