Function parse_device_model

runtime/src/parse.c:297–400

}

TinyNNStatus parse_device_model(
        DeviceModel* model, CombineModel* c_model,
        ns(DeviceModel_table_t) fbs_device_model) {
    //! parse tensor
    ns(Tensor_vec_t) fbs_tensors = ns(DeviceModel_tensor_pool(fbs_device_model));
    int nr_tensor = ns(Tensor_vec_len(fbs_tensors));
    LOG_DEBUG("device model tensor number: %d\n", nr_tensor);
    model->nr_tensor = nr_tensor;
    model->tensors = tinynn_malloc(sizeof(Tensor) * nr_tensor);
    memset(model->tensors, 0, sizeof(Tensor) * nr_tensor);
    for (int i = 0; i < nr_tensor; i++) {
        LOG_DEBUG("parse tensor id: %d\n", i);
        ns(Tensor_table_t) fbs_tensor = ns(Tensor_vec_at(fbs_tensors, i));
        Tensor* tensor = model->tensors + i;
        if (parse_tensor(tensor, fbs_tensor, i) != TinyNN_SUCCESS) {
            LOG_ERROR("parse tensor error!\n");
            goto exit;
        }
    }

    //! parse instructions
    ns(Instruction_union_vec_t) fbs_instructions_union =
            ns(DeviceModel_instructions_union(fbs_device_model));
    int nr_instruction = ns(Instruction_union_vec_len(fbs_instructions_union));
    LOG_DEBUG("device model instruction number: %d\n", nr_instruction);
    model->nr_instruction = nr_instruction;
    model->instructions = tinynn_malloc(sizeof(Instruction) * nr_instruction);
    memset(model->instructions, 0, sizeof(Instruction) * nr_instruction);
    for (int i = 0; i < nr_instruction; i++) {
        LOG_DEBUG("parse instruction id: %d\n", i);
        ns(Instruction_union_t) fbs_instruction_union =
                ns(Instruction_union_vec_at(fbs_instructions_union, i));
        Instruction* inst = model->instructions + i;
        if (vm_instruction_load((VM*)(c_model->vm), fbs_instruction_union, inst) !=
            TinyNN_SUCCESS) {
            goto exit;
        }
    }

    //! inputs
    flatbuffers_int32_vec_t fbs_inputs = ns(DeviceModel_inputs(fbs_device_model));
    model->nr_input = flatbuffers_int32_vec_len(fbs_inputs);
    model->inputs = tinynn_malloc(model->nr_input * sizeof(Tensor*));
    memset(model->inputs, 0, model->nr_input * sizeof(Tensor*));
    for (int i = 0; i < model->nr_input; i++) {
        int index = flatbuffers_int32_vec_at(fbs_inputs, i);
        *(model->inputs + i) = model->tensors + index;
        (*(model->inputs + i))->is_input = 1;
    }
    //! outputs
    flatbuffers_int32_vec_t fbs_outputs = ns(DeviceModel_outputs(fbs_device_model));
    flatbuffers_int32_vec_t fbs_weight_outputs =
            ns(DeviceModel_weight_outputs(fbs_device_model));
    flatbuffers_string_vec_t fbs_weight_outputs_name =
            ns(DeviceModel_weight_outputs_name(fbs_device_model));
    int nr_outputs = flatbuffers_int32_vec_len(fbs_outputs);
    int nr_weight_outputs = flatbuffers_int32_vec_len(fbs_weight_outputs);
    TINYNN_ASSERT(