menoh.hpp

Go to the documentation of this file.

#ifndef MENOH_HPP
#define MENOH_HPP

#include <memory>
#include <vector>

#include <menoh/menoh.h>

#ifndef DOXYGEN_SHOULD_SKIP_THIS

#define MENOH_CPP_API_ERROR_CHECK(statement)                 \
    {                                                        \
        auto ec = statement;                                 \
        if(ec) {                                             \
            throw error(ec, menoh_get_last_error_message()); \
        }                                                    \
    }

#endif // DOXYGEN_SHOULD_SKIP_THIS

namespace menoh {
    enum class error_code_t {
        success = menoh_error_code_success,
        std_error = menoh_error_code_std_error,
        unknown_error = menoh_error_code_unknown_error,
        invalid_filename = menoh_error_code_invalid_filename,
        unsupported_onnx_opset_version =
          menoh_error_code_unsupported_onnx_opset_version,
        onnx_parse_error = menoh_error_code_onnx_parse_error,
        invalid_dtype = menoh_error_code_invalid_dtype,
        invalid_attribute_type = menoh_error_code_invalid_attribute_type,
        unsupported_operator_attribute =
          menoh_error_code_unsupported_operator_attribute,
        dimension_mismatch = menoh_error_code_dimension_mismatch,
        variable_not_found = menoh_error_code_variable_not_found,
        index_out_of_range = menoh_error_code_index_out_of_range,
        json_parse_error = menoh_error_code_json_parse_error,
        invalid_backend_name = menoh_error_code_invalid_backend_name,
        unsupported_operator = menoh_error_code_unsupported_operator,
        failed_to_configure_operator =
          menoh_error_code_failed_to_configure_operator,
        backend_error = menoh_error_code_backend_error,
        same_named_variable_already_exist =
          menoh_error_code_same_named_variable_already_exist,
        invalid_dims_size,
    };


    class error : public std::runtime_error {
    public:
        explicit error(menoh_error_code ec, std::string const& message)
          : runtime_error(message), ec_(static_cast<error_code_t>(ec)) {}

        explicit error(error_code_t ec, std::string const& message)
          : error(static_cast<menoh_error_code>(ec), message) {}

        error_code_t error_code() const noexcept { return ec_; }

    private:
        error_code_t ec_;
    };
    enum class dtype_t { float_ = menoh_dtype_float };

    class variable_profile_table;

    class model_data {
    public:
        model_data() : impl_(nullptr, menoh_delete_model_data) {
            menoh_model_data_handle h;
            MENOH_CPP_API_ERROR_CHECK(menoh_make_model_data(&h));
            impl_.reset(h);
        }

        model_data(menoh_model_data_handle h)
          : impl_(h, menoh_delete_model_data) {}

        menoh_model_data_handle get() const noexcept { return impl_.get(); }


        void reset() noexcept { impl_.reset(); }


        void optimize(variable_profile_table const& vpt);

        void add_new_node(std::string const& op_type) {
            MENOH_CPP_API_ERROR_CHECK(
              menoh_model_data_add_new_node(impl_.get(), op_type.c_str()));
        }

        void add_input_name_to_current_node(std::string const& input_name) {
            MENOH_CPP_API_ERROR_CHECK(
              menoh_model_data_add_input_name_to_current_node(
                impl_.get(), input_name.c_str()));
        }

        void add_output_name_to_current_node(std::string const& output_name) {
            MENOH_CPP_API_ERROR_CHECK(
              menoh_model_data_add_output_name_to_current_node(
                impl_.get(), output_name.c_str()));
        }

        void
        add_attribute_int_to_current_node(std::string const& attribute_name,
                                          int32_t value) {
            MENOH_CPP_API_ERROR_CHECK(
              menoh_model_data_add_attribute_int_to_current_node(
                impl_.get(), attribute_name.c_str(), value));
        }

        void
        add_attribute_ints_to_current_node(std::string const& attribute_name,
                                           std::vector<int32_t> const& value) {
            MENOH_CPP_API_ERROR_CHECK(
              menoh_model_data_add_attribute_ints_to_current_node(
                impl_.get(), attribute_name.c_str(), value.size(),
                value.data()));
        }

        void
        add_attribute_float_to_current_node(std::string const& attribute_name,
                                            float value) {
            MENOH_CPP_API_ERROR_CHECK(
              menoh_model_data_add_attribute_float_to_current_node(
                impl_.get(), attribute_name.c_str(), value));
        }

        void
        add_attribute_floats_to_current_node(std::string const& attribute_name,
                                             std::vector<float> const& value) {
            MENOH_CPP_API_ERROR_CHECK(
              menoh_model_data_add_attribute_floats_to_current_node(
                impl_.get(), attribute_name.c_str(), value.size(),
                value.data()));
        }

        void add_parameter(std::string const& parameter_name, dtype_t dtype,
                             std::vector<int> const& dims,
                             void* buffer_handle) {
            MENOH_CPP_API_ERROR_CHECK(menoh_model_data_add_parameter(
              impl_.get(), parameter_name.c_str(),
              static_cast<menoh_dtype>(dtype), dims.size(), dims.data(),
              buffer_handle));
        }

    private:
        std::unique_ptr<menoh_model_data, decltype(&menoh_delete_model_data)>
          impl_;
    };

    inline model_data
    make_model_data_from_onnx(std::string const& onnx_filename) {
        menoh_model_data_handle h;
        MENOH_CPP_API_ERROR_CHECK(
          menoh_make_model_data_from_onnx(onnx_filename.c_str(), &h));
        return model_data(h);
    }
    inline model_data
    make_model_data_from_onnx_data_on_memory(const uint8_t* onnx_data,
                                             uint32_t size) {
        menoh_model_data_handle h;
        MENOH_CPP_API_ERROR_CHECK(
          menoh_make_model_data_from_onnx_data_on_memory(onnx_data, size, &h));
        return model_data(h);
    }
    struct variable_profile {
        dtype_t dtype;
        std::vector<int32_t> dims;
    };

