Global Namespace

Overview

// namespaces

namespace CheckOperatorEqual;
namespace ExecGraphInfoSerialization;
namespace FileUtils;
namespace InferenceEngine;
    namespace InferenceEngine::CLDNNConfigParams;
    namespace InferenceEngine::GNAConfigParams;
    namespace InferenceEngine::GPUConfigParams;
    namespace InferenceEngine::GPUContextParams;
    namespace InferenceEngine::HeteroConfigParams;
    namespace InferenceEngine::Metrics;
    namespace InferenceEngine::MultiDeviceConfigParams;
    namespace InferenceEngine::PluginConfigInternalParams;
    namespace InferenceEngine::PluginConfigParams;
    namespace InferenceEngine::PrecisionUtils;
        namespace InferenceEngine::PrecisionUtils::details;
    namespace InferenceEngine::VPUConfigParams;
    namespace InferenceEngine::gpu;
    namespace InferenceEngine::itt;
        namespace InferenceEngine::itt::domains;
namespace ONNX_NAMESPACE;
namespace XMLParseUtils;
namespace ngraph;
    namespace ngraph::builder;
    namespace ngraph::descriptor;
        namespace ngraph::descriptor::layout;
    namespace ngraph::element;
    namespace ngraph::file_util;
    namespace ngraph::onnx_import;
        namespace ngraph::onnx_import::detail;
        namespace ngraph::onnx_import::error;
            namespace ngraph::onnx_import::error::node;
    namespace ngraph::op;
        namespace ngraph::op::internal;
        namespace ngraph::op::util;
            namespace ngraph::op::util::detail;
            namespace ngraph::op::util::error;
        namespace ngraph::op::v0;
        namespace ngraph::op::v1;
        namespace ngraph::op::v3;
        namespace ngraph::op::v4;
        namespace ngraph::op::v5;
        namespace ngraph::op::v6;
        namespace ngraph::op::v7;
    namespace ngraph::opset1;
    namespace ngraph::opset2;
    namespace ngraph::opset3;
    namespace ngraph::opset4;
    namespace ngraph::opset5;
    namespace ngraph::opset6;
    namespace ngraph::opset7;
    namespace ngraph::pass;
    namespace ngraph::pattern;
        namespace ngraph::pattern::op;
    namespace ngraph::reduction;
    namespace ngraph::runtime;
namespace openvino;
    namespace openvino::itt;
namespace std;

// typedefs

typedef struct ie_core ie_core_t;
typedef struct ie_network ie_network_t;
typedef struct ie_executable ie_executable_network_t;
typedef struct ie_infer_request ie_infer_request_t;
typedef struct ie_blob ie_blob_t;
typedef struct ie_version ie_version_t;
typedef struct ie_core_version ie_core_version_t;
typedef struct ie_core_versions ie_core_versions_t;
typedef struct ie_config ie_config_t;
typedef struct ie_param ie_param_t;
typedef struct ie_param_config ie_param_config_t;
typedef struct desc desc_t;
typedef struct dimensions dimensions_t;
typedef struct tensor_desc tensor_desc_t;
typedef struct roi roi_t;
typedef struct input_shape input_shape_t;
typedef struct input_shapes input_shapes_t;
typedef struct ie_complete_call_back ie_complete_call_back_t;
typedef struct ie_available_devices ie_available_devices_t;
typedef char tchar;
typedef std::string file_name_t;
typedef std::unordered_map<ngraph::NodeTypeInfo, std::function<bool(const std::shared_ptr<ngraph::Node>&, ngraph::element::Type, size_t idx)>> type_to_fuse_map;
typedef std::vector<std::pair<ngraph::element::Type, ngraph::element::Type>> precisions_array;
typedef std::unordered_map<ngraph::Node::type_info_t, std::function<void(const ngraph::Node&, std::ostream&ss)>> visualize_tree_ops_map_t;

// enums

enum precision_e;
enum resize_alg_e;

