Method LoadGraph

serializer/tengine/v1/tm1_serializer.cpp:450–539

}

bool TmSerializer1::LoadGraph(StaticGraph* graph, const TM_Model* tm_model, void* mmap_buf)
{
    const TM_Vector_offsets* v_graphs = GetTmPtr<TM_Vector_offsets>(mmap_buf, tm_model->offset_vo_subgraphs);
    const TM_Subgraph* tm_graph = GetTmPtr<TM_Subgraph>(mmap_buf, v_graphs->offsets[0]);

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

    /* Load const tensors */
    for(unsigned int i = 0; i < v_tensors->v_num; i++)
    {
        const TM_Tensor* tm_tensor = GetTmPtr<TM_Tensor>(mmap_buf, v_tensors->offsets[i]);
        const TM_Buffer* tm_buf;
        if(tm_tensor->type == kConstTensor)
            tm_buf = GetTmPtr<TM_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 TM_Node* tm_node = GetTmPtr<TM_Node>(mmap_buf, v_nodes->offsets[i]);
        int idx = tm_node->node_id;
        std::string tm_node_name;
        if(tm_node->offset_s_nname == NOT_SET)
            tm_node_name = "node_" + std::to_string(idx);
        else
        {
            const TM_String* tm_string = GetTmPtr<TM_String>(mmap_buf, tm_node->offset_s_nname);
            tm_node_name.assign(GetTmPtr<char>(mmap_buf, tm_string->offset_data), tm_string->size);
        }

        const TM_Operator* tm_operator = GetTmPtr<TM_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 */
        node->op->dynamic_shape = tm_node->dynamic_shape;
    }