    class variable_profile_table {
    public:
        explicit variable_profile_table(menoh_variable_profile_table_handle h)
          : impl_(h, menoh_delete_variable_profile_table) {}


        variable_profile get_variable_profile(std::string const& name) const {
            menoh_dtype dtype;
            MENOH_CPP_API_ERROR_CHECK(menoh_variable_profile_table_get_dtype(
              impl_.get(), name.c_str(), &dtype));
            int32_t dims_size;
            MENOH_CPP_API_ERROR_CHECK(
              menoh_variable_profile_table_get_dims_size(
                impl_.get(), name.c_str(), &dims_size));
            std::vector<int32_t> dims(dims_size);
            for(int i = 0; i < dims_size; ++i) {
                MENOH_CPP_API_ERROR_CHECK(
                  menoh_variable_profile_table_get_dims_at(
                    impl_.get(), name.c_str(), i, &dims.at(i)));
            }
            return variable_profile{static_cast<dtype_t>(dtype), dims};
        }


        menoh_variable_profile_table_handle get() const noexcept {
            return impl_.get();
        }

    private:
        std::unique_ptr<menoh_variable_profile_table,
                        decltype(&menoh_delete_variable_profile_table)>
          impl_;
    };
    inline void model_data::optimize(variable_profile_table const& vpt) {
        MENOH_CPP_API_ERROR_CHECK(
          menoh_model_data_optimize(impl_.get(), vpt.get()));
    }
    class variable_profile_table_builder {
    public:
        variable_profile_table_builder()
          : impl_(nullptr, menoh_delete_variable_profile_table_builder) {
            menoh_variable_profile_table_builder_handle h;
            MENOH_CPP_API_ERROR_CHECK(
              menoh_make_variable_profile_table_builder(&h));
            impl_.reset(h);
        }

        void add_input_profile(std::string const& name, dtype_t dtype,
                               std::vector<int32_t> const& dims) {
            MENOH_CPP_API_ERROR_CHECK(
              menoh_variable_profile_table_builder_add_input_profile(
                impl_.get(), name.c_str(), static_cast<menoh_dtype>(dtype),
                dims.size(), dims.data()));
        }


        void add_output_name(std::string const& name) {
            MENOH_CPP_API_ERROR_CHECK(
              menoh_variable_profile_table_builder_add_output_name(
                impl_.get(), name.c_str()));
        }


        [[deprecated("Use add_output_name() instead")]]
        void add_output_profile(std::string const& name, dtype_t) {
            add_output_name(name);
        }

        variable_profile_table
        build_variable_profile_table(model_data const& model_data) {
            menoh_variable_profile_table_handle h;
            MENOH_CPP_API_ERROR_CHECK(menoh_build_variable_profile_table(
              impl_.get(), model_data.get(), &h));
            return variable_profile_table(h);
        }

    private:
        std::unique_ptr<menoh_variable_profile_table_builder,
                        decltype(&menoh_delete_variable_profile_table_builder)>
          impl_;
    };
    struct variable {
        dtype_t dtype;
        std::vector<int32_t> dims;
        void* buffer_handle;
    };

    class model {
    public:
        explicit model(menoh_model_handle h) : impl_(h, menoh_delete_model) {}


        variable get_variable(std::string const& name) const {
            void* buff;
            MENOH_CPP_API_ERROR_CHECK(menoh_model_get_variable_buffer_handle(
              impl_.get(), name.c_str(), &buff));
            menoh_dtype dtype;
            MENOH_CPP_API_ERROR_CHECK(menoh_model_get_variable_dtype(
              impl_.get(), name.c_str(), &dtype));
            int32_t dims_size;
            MENOH_CPP_API_ERROR_CHECK(menoh_model_get_variable_dims_size(
              impl_.get(), name.c_str(), &dims_size));
            std::vector<int32_t> dims(dims_size);
            for(int i = 0; i < dims_size; ++i) {
                MENOH_CPP_API_ERROR_CHECK(menoh_model_get_variable_dims_at(
                  impl_.get(), name.c_str(), i, &dims.at(i)));
            }
            return variable{static_cast<dtype_t>(dtype), dims, buff};
        }


        void run() { menoh_model_run(impl_.get()); }

    private:
        std::unique_ptr<menoh_model, decltype(&menoh_delete_model)> impl_;
    };

    class model_builder {
    public:
        explicit model_builder(
          variable_profile_table const& variable_profile_table)
          : impl_(nullptr, menoh_delete_model_builder) {
            menoh_model_builder_handle h;
            MENOH_CPP_API_ERROR_CHECK(
              menoh_make_model_builder(variable_profile_table.get(), &h));
            impl_.reset(h);
        }


        void attach_external_buffer(std::string const& name,
                                    void* buffer_handle) {
            MENOH_CPP_API_ERROR_CHECK(
              menoh_model_builder_attach_external_buffer(
                impl_.get(), name.c_str(), buffer_handle));
        }


        model build_model(model_data const& model_data,
                          std::string const& backend_name,
                          std::string const& backend_config = "") {
            menoh_model_handle h;
            MENOH_CPP_API_ERROR_CHECK(menoh_build_model(
              impl_.get(), model_data.get(), backend_name.c_str(),
              backend_config.c_str(), &h));
            return model(h);
        }

    private:
        std::unique_ptr<menoh_model_builder,
                        decltype(&menoh_delete_model_builder)>
          impl_;
    };
} // namespace menoh

#undef MENOH_CPP_API_ERROR_CHECK
#endif // MENOH_HPP