// structs

struct desc;
struct ie_config;
struct ie_version;
struct parse_result;
struct roi;
struct roi_t;
struct tensor_desc;

// classes

template <InferenceEngine::Precision::ePrecision precision>
class BlobFactory;
class ConvertReduceBase;

// global variables

const char* NGRAPH_VERSION_NUMBER = "${NGRAPH_VERSION}";

// global functions

ie_version_t ie_c_api_version(void);
void ie_version_free(ie_version_t* version);
void ie_param_free(ie_param_t* param);
IEStatusCode ie_core_create(const char* xml_config_file, ie_core_t** core);
void ie_core_free(ie_core_t** core);

IEStatusCode ie_core_get_versions(
    const ie_core_t* core,
    const char* device_name,
    ie_core_versions_t* versions
    );

void ie_core_versions_free(ie_core_versions_t* vers);

IEStatusCode ie_core_read_network(
    ie_core_t* core,
    const char* xml,
    const char* weights_file,
    ie_network_t** network
    );

IEStatusCode ie_core_read_network_from_memory(
    ie_core_t* core,
    const uint8_t* xml_content,
    size_t xml_content_size,
    const ie_blob_t* weight_blob,
    ie_network_t** network
    );

IEStatusCode ie_core_import_network(
    ie_core_t* core,
    const char* file_name,
    const char* device_name,
    const ie_config_t* config,
    ie_executable_network_t** exe_network
    );

IEStatusCode ie_core_import_network_from_memory(
    ie_core_t* core,
    const uint8_t* content,
    size_t content_size,
    const char* device_name,
    const ie_config_t* config,
    ie_executable_network_t** exe_network
    );

IEStatusCode ie_core_export_network(
    ie_executable_network_t* exe_network,
    const char* file_name
    );

IEStatusCode ie_core_load_network(
    ie_core_t* core,
    const ie_network_t* network,
    const char* device_name,
    const ie_config_t* config,
    ie_executable_network_t** exe_network
    );

IEStatusCode ie_core_load_network_from_file(
    ie_core_t* core,
    const char* xml,
    const char* device_name,
    const ie_config_t* config,
    ie_executable_network_t** exe_network
    );

IEStatusCode ie_core_set_config(
    ie_core_t* core,
    const ie_config_t* ie_core_config,
    const char* device_name
    );

IEStatusCode ie_core_register_plugin(
    ie_core_t* core,
    const char* plugin_name,
    const char* device_name
    );

IEStatusCode ie_core_register_plugins(
    ie_core_t* core,
    const char* xml_config_file
    );

IEStatusCode ie_core_unregister_plugin(ie_core_t* core, const char* device_name);

IEStatusCode ie_core_add_extension(
    ie_core_t* core,
    const char* extension_path,
    const char* device_name
    );

IEStatusCode ie_core_get_metric(
    const ie_core_t* core,
    const char* device_name,
    const char* metric_name,
    ie_param_t* param_result
    );

IEStatusCode ie_core_get_config(
    const ie_core_t* core,
    const char* device_name,
    const char* config_name,
    ie_param_t* param_result
    );

IEStatusCode ie_core_get_available_devices(
    const ie_core_t* core,
    ie_available_devices_t* avai_devices
    );

void ie_core_available_devices_free(ie_available_devices_t* avai_devices);
void ie_infer_request_free(ie_infer_request_t** infer_request);

IEStatusCode ie_infer_request_get_blob(
    ie_infer_request_t* infer_request,
    const char* name,
    ie_blob_t** blob
    );

IEStatusCode ie_infer_request_set_blob(
    ie_infer_request_t* infer_request,
    const char* name,
    const ie_blob_t* blob
    );

IEStatusCode ie_infer_request_infer(ie_infer_request_t* infer_request);
IEStatusCode ie_infer_request_infer_async(ie_infer_request_t* infer_request);

