Function init_multi_likely_device_model

runtime/src/init.c:299–339

}

static TinyNNStatus init_multi_likely_device_model(CombineModel* combo_model) {
    DeviceModel* model = combo_model->device_models[0];
    int nr_instruction = model->nr_instruction;
    int total_processed_weights = count_total_processed_weights_number(combo_model, 0);
    LOG_DEBUG("calc total_processed_weights done\n");
    if (total_processed_weights < 1) {
        return TinyNN_SUCCESS;
    }
    //! allocate the processed memory

    for (int model_idx = 0; model_idx < combo_model->nr_device_model; ++model_idx) {
        if (model_idx == 0) {
            DeviceModel* model = combo_model->device_models[model_idx];
            model->nr_processed_weight = total_processed_weights;
            model->processed_weights =
                    tinynn_malloc(total_processed_weights * sizeof(Tensor));
            memset(model->processed_weights, 0,
                   total_processed_weights * sizeof(Tensor));
        } else {
            DeviceModel* model = combo_model->device_models[model_idx];
            //! this model  will share weights from model0
            model->nr_processed_weight = 0;
            model->processed_weights = NULL;
        }
    }
    int processed_weights_index = 0;
    for (int i = 0; i < nr_instruction; i++) {
        Instruction* inst = model->instructions + i;
        if (inst->tag == TinyNN_INST_OPR) {
            Opr* opr = &inst->workload.opr;
            int size = get_ins_nr_processed_weights(opr, model);
            if (size == 1) {
                Tensor* weight = model->processed_weights + processed_weights_index;
                init_ins_weights(opr, model, weight);
                broadcast_postprocess_weight_memory(i, combo_model, weight);
                processed_weights_index += size;
            }
        }
    }
    return TinyNN_SUCCESS;
}

TinyNNStatus init_model_weights(CombineModel* combo_model) {
    if (!combo_model) {