neural_models.h

Go to the documentation of this file.

 
#ifndef OAKFIELD_NEURAL_MODELS_H
#define OAKFIELD_NEURAL_MODELS_H
 
#include "operators/neural/neural_infer.h"
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct SimContext;
 
#define SIM_NEURAL_MODEL_COMMAND_MAX 255U
#define SIM_NEURAL_MODEL_NOTE_MAX 127U
#define SIM_NEURAL_MODEL_ERROR_MAX 191U
 
typedef enum SimNeuralBackendKind {
    SIM_NEURAL_BACKEND_CALLBACK = 0,           
    SIM_NEURAL_BACKEND_EXTERNAL_PROCESS,       
    SIM_NEURAL_BACKEND_INPROCESS_ONNX_RUNTIME, 
    SIM_NEURAL_BACKEND_INPROCESS_LIBTORCH      
} SimNeuralBackendKind;
 
typedef enum SimNeuralExecutionDevice {
    SIM_NEURAL_EXEC_DEVICE_CPU = 0, 
    SIM_NEURAL_EXEC_DEVICE_CUDA,    
    SIM_NEURAL_EXEC_DEVICE_MPS      
} SimNeuralExecutionDevice;
 
#define SIM_NEURAL_DEVICE_MASK_CPU (1U << 0)
#define SIM_NEURAL_DEVICE_MASK_CUDA (1U << 1)
#define SIM_NEURAL_DEVICE_MASK_MPS (1U << 2)
 
typedef struct SimNeuralModelConfig {
    char model_id[SIM_NEURAL_MODEL_ID_MAX + 1U]; 
    SimNeuralBackendKind backend_kind;           
    uint32_t supported_device_mask; 
    SimNeuralPrecisionMode
        default_precision; 
    bool deterministic;    
    char external_command[SIM_NEURAL_MODEL_COMMAND_MAX + 1U]; 
    char note[SIM_NEURAL_MODEL_NOTE_MAX + 1U];                
    SimNeuralInferenceFn callback_fn;                         
    void *callback_userdata; 
} SimNeuralModelConfig;
 
typedef struct SimNeuralModelRuntimeStats {
    uint64_t invocation_count;            
    uint64_t success_count;               
    uint64_t failure_count;               
    uint64_t total_elements;              
    double last_wall_ms;                  
    double total_wall_ms;                 
    size_t last_step_index;               
    double last_sim_time;                 
    SimResult last_result;                
    SimNeuralExecutionDevice last_device; 
    char last_error[SIM_NEURAL_MODEL_ERROR_MAX + 1U]; 
} SimNeuralModelRuntimeStats;
 
typedef struct SimNeuralModelEntry {
    SimNeuralModelConfig config;      
    SimNeuralModelRuntimeStats stats; 
} SimNeuralModelEntry;
 
typedef struct SimNeuralModelRegistry {
    SimNeuralModelEntry *entries; 
    size_t count;                 
    size_t capacity;              
} SimNeuralModelRegistry;
 
SimNeuralModelConfig sim_neural_model_config_defaults(void);
 
void sim_neural_model_runtime_stats_reset(SimNeuralModelRuntimeStats *stats);
 
const char *sim_neural_backend_kind_name(SimNeuralBackendKind kind);
 
bool sim_neural_backend_kind_from_string(const char *text, SimNeuralBackendKind *out_kind);
 
const char *sim_neural_execution_device_name(SimNeuralExecutionDevice device);
 
bool sim_neural_execution_device_from_string(const char *text,
                                             SimNeuralExecutionDevice *out_device);
 
bool sim_neural_model_supports_device(const SimNeuralModelConfig *config,
                                      SimNeuralExecutionDevice device);
 
SimResult sim_neural_model_registry_init(SimNeuralModelRegistry *registry);
 
void sim_neural_model_registry_destroy(SimNeuralModelRegistry *registry);
 
SimResult sim_neural_model_register(struct SimContext *context, const SimNeuralModelConfig *config,
                                    size_t *out_index);
 
size_t sim_neural_model_count(const struct SimContext *context);
 
SimResult sim_neural_model_config_at(const struct SimContext *context, size_t model_index,
                                     SimNeuralModelConfig *out_config);
 
SimResult sim_neural_model_stats_at(const struct SimContext *context, size_t model_index,
                                    SimNeuralModelRuntimeStats *out_stats);
 
SimResult sim_neural_model_config(const struct SimContext *context, const char *model_id,
                                  SimNeuralModelConfig *out_config);
 
SimResult sim_neural_model_stats(const struct SimContext *context, const char *model_id,
                                 SimNeuralModelRuntimeStats *out_stats);
 
SimResult sim_neural_model_infer(struct SimContext *context, const char *model_id,
                                 const SimField *input, SimField *output,
                                 const SimNeuralInferenceRequest *request);
 
#ifdef __cplusplus
}
#endif
 
#endif /* OAKFIELD_NEURAL_MODELS_H */