IEStatusCode ie_infer_set_completion_callback(
    ie_infer_request_t* infer_request,
    ie_complete_call_back_t* callback
    );

IEStatusCode ie_infer_request_wait(
    ie_infer_request_t* infer_request,
    const int64_t timeout
    );

IEStatusCode ie_infer_request_set_batch(
    ie_infer_request_t* infer_request,
    const size_t size
    );

void ie_network_free(ie_network_t** network);
IEStatusCode ie_network_get_name(const ie_network_t* network, char** name);

IEStatusCode ie_network_get_inputs_number(
    const ie_network_t* network,
    size_t* size_result
    );

IEStatusCode ie_network_get_input_name(
    const ie_network_t* network,
    size_t number,
    char** name
    );

IEStatusCode ie_network_get_input_precision(
    const ie_network_t* network,
    const char* input_name,
    precision_e* prec_result
    );

IEStatusCode ie_network_set_input_precision(
    ie_network_t* network,
    const char* input_name,
    const precision_e p
    );

IEStatusCode ie_network_get_input_layout(
    const ie_network_t* network,
    const char* input_name,
    layout_e* layout_result
    );

IEStatusCode ie_network_set_input_layout(
    ie_network_t* network,
    const char* input_name,
    const layout_e l
    );

IEStatusCode ie_network_get_input_dims(
    const ie_network_t* network,
    const char* input_name,
    dimensions_t* dims_result
    );

IEStatusCode ie_network_get_input_resize_algorithm(
    const ie_network_t* network,
    const char* input_name,
    resize_alg_e* resize_alg_result
    );

IEStatusCode ie_network_set_input_resize_algorithm(
    ie_network_t* network,
    const char* input_name,
    const resize_alg_e resize_algo
    );

IEStatusCode ie_network_get_color_format(
    const ie_network_t* network,
    const char* input_name,
    colorformat_e* colformat_result
    );

IEStatusCode ie_network_set_color_format(
    ie_network_t* network,
    const char* input_name,
    const colorformat_e color_format
    );

IEStatusCode ie_network_get_input_shapes(
    ie_network_t* network,
    input_shapes_t* shapes
    );

IEStatusCode ie_network_reshape(
    ie_network_t* network,
    const input_shapes_t shapes
    );

IEStatusCode ie_network_get_outputs_number(
    const ie_network_t* network,
    size_t* size_result
    );

IEStatusCode ie_network_get_output_name(
    const ie_network_t* network,
    const size_t number,
    char** name
    );

IEStatusCode ie_network_get_output_precision(
    const ie_network_t* network,
    const char* output_name,
    precision_e* prec_result
    );

IEStatusCode ie_network_set_output_precision(
    ie_network_t* network,
    const char* output_name,
    const precision_e p
    );

IEStatusCode ie_network_get_output_layout(
    const ie_network_t* network,
    const char* output_name,
    layout_e* layout_result
    );

IEStatusCode ie_network_set_output_layout(
    ie_network_t* network,
    const char* output_name,
    const layout_e l
    );

IEStatusCode ie_network_get_output_dims(
    const ie_network_t* network,
    const char* output_name,
    dimensions_t* dims_result
    );

void ie_network_input_shapes_free(input_shapes_t* inputShapes);
void ie_network_name_free(char** name);

IEStatusCode ie_blob_make_memory(
    const tensor_desc_t* tensorDesc,
    ie_blob_t** blob
    );

IEStatusCode ie_blob_make_memory_from_preallocated(
    const tensor_desc_t* tensorDesc,
    void* ptr,
    size_t size,
    ie_blob_t** blob
    );

IEStatusCode ie_blob_make_memory_with_roi(
    const ie_blob_t* inputBlob,
    const roi_t* roi,
    ie_blob_t** blob
    );

IEStatusCode ie_blob_make_memory_nv12(
    const ie_blob_t* y,
    const ie_blob_t* uv,
    ie_blob_t** nv12Blob
    );

