Function parse_model

runtime/src/parse.c:419–556

all resource are allocate here

//! all resource are allocate here
TinyNNStatus parse_model(
        void* buffer, size_t size, int is_own_buffer, CombineModel* model,
        int share_weights) {
    load_kernel_init_function();
    ns(Model_table_t) fbs_model;
    if (!(fbs_model = ns(Model_as_root(buffer)))) {
        LOG_ERROR("Model not available\n");
        return -1;
    }
    if (is_own_buffer) {
        model->model_ptr = buffer;
        model->model_len = size;
    } else {
        model->model_ptr = NULL;
        model->model_len = 0;
    }
    //! name, model_id, device
    model->name = get_string(MegCC_Model_name(fbs_model));
    model->model_id = ns(Model_model_id(fbs_model));
    model->const_shape = ns(Model_const_shape(fbs_model));
    LOG_DEBUG(
            "log model: %s, model id: %zu, const shape: %d\n", model->name,
            model->model_id, model->const_shape);
    //! host device used to alloc weight
    memset(&(model->host_dev), 0, sizeof(Device));
    model->host_dev.device_type = TinyNN_BARE_METAL;
    TINYNN_ASSERT(init_device(&(model->host_dev)) == TinyNN_SUCCESS);

    //! parse weight
    ns(Weight_vec_t) fbs_weights = ns(Model_weight_pool(fbs_model));
    int nr_weight = ns(Weight_vec_len(fbs_weights));
    model->nr_origin_weight = nr_weight;
    model->weights = tinynn_malloc(sizeof(Tensor) * nr_weight);
    LOG_DEBUG("model weights number: %d\n", nr_weight);
    memset(model->weights, 0, sizeof(Tensor) * nr_weight);
    for (int i = 0; i < nr_weight; i++) {
        LOG_DEBUG("parse weight id: %d\n", i);
        ns(Weight_table_t) fbs_weight = ns(Weight_vec_at(fbs_weights, i));
        Tensor* weight = model->weights + i;
        if (parse_weight(weight, fbs_weight, &(model->host_dev)) != TinyNN_SUCCESS) {
            LOG_ERROR("parse weight error!\n");
            goto exit;
        }
    }

    //! parse device model
    ns(DeviceModel_vec_t) fbs_device_models = ns(Model_device_models(fbs_model));
    int nr_model = ns(DeviceModel_vec_len(fbs_device_models));
    int nr_valid_device_model = 0;
    {
        //! cal max memory for tensor and valid device model number
        size_t max_tensor_size = 0;
        for (int i = 0; i < nr_model; i++) {
            ns(DeviceModel_table_t) fbs_device_model =
                    ns(DeviceModel_vec_at(fbs_device_models, i));
            ns(Device_enum_t) fbs_device = ns(DeviceModel_device(fbs_device_model));
            TinyNNDevice device_enum = device_from_fbs(fbs_device);
            if (!valid_device_check(device_enum)) {