type.h Source File

type.h Source File#

SDK qb Runtime Library: type.h Source File
SDK qb Runtime Library v1.3
MCS001-EN
// Copyright ⓒ 2019- Mobilint Inc. All rights reserved.
 
#ifndef QBRUNTIME_TYPE_H_
#define QBRUNTIME_TYPE_H_
 
#include <cstdint>
#include <string>
#include <tuple>
#include <vector>
 
#include "qbruntime/export.h"
 
namespace mobilint {
QBRUNTIME_EXPORT std::string getQbRuntimeVersion();
QBRUNTIME_EXPORT std::string getQbRuntimeGitVersion();
QBRUNTIME_EXPORT std::string getQbRuntimeVendor();
QBRUNTIME_EXPORT std::string getQbRuntimeProduct();
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 CoreAllocationPolicy {
    Auto,   
    Manual, 
};
struct Scale {
    std::vector<float> scale_list; 
    float scale = 0.0F;            
    bool is_uniform = false;       
    std::vector<int8_t>
        zero_points;       
    int8_t zero_point = 0; 
    bool is_asymmetric = false; 
    float operator[](int i) const {
        if (is_uniform) {
            return scale;
        }
        return scale_list[i];
    }
};
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, 
    Auto = 0xE,  
    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 QBRUNTIME_EXPORT ModelConfig {
public:
    ModelConfig();
    bool setAutoCoreMode();
    bool setSingleCoreMode(int num_cores);
    bool setSingleCoreMode(std::vector<CoreId> core_ids);
    bool setMultiCoreMode(std::vector<Cluster> clusters = {Cluster::Cluster0,
                                                           Cluster::Cluster1});
    bool setGlobal4CoreMode(std::vector<Cluster> clusters = {Cluster::Cluster0,
                                                             Cluster::Cluster1});
    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; }
 
    const std::vector<Cluster>& getClusters() const { return mClusters; }
    void setAsyncPipelineEnabled(bool enable);
    bool getAsyncPipelineEnabled() const { return mAsyncPipelineEnabled; }
    void setActivationSlots(int count);
    int getActivationSlots() const { return mActivationSlots; }
 
    explicit ModelConfig(int num_cores); 
 
    bool setGlobalCoreMode(std::vector<Cluster> clusters); 
    std::vector<uint64_t> early_latencies;
    std::vector<uint64_t> finish_latencies;
 
private:
    CoreMode mCoreMode = CoreMode::Auto;
    CoreAllocationPolicy mCoreAllocationPolicy = CoreAllocationPolicy::Manual;
    std::vector<Cluster> mClusters;
    std::vector<CoreId> mCoreIds;
    int mNumCores;
    int mForcedNPUBundleIndex = -1;  // -1 means single npu bundle usage is not forced.
    bool mAsyncPipelineEnabled = false;
    int mActivationSlots = 1;
};
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;
};
enum class DataType : uint8_t { Float32 = 0, Float16, Int8, Uint8, Error = 0x0F };
struct BatchParam {
    int sequence_length;
    int cache_size;
    int cache_id;
};
 
QBRUNTIME_EXPORT void setLogLevel(LogLevel level);
QBRUNTIME_EXPORT bool startTracingEvents(const char* path);
QBRUNTIME_EXPORT void stopTracingEvents();
QBRUNTIME_EXPORT std::string getModelSummary(const std::string& mxq_path);
QBRUNTIME_EXPORT std::vector<int> getAvailableDeviceNumbers();
 
}  // namespace mobilint
 
#endif