IEStatusCode ie_blob_make_memory_i420(
    const ie_blob_t* y,
    const ie_blob_t* u,
    const ie_blob_t* v,
    ie_blob_t** i420Blob
    );

IEStatusCode ie_blob_size(ie_blob_t* blob, int* size_result);
IEStatusCode ie_blob_byte_size(ie_blob_t* blob, int* bsize_result);
void ie_blob_deallocate(ie_blob_t** blob);
IEStatusCode ie_blob_get_dims(const ie_blob_t* blob, dimensions_t* dims_result);
IEStatusCode ie_blob_get_layout(const ie_blob_t* blob, layout_e* layout_result);

IEStatusCode ie_blob_get_precision(
    const ie_blob_t* blob,
    precision_e* prec_result
    );

void ie_blob_free(ie_blob_t** blob);
InferenceEngine::Blob::Ptr make_blob_with_precision(const InferenceEngine::TensorDesc& desc);

InferenceEngine::Blob::Ptr make_blob_with_precision(
    const InferenceEngine::TensorDesc& desc,
    void* ptr
    );

InferenceEngine::Blob::Ptr make_blob_with_precision(
    const InferenceEngine::TensorDesc& desc,
    const std::shared_ptr<InferenceEngine::IAllocator>& alloc
    );

InferenceEngine::Blob::Ptr make_plain_blob(
    InferenceEngine::Precision prec,
    const InferenceEngine::SizeVector dims
    );

template <class... Args>
InferenceEngine::Blob::Ptr make_blob_with_precision(
    InferenceEngine::Precision precision,
    Args&&... args
    );

template <typename T>
void CopyVectorToBlob(
    const InferenceEngine::Blob::Ptr outputBlob,
    const std::vector<T>& inputVector
    );

int ie_memcpy(void* dest, size_t destsz, void const* src, size_t count);
parse_result ParseXml(const char* file_path);
ngraph::SlicePlan get_slice_plan(std::shared_ptr<ngraph::opset1::StridedSlice> slice);
NGRAPH_API const char* get_ngraph_version_string();

template <typename T>
std::vector<T> read_vector(std::shared_ptr<ngraph::runtime::Tensor> tv);

template <typename T>
std::vector<T> host_tensor_2_vector(ngraph::HostTensorPtr tensor);

std::vector<float> NGRAPH_API read_float_vector(std::shared_ptr<ngraph::runtime::Tensor> tv);
std::vector<int64_t> NGRAPH_API read_index_vector(std::shared_ptr<ngraph::runtime::Tensor> tv);

NGRAPH_API std::ostream& operator << (
    std::ostream& os,
    const ngraph::NodeVector& nv
    );

// macros

