/home/diehl/git/hpxcl/opencl/kernel.hpp

// Copyright (c)    2013 Martin Stumpf
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#pragma once
#ifndef HPX_OPENCL_KERNEL_HPP_
#define HPX_OPENCL_KERNEL_HPP_

// Default includes
#include <hpx/hpx.hpp>
#include <hpx/config.hpp>

// Export definitions
#include "export_definitions.hpp"

// Forward Declarations
#include "fwd_declarations.hpp"

// OpenCL Headers
#include "cl_headers.hpp"

// Crazy function overloading
#include "util/enqueue_overloads.hpp"


namespace hpx {
namespace opencl { 

    template <std::size_t DIM>
    struct work_size
    {
        private:
        struct dimension
        {
            std::size_t offset;
            std::size_t size;
            std::size_t local_size;
            dimension(){
                offset = 0;
                size = 0;
                local_size = 0;
            }
        };
        private:
            // local_size be treated as NULL if all dimensions have local_size == 0
            dimension dims[DIM];
        public:
            dimension& operator[](std::size_t idx){ return dims[idx]; }
    };

    class HPX_OPENCL_EXPORT kernel
      : public hpx::components::client_base<kernel, server::kernel>
    {
    
        typedef hpx::components::client_base<kernel, server::kernel> base_type;

        public:
            // Empty constructor, necessary for hpx purposes
            kernel(){}

            // Constructor
            kernel(hpx::shared_future<hpx::naming::id_type> const& gid,
                    hpx::naming::id_type device_gid_)
              : base_type(gid), device_gid(std::move(device_gid_))
            {}
            
            // initialization
            

            // ///////////////////////////////////////////////
            // Exposed Component functionality
            // 

            hpx::lcos::future<void>
            set_arg_async(cl_uint arg_index, const hpx::opencl::buffer &arg) const;

            void
            set_arg(cl_uint arg_index, const hpx::opencl::buffer &arg) const;

            template<std::size_t DIM, typename ...Deps>
            hpx::lcos::future<void>
            enqueue( hpx::opencl::work_size<DIM> size,
                     Deps &&... dependencies ) const;

            hpx::lcos::future<void>
            enqueue_impl( std::vector<std::size_t> && size_vec,
                          hpx::opencl::util::resolved_events && deps ) const;

 
        private:
            hpx::naming::id_type device_gid;

        private:
            // serialization support
            friend class hpx::serialization::access;

            template <typename Archive>
            void serialize(Archive & ar, unsigned)
            {
                ar & hpx::serialization::base_object<base_type>(*this);
                ar & device_gid;
            }

    };

}}


// IMPLEMENTATIONS
//
template<std::size_t DIM, typename ...Deps>
hpx::future<void>
hpx::opencl::kernel::enqueue( hpx::opencl::work_size<DIM> size,
                             Deps &&... dependencies ) const
{
    // combine dependency futures in one std::vector
    using hpx::opencl::util::enqueue_overloads::resolver;
    auto deps = resolver(std::forward<Deps>(dependencies)...);
    HPX_ASSERT(deps.are_from_device(device_gid));
 
    // extract information from work_size struct
    std::vector<std::size_t> size_vec(3*DIM);
    for(std::size_t i = 0; i < DIM; i++){
        size_vec[i + 0*DIM] = size[i].offset;
        size_vec[i + 1*DIM] = size[i].size;
        size_vec[i + 2*DIM] = size[i].local_size;
    }

    // forward to enqueue_impl
    return enqueue_impl( std::move(size_vec), std::move(deps) );

} 

#endif