/home/diehl/git/hpxcl/cuda/program.hpp

// Copyright (c)                2013 Damond Howard
//                                              2015 Patrick Diehl
// 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_CUDA_PROGRAM_HPP_
#define HPX_CUDA_PROGRAM_HPP_

#include <hpx/include/components.hpp>
#include "cuda/server/program.hpp"
#include "cuda/buffer.hpp"

namespace hpx {
namespace cuda {

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

public:

        program() {
        }

        program(hpx::future<hpx::naming::id_type> && gid) :
                        base_type(std::move(gid)) {
        }

        hpx::lcos::future<void> build(std::vector<std::string> compilerFlags,
                        std::vector<std::string> modulenames, unsigned int debug = 0) {
                HPX_ASSERT(this->get_gid());
                typedef server::program::build_action action_type;
                return hpx::async<action_type>(this->get_gid(), compilerFlags,
                                modulenames, debug);
        }

        void build_sync(std::vector<std::string> compilerFlags,
                        std::string modulename, unsigned int debug = 0) {
                std::vector<std::string> modulenames;
                modulenames.push_back(modulename);
                build(compilerFlags, modulenames, debug).get();
        }

        hpx::lcos::future<void> build(std::vector<std::string> compilerFlags,
                        std::string modulename, unsigned int debug = 0) {
                HPX_ASSERT(this->get_gid());
                std::vector<std::string> modulenames;
                modulenames.push_back(modulename);
                typedef server::program::build_action action_type;
                return hpx::async<action_type>(this->get_gid(), compilerFlags,
                                modulenames, debug);
        }

        void build_sync(std::vector<std::string> compilerFlags,
                        std::vector<std::string> modulenames, unsigned int debug = 0) {
                build(compilerFlags, modulenames, debug).get();
        }

        void set_source_sync(std::string source) {
                HPX_ASSERT(this->get_gid());
                typedef server::program::set_source_action action_type;
                hpx::async<action_type>(this->get_gid(), source).get();
        }

        hpx::lcos::future<void> run(std::vector<hpx::cuda::buffer> args,
                        std::string modulename, hpx::cuda::server::program::Dim3 grid,
                        hpx::cuda::server::program::Dim3 block, int stream = -1) {

                HPX_ASSERT(this->get_gid());

                std::vector<hpx::naming::id_type> args_id;

                for (unsigned int i = 0; i < args.size(); i++) {

                        args_id.push_back(args[i].get_id());
                }

                std::vector<hpx::naming::id_type> dependencies;

                typedef server::program::run_action action_type;
                return hpx::async<action_type>(this->get_gid(), args_id, modulename,
                                grid, block, dependencies, stream);

        }

        hpx::lcos::future<void> run(std::vector<hpx::cuda::buffer> args,
                        std::string modulename, hpx::cuda::server::program::Dim3 grid,
                        hpx::cuda::server::program::Dim3 block,
                        std::vector<hpx::cuda::buffer> dependencies, int stream = -1) {

                HPX_ASSERT(this->get_gid());

                std::vector<hpx::naming::id_type> args_id;

                for (unsigned int i = 0; i < args.size(); i++) {

                        args_id.push_back(args[i].get_id());
                }

                std::vector<hpx::naming::id_type> dependencies_id;

                for (unsigned int i = 0; i < dependencies.size(); i++) {

                        dependencies_id.push_back(dependencies[i].get_id());
                }

                typedef server::program::run_action action_type;
                return hpx::async<action_type>(this->get_gid(), args_id, modulename,
                                grid, block, dependencies_id, stream);

        }

        hpx::lcos::future<void> run(std::vector<hpx::cuda::buffer> args,
                        std::string modulename, hpx::cuda::server::program::Dim3 grid,
                        hpx::cuda::server::program::Dim3 block,
                        hpx::cuda::buffer dependency, int stream = -1) {

                HPX_ASSERT(this->get_gid());

                std::vector<hpx::naming::id_type> args_id;

                for (unsigned int i = 0; i < args.size(); i++) {

                        args_id.push_back(args[i].get_id());
                }

                std::vector<hpx::naming::id_type> dependencies_id;
                dependencies_id.push_back(dependency.get_id());

                typedef server::program::run_action action_type;
                return hpx::async<action_type>(this->get_gid(), args_id, modulename,
                                grid, block, dependencies_id, stream);

        }

        hpx::lcos::future<unsigned int> get_streams_size() {
                HPX_ASSERT(this->get_gid());
                typedef server::program::get_streams_size_action action_type;
                return hpx::async<action_type>(this->get_gid());

        }

        hpx::lcos::future<unsigned int> create_stream() {
                HPX_ASSERT(this->get_gid());
                typedef server::program::create_stream_action action_type;
                return hpx::async<action_type>(this->get_gid());
        }

};
}
}
#endif //PROGRAM_1_HPP