#define AUTO_CONFIG_KEY(name)
#define CALL_OVERLOAD(name, exc_class, ctx, ...)
#define CLDNN_CONFIG_KEY(name)
#define CL_HPP_MINIMUM_OPENCL_VERSION
#define CL_HPP_TARGET_OPENCL_VERSION
#define CONFIG_KEY(name)
#define CONFIG_KEY_INTERNAL(name)
#define CONFIG_VALUE(name)
#define COPY_TENSOR(a)
#define COUNT_ARGS_MAXN(...)
#define DECLARE_GPU_PARAM_KEY(name, ...)
#define DECLARE_GPU_PARAM_VALUE(name)
#define DECLARE_VPU_CONFIG(name)
#define EXEC_NETWORK_METRIC_KEY(name)
#define EXPAND_ARGS(args)
#define FOREACH_CHILD(c, p, tag)
#define GLUE(x, y)
#define GNA_CONFIG_KEY(name)
#define GNA_CONFIG_VALUE(name)
#define GPU_CONFIG_KEY(name)
#define GPU_METRIC_KEY(name)
#define GPU_PARAM_KEY(name)
#define GPU_PARAM_VALUE(name)
#define HETERO_CONFIG_KEY(name)
#define IE_ASSERT(EXPRESSION)
#define IE_DEFINE_EXTENSION_CREATE_FUNCTION(ExtensionType)
#define IE_DEFINE_PLUGIN_CREATE_FUNCTION(PluginType, version, ...)
#define IE_EXCEPTION_SWITCH(STATUS, TYPE_ALIAS, ...)
#define IE_SET_METRIC_RETURN(name, ...)
#define IE_THROW(...)
#define IE_VERSION_MAJOR
#define IE_VERSION_MINOR
#define IE_VERSION_PATCH
#define ITT_FUNCTION_NAME
#define METRIC_KEY(name)
#define METRIC_VALUE(name)
#define MULTI_CONFIG_KEY(name)
#define NGRAPH_API
#define NGRAPH_CHECK(...)
#define NGRAPH_CHECK_HELPER(exc_class, ctx, ...)
#define NGRAPH_CHECK_HELPER1(exc_class, ctx, check)
#define NGRAPH_CHECK_HELPER2(exc_class, ctx, check, ...)
#define NGRAPH_DEBUG
#define NGRAPH_DEPRECATED(msg)
#define NGRAPH_DO_PRAGMA(x)
#define NGRAPH_ERR
#define NGRAPH_HELPER_DLL_EXPORT
#define NGRAPH_HELPER_DLL_IMPORT
#define NGRAPH_INFO
#define NGRAPH_OP(a, b)
#define NGRAPH_OP(a, b)
#define NGRAPH_OP(a, b)
#define NGRAPH_OP(a, b)
#define NGRAPH_OP(a, b)
#define NGRAPH_OP(a, b)
#define NGRAPH_OP(a, b)
#define NGRAPH_RTTI_DECLARATION
#define NGRAPH_RTTI_DEFINITION(...)
#define NGRAPH_UNREACHABLE(...)
#define NGRAPH_WARN
#define NG_ATTRIBUTE_UNUSED
#define NODE_VALIDATION_CHECK(node, ...)
#define ONNX_IMPORTER_API
#define OVERLOAD_MACRO(name, count)
#define OVERLOAD_MACRO1(name, count)
#define OVERLOAD_MACRO2(name, count)
#define OV_ITT_DOMAIN(...)
#define OV_ITT_GROUP(group)
#define OV_ITT_SCOPE(group, ...)
#define OV_ITT_SCOPED_TASK(...)
#define OV_ITT_SCOPE_CHAIN(group, ...)
#define OV_ITT_SCOPE_NEXT(group, ...)
#define OV_ITT_SCOPE_SKIP(group, chainId)
#define OV_ITT_TASK_CHAIN(...)
#define OV_ITT_TASK_NEXT(...)
#define OV_ITT_TASK_SKIP(chainId)
#define PROJECT_ROOT_DIR

#define RETURN_ARG_COUNT( \
    _1_, \
    _2_, \
    _3_, \
    _4_, \
    _5_, \
    _6, \
    _7, \
    _8, \
    _9, \
    _10, \
    _11, \
    _12, \
    _13, \
    _14, \
    _15, \
    _16, \
    _17, \
    _18, \
    _19, \
    _20, \
    _21, \
    _22, \
    _23, \
    _24, \
    _25, \
    count, \
    ... \
    )

#define TBB_PREVIEW_TASK_ARENA_CONSTRAINTS_EXTENSION
#define TRANSFORMATIONS_API
#define TYPE_CASE(a)
#define UNUSED_PARAMETER
#define USE_FACTORY(precision)
#define VPU_CONFIG_KEY(name)
#define VPU_CONFIG_VALUE(name)
#define VPU_HDDL_CONFIG_KEY(name)
#define VPU_HDDL_CONFIG_VALUE(name)
#define VPU_HDDL_METRIC(name)
#define VPU_METRIC(name)
#define VPU_MYRIAD_CONFIG_KEY(name)
#define VPU_MYRIAD_CONFIG_VALUE(name)
#define _NGRAPH_RTTI_DEFINITION_COMMON(CLASS)
#define _NGRAPH_RTTI_DEFINITION_NO_PARENT(CLASS, TYPE_NAME, _VERSION_INDEX)
#define _NGRAPH_RTTI_DEFINITION_SELECTOR(_1, _2, _3, _4, NAME, ...)

