Method LoadGraph

serializer/tengine/v2/tm2_serializer.cpp:612–705

}

bool TmSerializer2::LoadGraph(StaticGraph* graph, const TM2_Model* tm_model, void* mmap_buf)
{
    const TM2_Vector_offsets* v_graphs = GetTmPtr<TM2_Vector_offsets>(mmap_buf, tm_model->offset_vo_subgraphs);
    const TM2_Subgraph* tm_graph = GetTmPtr<TM2_Subgraph>(mmap_buf, v_graphs->offsets[0]);

    const TM2_Vector_offsets* v_nodes = GetTmPtr<TM2_Vector_offsets>(mmap_buf, tm_graph->offset_vo_seq_nodes);
    const TM2_Vector_offsets* v_tensors = GetTmPtr<TM2_Vector_offsets>(mmap_buf, tm_graph->offset_vo_tensors);
    const TM2_Vector_offsets* v_buffers = GetTmPtr<TM2_Vector_offsets>(mmap_buf, tm_graph->offset_vo_buffers);

    SetGraphLayout(graph, tm_graph->graph_layout);
    SetModelLayout(graph, tm_graph->model_layout);

    /* Load const tensors */
    for(unsigned int i = 0; i < v_tensors->v_num; i++)
    {
        const TM2_Tensor* tm_tensor = GetTmPtr<TM2_Tensor>(mmap_buf, v_tensors->offsets[i]);
        const TM2_Buffer* tm_buf;
        if(tm_tensor->type == kConstTensor)
            tm_buf = GetTmPtr<TM2_Buffer>(mmap_buf, v_buffers->offsets[tm_tensor->buffer_id]);
        else
            tm_buf = nullptr;
        LoadTensor(graph, tm_tensor, tm_buf, mmap_buf);
    }

    /* Create static nodes */
    unsigned int i;
    for(i = 0; i < v_nodes->v_num; i++)
    {
        const TM2_Node* tm_node = GetTmPtr<TM2_Node>(mmap_buf, v_nodes->offsets[i]);
        int idx = tm_node->node_id;
        std::string tm_node_name;
        if(tm_node->offset_s_nname == TM2_NOT_SET)
            tm_node_name = "node_" + std::to_string(idx);
        else
        {
            const TM2_String* tm_str = GetTmPtr<TM2_String>(mmap_buf, tm_node->offset_s_nname);
            tm_node_name.assign(GetTmPtr<char>(mmap_buf, tm_str->offset_data), tm_str->size - 1);
        }

        const TM2_Operator* tm_operator = GetTmPtr<TM2_Operator>(mmap_buf, tm_node->offset_t_operator);
        const std::string& tm_op_name = GetOpStr(tm_operator->operator_type);

        if(!FindOpLoadMethod(tm_op_name))
        {
            LOG_ERROR() << "cannot find load function for operator: " << tm_op_name << "\n";
            break;
        }

        StaticNode* node = CreateStaticNode(graph, tm_node_name);
        if(!LoadNode(graph, node, tm_node, mmap_buf))
            break;

        op_load_t op_func = any_cast<op_load_t>(GetOpLoadMethod(tm_op_name));

        if(!op_func(graph, node, mmap_buf, tm_operator))
            break;

        /* Set the dynamic shape of the operator */