engine.hpp

// Copyright (c) 2017-2018 Intel Corporation
// 
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// 
//      http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#pragma once
#include <memory>
#include <exception>
#include <typeinfo>
#include <vector>
#include <type_traits>
#include <chrono>
#include <map>
#include <cassert>

namespace iclgpu
{
class primitive_db;

template <class T, class U>
auto down_pointer_cast(const std::shared_ptr<U>& r)
-> typename std::enable_if<std::is_base_of<U, T>::value && !std::is_same<U, T>::value, std::shared_ptr<T>>::type
{
    auto res = std::dynamic_pointer_cast<T>(r);
    if (!res)
        throw std::bad_cast();
    return res;
}

template <class T, class U>
auto down_pointer_cast(const std::shared_ptr<U>& r)
-> typename std::enable_if<std::is_same<T, U>::value, std::shared_ptr<T>>::type
{
    return r;
}

struct engine;


struct engine_object : std::enable_shared_from_this<engine_object>
{
    explicit engine_object(const std::shared_ptr<engine>& engine)
        : _engine(engine) {}

    virtual ~engine_object() = default;

    template <class EngTy = engine>
    auto get_engine() const
    -> typename std::enable_if<std::is_base_of<engine, EngTy>::value, std::shared_ptr<EngTy>>::type
    {
        return down_pointer_cast<EngTy>(_engine);
    }

private:
    std::shared_ptr<engine> _engine;
};

struct event : engine_object
{
    using engine_object::engine_object;
    virtual std::chrono::nanoseconds wait() = 0;
};

struct command_queue
{
    typedef size_t id_t;

    command_queue(id_t id)
        : _id(id) {}

    command_queue()
        : _id(0) {}

    id_t id() const { return _id; }
private:
    id_t _id;
};

static const command_queue default_queue;

struct command : engine_object
{
    using engine_object::engine_object;

    virtual std::shared_ptr<event> submit(const std::vector<std::shared_ptr<event>>& dependencies = {},
                                          const command_queue&                       queue        = default_queue) = 0;
};

struct buffer : engine_object
{
    using engine_object::engine_object;
    virtual size_t size() const = 0;
    virtual void* get_host_ptr() = 0;
};

enum direction { none = 0x0, input = 0x1, output = 0x2, inout = input | output };

class buffer_binding
{
public:

    buffer_binding(void* ptr, size_t size = 0, direction dir = inout)
        : _direction(dir)
        , _host_ptr(ptr)
        , _capacity(size)
        , _size(size)
        , _owning_engine(nullptr)
        , _buffers({})
    {
        assert(_host_ptr);
    }

    buffer_binding(const std::shared_ptr<buffer>& buffer, direction dir = inout, size_t size = 0)
        : _direction(dir)
        , _host_ptr(nullptr)
        , _capacity(buffer->size())
        , _size(size != 0 ? size : buffer->size())
        , _owning_engine(buffer->get_engine())
        , _buffers({{buffer->get_engine(), buffer}})
    {
        assert(_capacity >= _size);
    }

    direction get_direction() const { return _direction; }

    direction set_direction(direction dir);

    const std::shared_ptr<engine>& get_owning_engine() const { return _owning_engine; }

    void* get_host_ptr() const;

    void reset_host_ptr() const;

    size_t size() const { return _size; }

    size_t capacity() const { return _capacity; }

    void size(size_t size);

    std::shared_ptr<buffer> get_buffer(const std::shared_ptr<engine>& engine) const;

    bool is_output() const { return (_direction & output) != 0; }
    bool is_input() const { return (_direction & input) != 0; }

    bool is_defined() const
    {
        return _size != 0 && (_host_ptr || _owning_engine);
    }

protected:
    direction               _direction;
    mutable void*           _host_ptr;
    size_t                  _capacity;
    size_t                  _size;
    std::shared_ptr<engine> _owning_engine;
    mutable std::map<std::shared_ptr<engine>, std::shared_ptr<buffer>> _buffers;
};

template <typename ElemTy> size_t sizeof_t()       { return sizeof(ElemTy); }
template <> inline size_t         sizeof_t<void>() { return 1; }

struct raise_event_command : command
{
    using command::command;
};

struct commands_sequence : command
{
    using command::command;

    void push_back(const std::shared_ptr<command>& command);

    std::shared_ptr<event> submit(const std::vector<std::shared_ptr<event>>& dependencies = {},
                                  const command_queue&                       queue        = default_queue) override;
protected:
    std::vector<std::shared_ptr<command>> _commands;
};

struct commands_parallel : command
{
    using command::command;