#define _NGRAPH_RTTI_DEFINITION_WITH_PARENT( \
    CLASS, \
    TYPE_NAME, \
    _VERSION_INDEX, \
    PARENT_CLASS \
    )

#define _NGRAPH_RTTI_EXPAND(X)
#define _TBB_REDUCE_FUNC
#define cu32(x)
#define strncasecmp

Detailed Documentation

Global Functions

ie_version_t ie_c_api_version(void)

Returns number of version that is exported. Use the ie_version_free() to free memory.

Returns:

Version number of the API.

void ie_version_free(ie_version_t* version)

Release the memory allocated by ie_c_api_version.

Parameters:

version

A pointer to the ie_version_t to free memory.

void ie_param_free(ie_param_t* param)

Release the memory allocated by ie_param_t.

Parameters:

param

A pointer to the ie_param_t to free memory.

Macros

#define AUTO_CONFIG_KEY(name)

A macro which provides an AUTO-mangled name for configuration key with name name

#define CLDNN_CONFIG_KEY(name)

shortcut for defining configuration keys

#define CONFIG_KEY(name)

shortcut for defining configuration keys

#define CONFIG_VALUE(name)

shortcut for defining configuration values

#define DECLARE_GPU_PARAM_KEY(name, ...)

Shortcut for defining object parameter keys.

#define DECLARE_GPU_PARAM_VALUE(name)

Shortcut for defining possible values for object parameter keys.

#define EXEC_NETWORK_METRIC_KEY(name)

shortcut for defining common Inference Engine ExecutableNetwork metrics

#define GNA_CONFIG_KEY(name)

Shortcut for defining configuration keys.

#define GNA_CONFIG_VALUE(name)

Shortcut for defining configuration values.

#define GPU_CONFIG_KEY(name)

shortcut for defining configuration keys

#define GPU_METRIC_KEY(name)

shortcut for defining GPU plugin metrics

#define GPU_PARAM_KEY(name)

Shortcut for defining configuration keys.

#define GPU_PARAM_VALUE(name)

Shortcut for defining configuration values.

#define HETERO_CONFIG_KEY(name)

Shortcut for defining HETERO configuration keys.

#define IE_ASSERT(EXPRESSION)

Uses assert() function if NDEBUG is not defined, InferenceEngine exception otherwise.

#define IE_DEFINE_EXTENSION_CREATE_FUNCTION(ExtensionType)

Generates extension creation function.

#define IE_EXCEPTION_SWITCH(STATUS, TYPE_ALIAS, ...)

Generate Switch statement over error codes adn maps them to coresponding exceptions type.

#define IE_THROW(...)

A macro used to throw specified exception with a description.

#define IE_VERSION_MAJOR

Defines Inference Engine major version.

#define IE_VERSION_MINOR

Defines Inference Engine minor version.

#define IE_VERSION_PATCH

Defines Inference Engine patch version.

#define METRIC_KEY(name)

shortcut for defining common Inference Engine metrics

#define METRIC_VALUE(name)

shortcut for defining metric values

#define MULTI_CONFIG_KEY(name)

A macro which provides a MULTI-mangled name for configuration key with name name

#define NGRAPH_CHECK(...)

Macro to check whether a boolean condition holds.

Parameters:

cond	Condition to check
…	Additional error message info to be added to the error message via the << stream-insertion operator. Note that the expressions here will be evaluated lazily, i.e., only if the cond evalutes to false.
ngraph::CheckFailure	if cond is false.

#define NGRAPH_RTTI_DECLARATION

