cldnn.h

/*
// 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.
*/

#ifndef CLDNN_H
#define CLDNN_H

// exporting symbols form dynamic library
#ifdef EXPORT_NEURAL_SYMBOLS
#   if defined(_MSC_VER)
//  Microsoft
#      define CLDNN_API __declspec(dllexport)
#   elif defined(__GNUC__)
//  GCC
#      define CLDNN_API __attribute__((visibility("default")))
#   else
#      define CLDNN_API
#      pragma warning Unknown dynamic link import/export semantics.
#   endif
#else //import dll
#   if defined(_MSC_VER)
//  Microsoft
#      define CLDNN_API __declspec(dllimport)
#   elif defined(__GNUC__)
//  GCC
#      define CLDNN_API
#   else
#      define CLDNN_API
#      pragma warning Unknown dynamic link import/export semantics.
#   endif
#endif

#include <stdint.h>
#include <stddef.h>








#ifdef __cplusplus
extern "C" {
#endif

#define CLDNN_SUCCESS                0
#define CLDNN_ERROR                 -1
#define CLDNN_INVALID_ARG           -2
#define CLDNN_OUT_OF_RESOURCES      -3
#define CLDNN_DEVICE_ERROR          -4
#define CLDNN_UNSUPPORTED_SIZE      -5
#define CLDNN_UNSUPPORTED_FORMAT    -6
#define CLDNN_DIMENSION_MISMATCH    -7
#define CLDNN_ALLOC_SIZE_EXCEEDED   -8
#define CLDNN_GLOBAL_SIZE_EXCEEDED  -9

typedef int32_t cldnn_status;

typedef struct
{
    int32_t major;    
    int32_t minor;    
    int32_t build;    
    int32_t revision; 
} cldnn_version;

typedef struct cldnn_engine_impl* cldnn_engine;

typedef struct cldnn_event_impl* cldnn_event;

typedef struct cldnn_topology_impl* cldnn_topology;

typedef struct cldnn_program_impl* cldnn_program;

typedef struct cldnn_network_impl* cldnn_network;

typedef struct cldnn_memory_impl* cldnn_memory;


typedef enum /*:int32_t*/
{
    cldnn_engine_ocl 
} cldnn_engine_type;

typedef struct
{
    uint32_t enable_profiling;         
    uint32_t meaningful_kernels_names; 
    uint32_t dump_custom_program;      
    const char* compiler_options;      
    const char* single_kernel_name;    
    uint32_t enable_parallelisation;   
    const char* engine_log;            
    const char* sources_dumps_dir;     
    uint32_t priority_mode;            
}  cldnn_engine_configuration;

typedef struct
{
    uint32_t cores_count;              
    uint32_t core_frequency;           

    uint64_t max_work_group_size;      
    uint64_t max_local_mem_size;       
    uint64_t max_global_mem_size;      
    uint64_t max_alloc_mem_size;       

    // Flags (for layout compatibility fixed size types are used).
    uint8_t supports_fp16;             
    uint8_t supports_fp16_denorms;     
    uint8_t supports_subgroups_short;  
}  cldnn_engine_info;


typedef void(*cldnn_event_handler)(void*);

typedef struct
{
    const char* name;                   
    uint64_t nanoseconds;
} cldnn_profiling_interval;

typedef enum /*:int32_t*/
{
    cldnn_build_option_fusing,                  
    cldnn_build_option_optimize_data,           
    cldnn_build_option_debug,                   
    cldnn_build_option_outputs,                 
    cldnn_build_option_tuning_config,           
    cldnn_build_option_graph_dumps_dir          
} cldnn_build_option_type;

typedef enum /*:int32_t*/
{
    cldnn_tuning_disabled,          
    cldnn_tuning_use_cache,         
    cldnn_tuning_tune_and_cache,    
} cldnn_tuning_mode_type;

struct cldnn_tuning_config
{
    const int32_t mode;             
    const char* cache_file_path;    
};

typedef struct
{
    int32_t type;                       
    const void* data;                   
}  cldnn_build_option;

typedef struct
{
    cldnn_event event;                  
    cldnn_memory memory;                
} cldnn_network_output;



typedef enum /*:int32_t*/
{
    cldnn_format_yxfb,          
    cldnn_format_byxf,          
    cldnn_format_bfyx,          
    cldnn_format_fyxb,          
    cldnn_format_os_iyx_osv16,  
    cldnn_format_bs_xs_xsv8_bsv8, 
    cldnn_format_bs_xs_xsv8_bsv16,
    cldnn_format_bs_x_bsv16,    
    cldnn_format_bf8_xy16,      
    cldnn_format_image_2d_weights_c4_fyx_b, 
    cldnn_format_image_2d_weights_c1_b_fyx, 
    cldnn_format_format_num,    
    cldnn_format_any = -1
} cldnn_format_type;

#define CLDNN_FLOAT_TYPE_MASK 0x80
#define CLDNN_UINT_TYPE_MASK 0x40

#define CLDNN_TENSOR_BATCH_DIM_MAX 1
#define CLDNN_TENSOR_FEATURE_DIM_MAX 1
#define CLDNN_TENSOR_SPATIAL_DIM_MAX 2
#define CLDNN_TENSOR_DIM_MAX 8

typedef struct
{
    size_t batch_num;
    size_t feature_num;
    size_t spatial_num;
    int32_t sizes[CLDNN_TENSOR_DIM_MAX];
} cldnn_tensor;

typedef struct
{
    cldnn_tensor lower_size; 
    cldnn_tensor upper_size; 
    float filling_value;     
} cldnn_padding;

typedef enum /*:size_t*/
{
    cldnn_i8  = sizeof(int8_t),
    cldnn_f16 = sizeof(int16_t) | CLDNN_FLOAT_TYPE_MASK,
    cldnn_f32 = sizeof(float) | CLDNN_FLOAT_TYPE_MASK,
    cldnn_u8  = sizeof(uint8_t) | CLDNN_UINT_TYPE_MASK // TODO: move to top of list and re-compile inference engine

} cldnn_data_type;

typedef struct
{
    size_t data_type;       
    int32_t format;         
    cldnn_tensor size;      
    cldnn_padding padding;  
} cldnn_layout;


typedef struct
{
    const float* data; 
    size_t size;       
} cldnn_float_arr;

typedef struct
{
    const uint16_t* data; 
    size_t size;       
} cldnn_uint16_t_arr;

typedef struct
{
    const cldnn_tensor* data; 
    size_t size;       
} cldnn_tensor_arr;

typedef const struct cldnn_primitive_type* cldnn_primitive_type_id;

typedef const char* cldnn_primitive_id;

typedef struct
{
    const cldnn_primitive_id* data; 
    size_t size;                    
} cldnn_primitive_id_arr;

typedef const char*  cldnn_kernel_code;
typedef cldnn_kernel_code* cldnn_kernels_code;
typedef const char*  cldnn_kernel_entry_point;
typedef const char*  cldnn_kernel_build_options;
typedef const size_t*  cldnn_work_group_sizes;

typedef enum cldnn_arg_type_t
{
    arg_input,
    arg_output,
} cldnn_arg_type;

typedef uint32_t cldnn_arg_index;

typedef struct cldnn_arg_t
{
    cldnn_arg_type arg_type;
    cldnn_arg_index index;
} cldnn_arg;

typedef const cldnn_arg* cldnn_kernel_arguments;

typedef enum cldnn_activation_func_t
{
    activation_none,                    // val
    activation_logistic,                // 1/(1 + exp(-val))
    activation_hyperbolic_tan,          // tanh(val)
    activation_relu,                    // max(0, val)
    activation_relu_negative_slope,     // max(0, val) + a * min(0, val)    (a is additional param)
    activation_clamp,                   // max(a, min(b, val)               (a,b are additional param)
    activation_softrelu,                // log(1 + exp(val))
    activation_abs,                     // abs(val)
    activation_linear,                  // a*val + b                        (a,b are additional params) 
    activation_square,                  // val*val
    activation_sqrt,                    // sqrt(val)
} cldnn_activation_func;

typedef struct cldnn_activation_additional_params_t
{
    float a, b;
} cldnn_activation_additional_params;

#define CLDNN_BEGIN_PRIMITIVE_DESC(PType) struct cldnn_##PType##_desc {\
    cldnn_primitive_type_id type; \
    cldnn_primitive_id id;        \
    cldnn_primitive_id_arr input; \
    cldnn_padding output_padding; 
#define CLDNN_END_PRIMITIVE_DESC(PType) };

#define CLDNN_PRIMITIVE_DESC(PType) cldnn_##PType##_desc

CLDNN_BEGIN_PRIMITIVE_DESC(primitive)
CLDNN_END_PRIMITIVE_DESC(primitive)


CLDNN_API cldnn_version cldnn_get_version(cldnn_status* status);


CLDNN_API cldnn_topology cldnn_create_topology(cldnn_status* status);

CLDNN_API void cldnn_add_primitive(cldnn_topology topology, const struct CLDNN_PRIMITIVE_DESC(primitive)* dto, cldnn_status* status);

CLDNN_API void cldnn_get_primitive_ids(cldnn_topology topology, char* ids, size_t size, size_t* size_ret, cldnn_status* status);

CLDNN_API void cldnn_retain_topology(cldnn_topology topology, cldnn_status* status);

CLDNN_API void cldnn_release_topology(cldnn_topology topology, cldnn_status* status);


CLDNN_API uint32_t cldnn_get_engine_count(/*cldnn_engine_type*/ int32_t type, cldnn_status* status);

CLDNN_API cldnn_engine cldnn_create_engine(/*cldnn_engine_type*/ int32_t type, uint32_t engine_num, const cldnn_engine_configuration* configuration, cldnn_status* status);

CLDNN_API void cldnn_retain_engine(cldnn_engine engine, cldnn_status* status);

CLDNN_API void cldnn_release_engine(cldnn_engine engine, cldnn_status* status);

CLDNN_API cldnn_engine_info cldnn_get_engine_info(cldnn_engine engine, cldnn_status* status);

CLDNN_API /*cldnn_engine_type*/ int32_t cldnn_get_engine_type(cldnn_engine engine, cldnn_status* status);


CLDNN_API cldnn_event cldnn_create_user_event(cldnn_engine engine, cldnn_status* status);

CLDNN_API int32_t cldnn_is_user_event(cldnn_event event, cldnn_status* status);

CLDNN_API void cldnn_retain_event(cldnn_event event, cldnn_status* status);

CLDNN_API void cldnn_release_event(cldnn_event event, cldnn_status* status);

CLDNN_API void cldnn_wait_for_event(cldnn_event event, cldnn_status* status);

CLDNN_API void cldnn_set_event(cldnn_event event, cldnn_status* status);

CLDNN_API void cldnn_add_event_handler(cldnn_event event, cldnn_event_handler handler, void* param, cldnn_status* status);

CLDNN_API void cldnn_get_event_profiling_info(cldnn_event event, cldnn_profiling_interval* profiling, size_t size, size_t* size_ret, cldnn_status* status);


CLDNN_API cldnn_program cldnn_build_program(cldnn_engine engine, cldnn_topology topology, cldnn_build_option* options, size_t options_num, cldnn_status* status);

CLDNN_API void cldnn_retain_program(cldnn_program program, cldnn_status* status);

CLDNN_API void cldnn_release_program(cldnn_program program, cldnn_status* status);


CLDNN_API        cldnn_network cldnn_build_network(cldnn_engine engine, cldnn_topology topology, cldnn_build_option* options, size_t options_num, cldnn_status* status);

CLDNN_API        cldnn_network cldnn_allocate_network(cldnn_program program, cldnn_status* status);

CLDNN_API                 void cldnn_retain_network(cldnn_network network, cldnn_status* status);

CLDNN_API                 void cldnn_release_network(cldnn_network network, cldnn_status* status);

CLDNN_API                 void cldnn_set_network_input(cldnn_network network, cldnn_primitive_id id, cldnn_memory mem, cldnn_status* status);

CLDNN_API void cldnn_get_primitive_info(cldnn_network network, cldnn_primitive_id id, char* info, size_t size, size_t* size_ret, cldnn_status* status);

CLDNN_API         cldnn_engine cldnn_get_network_engine(cldnn_network network, cldnn_status* status);

CLDNN_API        cldnn_program cldnn_get_network_program(cldnn_network network, cldnn_status* status);

CLDNN_API                 void cldnn_get_network_output_names(cldnn_network network, char* names, size_t size, size_t* size_ret, cldnn_status* status);

CLDNN_API                 void cldnn_get_network_executed_primitive_names(cldnn_network network, char* names, size_t size, size_t* size_ret, cldnn_status* status);

CLDNN_API                 void cldnn_get_network_all_primitive_names(cldnn_network network, char* names, size_t size, size_t* size_ret, cldnn_status* status);

CLDNN_API                 void cldnn_get_network_all_primitive_org_names(cldnn_network network, char* names, size_t size, size_t* size_ret, cldnn_status* status);

CLDNN_API                 void cldnn_execute_network(cldnn_network network, cldnn_event* dependencies, size_t deps_num, cldnn_status* status);

CLDNN_API cldnn_network_output cldnn_get_network_output(cldnn_network network, const char* name, cldnn_status* status);

CLDNN_API cldnn_memory cldnn_get_network_output_memory(cldnn_network network, const char* name, cldnn_status* status);

CLDNN_API cldnn_event cldnn_get_network_output_event(cldnn_network network, const char* name, cldnn_status* status);


CLDNN_API cldnn_memory cldnn_allocate_memory(cldnn_engine engine, cldnn_layout layout, cldnn_status* status);
CLDNN_API cldnn_memory cldnn_attach_memory(cldnn_layout layout, void* pointer, size_t size, cldnn_status* status);
CLDNN_API int32_t cldnn_is_the_same_buffer(cldnn_memory mem1, cldnn_memory mem2, cldnn_status* status);
CLDNN_API void cldnn_retain_memory(cldnn_memory memory, cldnn_status* status);
CLDNN_API void cldnn_release_memory(cldnn_memory memory, cldnn_status* status);
CLDNN_API void* cldnn_lock_memory(cldnn_memory memory, cldnn_status* status);
CLDNN_API void cldnn_unlock_memory(cldnn_memory memory, cldnn_status* status);
CLDNN_API cldnn_layout cldnn_get_memory_layout(cldnn_memory memory, cldnn_status* status);
CLDNN_API cldnn_engine cldnn_get_memory_engine(cldnn_memory memory, cldnn_status* status);
CLDNN_API uint16_t cldnn_float_to_half(float,cldnn_status*);
CLDNN_API float cldnn_half_to_float(uint16_t, cldnn_status*);



CLDNN_API const char* cldnn_get_last_error_message();

#ifdef __cplusplus
}
#endif


//primitives
#ifdef __cplusplus
#define CLDNN_DECLARE_PRIMITIVE_TYPE_ID(PType) extern "C" CLDNN_API cldnn_primitive_type_id cldnn_##PType##_type_id(cldnn_status* status)
#else
#define CLDNN_DECLARE_PRIMITIVE_TYPE_ID(PType) CLDNN_API cldnn_primitive_type_id cldnn_##PType##_type_id(cldnn_status* status)
#endif


#endif /* CLDNN_H */