program.hpp

/*
// Copyright (c) 2016 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 "cldnn_defs.h"
#include "topology.hpp"
#include "engine.hpp"
#include <iostream>

#include <memory>

namespace cldnn
{



enum class build_option_type
{
    fusing = cldnn_build_option_fusing,

    optimize_data = cldnn_build_option_optimize_data,

    debug = cldnn_build_option_debug,

    outputs = cldnn_build_option_outputs,

    tuning_config = cldnn_build_option_tuning_config,

    graph_dumps_dir = cldnn_build_option_graph_dumps_dir
};

enum class tuning_mode
{
    tuning_disabled = cldnn_tuning_disabled,

    tuning_use_cache = cldnn_tuning_use_cache,

    tuning_tune_and_cache = cldnn_tuning_tune_and_cache
};

struct tuning_config_options
{
    tuning_mode mode;
    std::string cache_file_path;

    tuning_config_options() :
        mode(tuning_mode::tuning_disabled),
        cache_file_path("")
    {}
};

struct build_option
{
    static std::shared_ptr<const build_option> fusing(bool enable = false);

    static std::shared_ptr<const build_option> optimize_data(bool enable = false);

    static std::shared_ptr<const build_option> debug(bool enable = false);

    static std::shared_ptr<const build_option> outputs(const std::vector<primitive_id>& outs);

    static std::shared_ptr<const build_option> tuning_config(const tuning_config_options& config = tuning_config_options());

    static std::shared_ptr<const build_option> graph_dumps_dir(const std::string& dir_path);

    virtual ~build_option() = default;

private:
    virtual build_option_type get_type() const = 0;

    virtual const void* get_data() const = 0;

    friend class build_options;
};

template<build_option_type OptType>
struct build_option_bool : build_option
{
    explicit build_option_bool(bool value) : _value(value ? 1 : 0) {}

    explicit build_option_bool(const cldnn_build_option& value)
        : _value(reinterpret_cast<uintptr_t>(value.data))
    {
        assert(value.type == static_cast<int32_t>(OptType));
    }

    bool enabled() const { return _value != 0; }
private:
    build_option_type get_type() const override { return OptType; }
    const void* get_data() const override { return reinterpret_cast<const void*>(_value); }
    uintptr_t _value;
};

struct build_option_outputs : build_option
{
    const std::vector<primitive_id> outputs;

    explicit build_option_outputs(const std::vector<primitive_id>& outs)
        : outputs(outs)
        , _ref_store(to_refs(outputs))
        , _outputs_ref({ _ref_store.data(), _ref_store.size() })
    {}

    explicit build_option_outputs(const cldnn_build_option& value)
        : build_option_outputs(make_outputs_from_ref(value))
    {
        assert(value.type == static_cast<int32_t>(cldnn_build_option_outputs));
    }

private:
    build_option_type get_type() const override { return build_option_type::outputs; }
    const void* get_data() const override { return &_outputs_ref; }

    build_option_outputs(const build_option_outputs& other) = delete;
    build_option_outputs& operator=(const build_option_outputs& other) = delete;

    const std::vector<cldnn_primitive_id> _ref_store;
    const cldnn_primitive_id_arr _outputs_ref;

    static std::vector<cldnn_primitive_id> to_refs(const std::vector<primitive_id>& stor)
    {
        std::vector<cldnn_primitive_id> result(stor.size());
        for (size_t i = 0; i < stor.size(); i++)
        {
            result[i] = stor[i].c_str();
        }
        return result;
    }

    static std::vector<primitive_id> make_outputs_from_ref(const cldnn_build_option& value)
    {
        if (value.type != cldnn_build_option_outputs) throw std::invalid_argument("option type does not match: should be 'output'");
        if (value.data == nullptr) throw std::invalid_argument("output data is empty");
        auto refs = reinterpret_cast<const cldnn_primitive_id_arr*>(value.data);
        std::vector<primitive_id> result;
        result.reserve(refs->size);
        for (decltype(refs->size) i = 0; i < refs->size; i++)
        {
            result.push_back(refs->data[i]);
        }
        return result;
    }
};

struct build_option_tuning_config : build_option
{
    const tuning_config_options config;

    explicit build_option_tuning_config(const tuning_config_options& tuning_config) :
        config(tuning_config),
        config_ref({ static_cast<int32_t>(config.mode), config.cache_file_path.c_str() })
    {}

    explicit build_option_tuning_config(const cldnn_build_option& value)
        : build_option_tuning_config(make_config_from_ref(value))
    {
        assert(value.type == static_cast<int32_t>(cldnn_build_option_tuning_config));
    }

private:
    build_option_type get_type() const override { return build_option_type::tuning_config; }
    const void* get_data() const override { return &config_ref; }

    build_option_tuning_config(const build_option_tuning_config& other) = delete;
    build_option_tuning_config& operator=(const build_option_tuning_config& other) = delete;

    const cldnn_tuning_config config_ref;

    static tuning_config_options make_config_from_ref(const cldnn_build_option& value)
    {
        if (value.type != cldnn_build_option_tuning_config) throw std::invalid_argument("option type does not match: should be 'tuning_config'");
        if (value.data == nullptr) throw std::invalid_argument("Tuning config data is empty");
        auto refs = reinterpret_cast<const cldnn_tuning_config*>(value.data);
        tuning_config_options result;
        result.mode = tuning_mode(refs->mode);
        result.cache_file_path = std::string(refs->cache_file_path);
        return result;
    }
};

template<build_option_type OptType>
struct build_option_directory : build_option
{
    const std::string directory_path;

    explicit build_option_directory(const std::string& dir_path)
        : directory_path(dir_path)
    {}

    explicit build_option_directory(const cldnn_build_option& value)
        : directory_path(from_c_value(value))
    {}

private:
    build_option_type get_type() const override { return build_option_type::graph_dumps_dir; }
    const void* get_data() const override { return (directory_path.empty() ? nullptr : directory_path.c_str()); }

    build_option_directory(const build_option_directory& other) = delete;
    build_option_directory& operator=(const build_option_directory& other) = delete;

    static std::string from_c_value(const cldnn_build_option& value)
    {
        if (value.type != static_cast<int32_t>(OptType))
            throw std::invalid_argument("option type does not match");
        if (value.data == nullptr)
            return{};

        return{ static_cast<const char*>(value.data) };
    }
};

namespace detail
{
    template<build_option_type OptType>
    struct build_option_traits
    {
        typedef build_option object_type;
        static std::shared_ptr<const build_option> make_default();
        static std::shared_ptr<const build_option> make_option(const cldnn_build_option& option);
    };

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    template<> struct build_option_traits<build_option_type::fusing>
    {
        typedef build_option_bool<build_option_type::fusing> object_type;
        static std::shared_ptr<const build_option> make_default() { return build_option::fusing(); }
        static std::shared_ptr<const build_option> make_option(const cldnn_build_option& option)
        {
            assert(option.type == cldnn_build_option_fusing);
            return std::make_shared<object_type>(option);
        }
    };
    template<> struct build_option_traits<build_option_type::optimize_data>
    {
        typedef build_option_bool<build_option_type::optimize_data> object_type;
        static std::shared_ptr<const build_option> make_default() { return build_option::optimize_data(); }
        static std::shared_ptr<const build_option> make_option(const cldnn_build_option& option)
        {
            assert(option.type == cldnn_build_option_optimize_data);
            return std::make_shared<object_type>(option);
        }
    };
    template<> struct build_option_traits<build_option_type::debug>
    {
        typedef build_option_bool<build_option_type::debug> object_type;
        static std::shared_ptr<const build_option> make_default() { return build_option::debug(); }
        static std::shared_ptr<const build_option> make_option(const cldnn_build_option& option)
        {
            assert(option.type == cldnn_build_option_debug);
            return std::make_shared<object_type>(option);
        }
    };
    template<> struct build_option_traits<build_option_type::outputs>
    {
        typedef build_option_outputs object_type;
        static std::shared_ptr<const build_option> make_default() { return build_option::outputs({}); }
        static std::shared_ptr<const build_option> make_option(const cldnn_build_option& option)
        {
            assert(option.type == cldnn_build_option_outputs);
            return std::make_shared<object_type>(option);
        }
    };
    template<> struct build_option_traits<build_option_type::tuning_config>
    {
        typedef build_option_tuning_config object_type;
        static std::shared_ptr<const build_option> make_default() { return build_option::tuning_config(); }
        static std::shared_ptr<const build_option> make_option(const cldnn_build_option& option)
        {
            assert(option.type == cldnn_build_option_tuning_config);
            return std::make_shared<object_type>(option);
        }
    };
    template<> struct build_option_traits<build_option_type::graph_dumps_dir>
    {
        typedef build_option_directory<build_option_type::graph_dumps_dir> object_type;
        static std::shared_ptr<const build_option> make_default() { return build_option::graph_dumps_dir({}); }
        static std::shared_ptr<const build_option> make_option(const cldnn_build_option& option)
        {
            assert(option.type == cldnn_build_option_graph_dumps_dir);
            return std::make_shared<object_type>(option);
        }
    };
#endif
} // namespace detail

#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline std::shared_ptr<const build_option> build_option::fusing(bool enable)
{
    return std::make_shared<build_option_bool<build_option_type::fusing>>(enable);
}

inline std::shared_ptr<const build_option> build_option::optimize_data(bool enable)
{
    return std::make_shared<build_option_bool<build_option_type::optimize_data>>(enable);
}

inline std::shared_ptr<const build_option> build_option::debug(bool enable)
{
    return std::make_shared<build_option_bool<build_option_type::debug>>(enable);
}

inline std::shared_ptr<const build_option> build_option::outputs(const std::vector<primitive_id>& outs)
{
    return std::make_shared<build_option_outputs>(outs);
}

inline std::shared_ptr<const build_option> build_option::tuning_config(const tuning_config_options& config)
{
    return std::make_shared<build_option_tuning_config>(config);
}

inline std::shared_ptr<const build_option> build_option::graph_dumps_dir(const std::string& dir_path)
{
    return std::make_shared<build_option_directory<build_option_type::graph_dumps_dir>>(dir_path);
}
#endif

class build_options
{
public:
    void set_option(std::shared_ptr<const build_option> opt)
    {
        add_or_replace_option(opt);
    }

    template<typename ...Args>
    void set_option(std::shared_ptr<const build_option> opt, Args... args)
    {
        add_or_replace_option(opt);
        set_option(args...);
    }

    template<typename ...Args>
    build_options(Args... args)
    {
        set_option(args...);
    }

    build_options(array_ref<cldnn_build_option> options)
    {
        for (auto& o : options)
        {
            _options.emplace_back(make_option(o));
        }
    }

    template<build_option_type OptType>
    std::shared_ptr<const typename detail::build_option_traits<OptType>::object_type>
        get() const
    {
        using T = typename detail::build_option_traits<OptType>::object_type;
        for (auto& option : _options)
        {
            if (option->get_type() == OptType)
                return std::static_pointer_cast<const T>(option);
        }
        return std::static_pointer_cast<const T>(detail::build_option_traits<OptType>::make_default());
    }

private:
    friend struct program;
    std::vector<std::shared_ptr<const build_option>> _options;
    void set_option(void) {}

    std::vector<cldnn_build_option> get_refs() const
    {
        std::vector<cldnn_build_option> result;
        for (auto& o : _options)
        {
            result.push_back({ static_cast<int32_t>(o->get_type()), o->get_data() });
        }
        return result;
    }

    void add_or_replace_option(std::shared_ptr<const build_option> opt)
    {
        for (auto& p : _options)
        {
            if (p->get_type() == opt->get_type())
            {
                p = opt;
                return;
            }
        }
        _options.push_back(opt);
    }

    static std::shared_ptr<const build_option> make_option(const cldnn_build_option& option)
    {
        switch (option.type)
        {
        case cldnn_build_option_fusing:
            return  detail::build_option_traits<build_option_type::fusing>::make_option(option);
        case cldnn_build_option_optimize_data:
            return detail::build_option_traits<build_option_type::optimize_data>::make_option(option);
        case cldnn_build_option_debug:
            return detail::build_option_traits<build_option_type::debug>::make_option(option);
        case cldnn_build_option_outputs:
            return detail::build_option_traits<build_option_type::outputs>::make_option(option);
        case cldnn_build_option_tuning_config:
            return detail::build_option_traits<build_option_type::tuning_config>::make_option(option);
        case cldnn_build_option_graph_dumps_dir:
            return detail::build_option_traits<build_option_type::graph_dumps_dir>::make_option(option);
        default: throw std::out_of_range("unsupported build option type");
        }
    }
};

struct program
{
    friend struct network;

public:
    program(engine const& engine, topology const& topology, build_options const& options = build_options())
        :_impl(check_status<cldnn_program>("program creation failed", [&](status_t* status)
            {
                auto options_refs = options.get_refs();
                return cldnn_build_program(engine.get(), topology.get(), options_refs.data(), options_refs.size(), status);
            }))
    {}

    program(program const& other)
        :_impl(other._impl)
    {
        retain();
    }

    ~program()
    {
        release();
    }

    program& operator=(const program& other)
    {
        if (_impl == other._impl) return *this;
        release();
        _impl = other._impl;
        retain();
        return *this;
    }

    friend bool operator==(const program& lhs, const program& rhs) { return lhs._impl == rhs._impl; }
    friend bool operator!=(const program& lhs, const program& rhs) { return !(lhs == rhs); }

    ::cldnn_program get() const { return _impl; }

private:

    ::cldnn_program _impl;

    program(::cldnn_program impl) : _impl(impl)
    {
        if (_impl == nullptr)
            throw std::invalid_argument("implementation pointer should not be null");
    }

    void retain()
    {
        check_status<void>("retain topology failed", [=](status_t* status) { cldnn_retain_program(_impl, status); });
    }
    void release()
    {
        check_status<void>("retain topology failed", [=](status_t* status) { cldnn_release_program(_impl, status); });
    }
};
}