type.h Source File

type.h Source File#

Runtime Library: type.h Source File
Runtime Library v0.30
Mobilint SDK qb
// Copyright ⓒ 2019- Mobilint Inc. All rights reserved.
 
#ifndef MACCEL_TYPE_H_
#define MACCEL_TYPE_H_
 
#include <cstdint>
#include <string>
#include <tuple>
#include <vector>
 
#include "maccel/export.h"
 
namespace mobilint {
enum class Cluster : int32_t {
    Cluster0 = 1 << 16,  
    Cluster1 = 2 << 16,  
    Error = 0x7FFF'0000, 
};
enum class Core : int32_t {
    Core0 = 1,                
    Core1 = 2,                
    Core2 = 3,                
    Core3 = 4,                
    All = 0x0000'FFFC,        
    GlobalCore = 0x0000'FFFE, 
    Error = 0x0000'FFFF,      
};
enum class CollaborationModel {
    Unified,
    Separated,
    Undefined,
};
enum class CoreStatus {
    Vacant,
    Ready,
    Idle,
    Running,
};
enum class SchedulePolicy {
    FIFO,
    LIFO,
    ByPriority,
    Undefined,
};
enum class LatencySetPolicy {
    Auto,
    Manual,
};
enum class MaintenancePolicy {
    Maintain,
    DropExpired,
    Undefined,
};
enum class InferenceResult {
    Successful,
    Expired,
    Unexpected,
};
enum class CoreAllocationPolicy {
    Auto,   
    Manual, 
};
struct Scale {
    std::vector<float> scale_list; 
    float scale = 0.0F;            
    bool is_uniform = false;       
    float operator[](int i) const {
        if (is_uniform) {
            return scale;
        }
        return scale_list[i];
    }
};
 
class Statistics;
struct CoreId {
    Cluster cluster = Cluster::Error; 
    Core core = Core::Error;          
    bool operator==(const CoreId& rhs) const {
        return std::tie(cluster, core) == std::tie(rhs.cluster, rhs.core);
    }
    bool operator<(const CoreId& rhs) const {
        return std::tie(cluster, core) < std::tie(rhs.cluster, rhs.core);
    }
};
struct Buffer {
    int8_t* data = nullptr; 
    uint64_t size = 0;      
};
enum class CoreMode : uint8_t {
    Single = 0,  
    Multi = 1,   
    Global = 2,  
    Global4 = 3, 
    Global8 = 4, 
    Error = 0xF, 
};
struct BufferInfo {
    // clang-format off
    uint32_t original_height = 0;  
    uint32_t original_width = 0;   
    uint32_t original_channel = 0; 
    uint32_t reshaped_height = 0;  
    uint32_t reshaped_width = 0;   
    uint32_t reshaped_channel = 0; 
    uint32_t height = 0;           
    uint32_t width = 0;            
    uint32_t channel = 0;          
    uint32_t max_height = 0;       
    uint32_t max_width = 0;        
    uint32_t max_channel = 0;      
    uint32_t max_cache_size = 0;   
    // clang-format on
    uint32_t original_size() const {
        return original_height * original_width * original_channel;
    }
    uint32_t reshaped_size() const {
        return reshaped_height * reshaped_width * reshaped_channel;
    }
    uint32_t size() const { return height * width * channel; }
};
class MACCEL_EXPORT ModelConfig {
public:
    ModelConfig();
    bool setSingleCoreMode(int num_cores);
    bool setSingleCoreMode(std::vector<CoreId> core_ids);
    bool setMultiCoreMode(std::vector<Cluster> clusters);
    bool setGlobal4CoreMode(std::vector<Cluster> clusters);
    bool setGlobal8CoreMode();
    CoreMode getCoreMode() const { return mCoreMode; }
    CoreAllocationPolicy getCoreAllocationPolicy() const { return mCoreAllocationPolicy; }
    int getNumCores() const { return mNumCores; }
    bool forceSingleNPUBundle(int npu_bundle_index);
    int getForcedNPUBundleIndex() const { return mForcedNPUBundleIndex; }
    const std::vector<CoreId>& getCoreIds() const { return mCoreIds; }
    void setAsyncPipelineEnabled(bool enable);
    bool getAsyncPipelineEnabled() const { return mAsyncPipelineEnabled; }
 
    explicit ModelConfig(int num_cores); 
 
    bool includeAllCores();                   
    bool excludeAllCores();                   
    bool include(Cluster cluster, Core core); 
    bool include(Cluster cluster);            
    bool include(Core core);                  
 
    bool exclude(Cluster cluster, Core core); 
    bool exclude(Cluster cluster);            
    bool exclude(Core core);                  
 
    bool setGlobalCoreMode(std::vector<Cluster> clusters); 
 
    bool setAutoMode(int num_cores = 1); 
    bool setManualMode();                
    SchedulePolicy schedule_policy = SchedulePolicy::FIFO;
    LatencySetPolicy latency_set_policy = LatencySetPolicy::Auto;
    MaintenancePolicy maintenance_policy = MaintenancePolicy::Maintain;
    std::vector<uint64_t> early_latencies;
    std::vector<uint64_t> finish_latencies;
 
private:
    CoreMode mCoreMode = CoreMode::Single;
    CoreAllocationPolicy mCoreAllocationPolicy = CoreAllocationPolicy::Manual;
    std::vector<CoreId> mCoreIds;
    int mNumCores;
    int mForcedNPUBundleIndex = -1;  // -1 means single npu bundle usage is not forced.
    bool mAsyncPipelineEnabled = false;
};
enum class LogLevel : char {
    DEBUG = 1,
    INFO = 2,
    WARN = 3,
    ERR = 4,
    FATAL = 5,
    OFF = 6,
};
enum class CacheType : uint8_t { Default = 0, Batch, Error = 0x0F };
struct CacheInfo {
    CacheType cache_type = CacheType::Error;
    std::string name;
    std::string layer_hash;
    uint64_t size = 0;
    size_t num_batches = 0;
};
 
MACCEL_EXPORT void setLogLevel(LogLevel level);
MACCEL_EXPORT bool startTracingEvents(const char* path);
MACCEL_EXPORT void stopTracingEvents();
MACCEL_EXPORT std::string getModelSummary(const std::string& mxq_path);
 
}  // namespace mobilint
 
#endif