backend.h

Go to the documentation of this file.

 
#ifndef OAKFIELD_BACKEND_H
#define OAKFIELD_BACKEND_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "oakfield/field.h"
#include "oakfield/kernel_ir.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum SimBackendType {
    SIM_BACKEND_TYPE_CPU = 0, 
    SIM_BACKEND_TYPE_CUDA,    
    SIM_BACKEND_TYPE_METAL    
} SimBackendType;
 
typedef enum SimBackendFeature {
    SIM_BACKEND_FEATURE_NONE                 = 0ULL,      
    SIM_BACKEND_FEATURE_ANALYTIC_WARP        = 1ULL << 0, 
    SIM_BACKEND_FEATURE_BOUNDARY_AWARE_DIFFS = 1ULL << 1  
} SimBackendFeature;
 
typedef struct SimKernelIRBinding {
    size_t        field_index; 
    SimField*     field;       
    const size_t* shape;       
    const size_t* strides;     
    size_t        rank;        
} SimKernelIRBinding;
 
typedef struct SimKernelIROutput {
    size_t      field_index; 
    SimIRNodeId expression;  
} SimKernelIROutput;
 
typedef enum SimKernelComplexSemantics {
    SIM_KERNEL_COMPLEX_SEMANTICS_TRUE_COMPLEX = 0, 
    SIM_KERNEL_COMPLEX_SEMANTICS_COMPONENTWISE     
} SimKernelComplexSemantics;
 
typedef struct KernelIR {
    const SimIRBuilder*       builder;           
    const SimKernelIRBinding* bindings;          
    size_t                    binding_count;     
    const SimKernelIROutput*  outputs;           
    size_t                    output_count;      
    double*                   params;            
    size_t                    param_count;       
    uint64_t                  required_features; 
    SimKernelComplexSemantics complex_semantics; 
} KernelIR;
 
typedef struct SimBackend {
    SimBackendType type;       
    SimResult      last_error; 
    uint64_t       features;   
    void*          impl;       
} SimBackend;
 
void backend_init(SimBackend* backend);
 
void backend_launch(SimBackend* backend, KernelIR* kernel);
 
void backend_destroy(SimBackend* backend);
 
bool sim_backend_cpu_vdsp_enabled(const SimBackend* backend);
 
void sim_backend_cpu_set_vdsp_enabled(SimBackend* backend, bool enabled);
 
#ifdef SIM_TESTING
SimResult
sim_backend_metal_debug_copy_device_name(SimBackend* backend, char* out_name, size_t capacity);
 
SimResult sim_backend_metal_debug_get_pipeline_cache_count(SimBackend* backend, size_t* out_count);
 
SimResult sim_backend_metal_debug_get_total_pipeline_refcount(SimBackend* backend,
                                                              size_t*     out_total);
#endif
 
static inline bool backend_supports_features(const SimBackend* backend, uint64_t mask) {
    if (backend == NULL) {
        return false;
    }
    return (backend->features & mask) == mask;
}
 
static inline bool backend_supports_feature(const SimBackend* backend, SimBackendFeature feature) {
    return backend_supports_features(backend, (uint64_t) feature);
}
 
static inline void backend_enable_feature(SimBackend* backend, SimBackendFeature feature) {
    if (backend == NULL) {
        return;
    }
    backend->features |= (uint64_t) feature;
}
 
static inline void backend_disable_feature(SimBackend* backend, SimBackendFeature feature) {
    if (backend == NULL) {
        return;
    }
    backend->features &= ~((uint64_t) feature);
}
 
static inline void backend_set_features(SimBackend* backend, uint64_t mask) {
    if (backend == NULL) {
        return;
    }
    backend->features = mask;
}
 
static inline size_t sim_kernel_binding_width(const SimKernelIRBinding* binding) {
    if (binding == NULL || binding->shape == NULL || binding->rank == 0U) {
        return 0U;
    }
    return binding->shape[binding->rank - 1U];
}
 
static inline size_t sim_kernel_binding_height(const SimKernelIRBinding* binding) {
    if (binding == NULL || binding->shape == NULL || binding->rank == 0U) {
        return 0U;
    }
    if (binding->rank == 1U) {
        return 1U;
    }
    return binding->shape[binding->rank - 2U];
}
 
static inline SimResult sim_kernel_binding_index_to_xy(const SimKernelIRBinding* binding,
                                                       size_t                    index,
                                                       size_t*                   out_x,
                                                       size_t*                   out_y) {
    if (binding == NULL || out_x == NULL || out_y == NULL) {
        return SIM_RESULT_INVALID_ARGUMENT;
    }
 
    const size_t* shape   = binding->shape;
    const size_t* strides = binding->strides;
    size_t        rank    = binding->rank;
    if ((shape == NULL || strides == NULL || rank == 0U) && binding->field != NULL) {
        shape   = binding->field->layout.shape;
        strides = binding->field->layout.strides;
        rank    = binding->field->layout.rank;
    }
 
    if (shape == NULL || strides == NULL || rank == 0U) {
        return SIM_RESULT_INVALID_ARGUMENT;
    }
 
    size_t count = 1U;
    for (size_t i = 0U; i < rank; ++i) {
        if (shape[i] == 0U) {
            return SIM_RESULT_INVALID_ARGUMENT;
        }
        count *= shape[i];
    }
    if (index >= count) {
        return SIM_RESULT_INVALID_ARGUMENT;
    }
 
    if (rank == 1U) {
        *out_x = index;
        *out_y = 0U;
        return SIM_RESULT_OK;
    }
 
    size_t axis_x   = rank - 1U;
    size_t axis_y   = rank - 2U;
    size_t extent_x = shape[axis_x];
    size_t extent_y = shape[axis_y];
    size_t stride_x = strides[axis_x];
    size_t stride_y = strides[axis_y];
    if (extent_x == 0U || extent_y == 0U || stride_x == 0U || stride_y == 0U) {
        return SIM_RESULT_INVALID_ARGUMENT;
    }
 
    *out_x = (index / stride_x) % extent_x;
    *out_y = (index / stride_y) % extent_y;
    return SIM_RESULT_OK;
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* OAKFIELD_BACKEND_H */