    void add(const std::shared_ptr<command>& command);

    std::shared_ptr<event> submit(const std::vector<std::shared_ptr<event>>& dependencies = {},
                                  const command_queue&                       queue        = default_queue) override;
private:
    std::vector<std::shared_ptr<command>> _commands;
};

struct nd_range
{
    nd_range()
        : _size(0)
        , _values{0, 0, 0} {}

    nd_range(size_t x)
        : _size(1)
        , _values{x, 0, 0} {}

    nd_range(size_t x, size_t y)
        : _size(2)
        , _values{x, y, 0} {}

    nd_range(size_t x, size_t y, size_t z)
        : _size(3)
        , _values{x, y, z} {}

    size_t        dimensions() const { return _size; }
    const size_t* values()     const { return _values; }

    const size_t& operator[](size_t idx) const
    {
        assert(idx < _size);
        return _values[idx];
    }

    size_t& operator[](size_t idx)
    {
        assert(idx < _size);
        return _values[idx];
    }

private:
    size_t _size;
    size_t _values[3];
};

static const nd_range null_range;

struct kernel_options
{
    kernel_options(const nd_range& work_size, const nd_range& parallel_size = null_range);

    virtual ~kernel_options() = default;

    const nd_range& work_size() const { return _work_size; }

    const nd_range& parallel_size() const { return _parallel_size; }
private:
    nd_range _work_size;
    nd_range _parallel_size;
};

struct kernel_command : command
{
    using command::command;

    template <typename T>
    auto set_arg(unsigned idx, const T& value)
    -> typename std::enable_if<!std::is_pointer<T>::value>::type
    {
        set_scalar_arg(idx, &value, sizeof(T));
    }

    void set_arg(unsigned idx, const std::shared_ptr<buffer_binding>& value)
    {
        assert(value->is_defined());
        set_buffer_arg(idx, value);
    }

    virtual void set_options(const kernel_options& params) = 0;

protected:
    virtual void set_scalar_arg(unsigned idx, const void* ptr, size_t size) = 0;

    virtual void set_buffer_arg(unsigned idx, const std::shared_ptr<buffer_binding>& binding) = 0;
};

template <typename ElemTy, direction Dir> class blob;

struct engine
{
    virtual ~engine() = default;

    virtual primitive_db* get_primitive_db() = 0;

    virtual std::shared_ptr<kernel_command> get_kernel(const std::string& name,
                                                       const std::string& module = std::string()) = 0;

    virtual std::shared_ptr<buffer> create_buffer(size_t size, void* ptr = nullptr) = 0;

    virtual std::shared_ptr<raise_event_command> get_raise_event_command() = 0;

    virtual std::shared_ptr<commands_sequence> get_commands_sequence(const std::vector<std::shared_ptr<command>>& commands = {}) = 0;

    virtual std::shared_ptr<commands_parallel> get_commands_parallel(const std::vector<std::shared_ptr<command>>& commands = {}) = 0;

    template <typename T = char>
    std::shared_ptr<buffer_binding> get_temp_buffer(size_t num)
    {
        if (num == 0) throw std::invalid_argument("size should not be zero.");
        return std::make_shared<buffer_binding>(create_buffer(num * sizeof_t<T>(), nullptr), none);
    }

    template <typename T, direction Dir>
    static auto get_input_buffer(const blob<T, Dir>& blob, size_t num)
    -> typename std::enable_if<(Dir & input) != 0, std::shared_ptr<buffer_binding>>::type
    {
        return set_binding_options<T>(blob.get(), num, input);
    }

    template <typename T, direction Dir>
    static auto get_output_buffer(const blob<T, Dir>& blob, size_t num)
    -> typename std::enable_if<(Dir & output) != 0, std::shared_ptr<buffer_binding>>::type
    {
        return set_binding_options<T>(blob.get(), num, output);
    }

    template <typename T, direction Dir>
    static auto get_inout_buffer(const blob<T, Dir>& blob, size_t num)
    -> typename std::enable_if<Dir == inout, std::shared_ptr<buffer_binding>>::type
    {
        return set_binding_options<T>(blob.get(), num, Dir);
    }

private:
    template <typename T>
    static std::shared_ptr<buffer_binding> set_binding_options(std::shared_ptr<buffer_binding>&& binding,
                                                               size_t                            num,
                                                               direction                         dir)
    {
        binding->set_direction(dir);
        binding->size(num * sizeof_t<T>());
        return binding;
    }
};


}