Helper macro that puts necessary declarations of RTTI block inside a class definition. Should be used in the scope of class that requires type identification besides one provided by C++ RTTI. Recommended to be used for all classes that are inherited from class ngraph::Node to enable pattern matching for them. Accepts necessary type identification details like type of the operation, version and optional parent class.

Applying this macro within a class definition provides declaration of type_info static constant for backward compatibility with old RTTI definition for Node, static function get_type_info_static which returns a reference to an object that is equal to type_info but not necessary to the same object, and get_type_info virtual function that overrides Node::get_type_info and returns a reference to the same object that get_type_info_static gives.

Use this macro as a public part of the class definition:

class MyOp : public Node
{
    public:
        // Don't use Node as a parent for type_info, it doesn't have any value and
        prohibited
        NGRAPH_RTTI_DECLARATION;

        ...
};

class MyInheritedOp : public MyOp
{
    public:
        NGRAPH_RTTI_DECLARATION;

        ...
};

To complete type identification for a class, use NGRAPH_RTTI_DEFINITION.

#define NGRAPH_RTTI_DEFINITION(...)

Complementary to NGRAPH_RTTI_DECLARATION, this helper macro defines items declared by NGRAPH_RTTI_DECLARATION. Should be used outside the class definition scope in place where ODR is ensured.

Examples (see corresponding declarations in NGRAPH_RTTI_DECLARATION description):

NGRAPH_RTTI_DEFINITION(MyOp,"MyOp", 1);
NGRAPH_RTTI_DEFINITION(MyInheritedOp, "MyInheritedOp", 1, MyOp)

For convenience, TYPE_NAME and CLASS name are recommended to be the same.

Parameters:

CLASS	is a C++ name of the class where corresponding NGRAPH_RTTI_DECLARATION was applied.
TYPE_NAME	a string literal of type const char* that names your class in type identification namespace; It is your choice how to name it, but it should be unique among all NGRAPH_RTTI_DECLARATION-enabled classes that can be used in conjunction with each other in one transformation flow.
_VERSION_INDEX	is an unsigned integer index to distinguish different versions of operations that shares the same TYPE_NAME
PARENT_CLASS	is an optional direct or indirect parent class for this class; define it only in case if there is a need to capture any operation from some group of operations that all derived from some common base class. Don’t use Node as a parent, it is a base class for all operations and doesn’t provide ability to define some perfect subset of operations. PARENT_CLASS should define RTTI with NGRAPH_RTTI_{DECLARATION/DEFINITION} macros.

#define NGRAPH_UNREACHABLE(...)

Macro to signal a code path that is unreachable in a successful execution. It’s implemented with NGRAPH_CHECK macro.

Parameters:

…	Additional error message that should describe why that execution path is unreachable.
ngraph::CheckFailure	if the macro is executed.

#define TYPE_CASE(a)

Used in evaluator switch statement so that the case type and evaluate call are guaranteed to have the types match.

Use this in an evaluate_*() function like this switch (arg0->get_element_type()) {TYPE_CASE(i8) (arg0, arg1, out, broadcast_spec); break; TYPE_CASE(i16) (arg0, arg1, out, broadcast_spec); break;

Each TYPE_CASE statement expands like this: case element::Type_t::a: rc = evaluate<element::Type_t::a>(arg0, arg1, out, broadcast_spec)

Don’t forget to put a break after each statement or it will fall through and generate a runtime error.

#define VPU_HDDL_CONFIG_KEY(name)

Shortcut for defining VPU HDDL configuration key.

#define VPU_HDDL_CONFIG_VALUE(name)

Shortcut for defining VPU HDDL configuration value.

#define VPU_HDDL_METRIC(name)

Shortcut for defining VPU HDDL metric.

#define VPU_MYRIAD_CONFIG_KEY(name)

Shortcut for defining VPU MYRIAD configuration key.

#define VPU_MYRIAD_CONFIG_VALUE(name)

Shortcut for defining VPU MYRIAD configuration value.