engine.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"

namespace cldnn
{



enum class engine_types : int32_t
{
    ocl = cldnn_engine_ocl
};

struct engine_configuration
{
    const bool enable_profiling;            
    const bool meaningful_kernels_names;    
    const bool dump_custom_program;         
    const std::string compiler_options;     
    const std::string single_kernel_name;   
    const bool enable_parallelisation;      
    const std::string engine_log;           
    const std::string sources_dumps_dir;    
    const uint32_t priority_mode;           

    engine_configuration(
            bool profiling = false,
            bool decorate_kernel_names = false,
            bool dump_custom_program = false,
            const std::string& options = std::string(),
            const std::string& single_kernel = std::string(),
            bool primitives_parallelisation = false,
            const std::string& engine_log = std::string(),
            const std::string& sources_dumps_dir = std::string(),
            uint32_t priority_mode = 0)
        : enable_profiling(profiling)
        , meaningful_kernels_names(decorate_kernel_names)
        , dump_custom_program(dump_custom_program)
        , compiler_options(options)
        , single_kernel_name(single_kernel)
        , enable_parallelisation(primitives_parallelisation)
        , engine_log(engine_log)
        , sources_dumps_dir(sources_dumps_dir)
        , priority_mode(priority_mode)
    {}

    engine_configuration(const cldnn_engine_configuration& c_conf)
        : enable_profiling(c_conf.enable_profiling != 0)
        , meaningful_kernels_names(c_conf.meaningful_kernels_names != 0)
        , dump_custom_program(c_conf.dump_custom_program != 0)
        , compiler_options(c_conf.compiler_options)
        , single_kernel_name(c_conf.single_kernel_name)
        , enable_parallelisation(c_conf.enable_parallelisation != 0)
        , engine_log(c_conf.engine_log)
        , sources_dumps_dir(c_conf.sources_dumps_dir)
        , priority_mode(c_conf.priority_mode)
    {}

    operator ::cldnn_engine_configuration() const
    {
        return{
            enable_profiling,
            meaningful_kernels_names,
            dump_custom_program,
            compiler_options.c_str(),
            single_kernel_name.c_str(),
            enable_parallelisation,
            engine_log.c_str(),
            sources_dumps_dir.c_str(),
            priority_mode
        };
    }
};

using engine_info = ::cldnn_engine_info;

struct engine
{
    engine(const engine_configuration& configuration = engine_configuration())
        :engine(engine_types::ocl, 0, configuration)
    {}

    engine(engine_types type, uint32_t engine_num, const engine_configuration& configuration = engine_configuration())
        :_impl(check_status<::cldnn_engine>("failed to create engine", [&](status_t* status)
              {
                  cldnn_engine_configuration conf = configuration;
                  return cldnn_create_engine(static_cast<int32_t>(type), engine_num, &conf, status);
              }))
    {}

    // TODO add move construction/assignment
    engine(const engine& other) :_impl(other._impl)
    {
        retain();
    }

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

    ~engine()
    {
        release();
    }

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

    static uint32_t engine_count(engine_types type)
    {
        return check_status<uint32_t>("engine_count failed", [=](status_t* status)
        {
            return cldnn_get_engine_count(static_cast<int32_t>(type), status);
        });
    }

    engine_info get_info() const
    {
        return check_status<engine_info>("engine_count failed", [=](status_t* status)
        {
            return cldnn_get_engine_info(_impl, status);
        });
    }

    engine_types get_type() const
    {
        return check_status<engine_types>("engine_count failed", [=](status_t* status)
        {
            return static_cast<engine_types>(cldnn_get_engine_type(_impl, status));
        });
    }

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

private:
    friend struct network;
    friend struct memory;
    friend struct event;
    engine(::cldnn_engine impl) : _impl(impl)
    {
        if (_impl == nullptr) throw std::invalid_argument("implementation pointer should not be null");
    }
    ::cldnn_engine _impl;

    void retain()
    {
        check_status<void>("retain engine failed", [=](status_t* status) { cldnn_retain_engine(_impl, status); });
    }
    void release()
    {
        check_status<void>("release engine failed", [=](status_t* status) { cldnn_release_engine(_impl, status); });
    }
};
CLDNN_API_CLASS(engine)



}