Method update_input_lite_tensors

lite/src/mge/network_impl.cpp:797–843

initialization lite_tensors when input is composed of discrete multiple tensors

//! initialization lite_tensors when input is composed of discrete multiple tensors
void NetworkImplDft::update_input_lite_tensors() {
    auto device_type = m_user_config->device_type;
    auto device_id = m_compnode_locator.device;
    auto stream_id = m_compnode_locator.stream;

    for (auto&& in_tensor_iter : m_load_result.tensor_map) {
        if (in_tensor_iter.first != m_user_config->discrete_input_name) {
            continue;
        }
        for (auto&& config_in : m_network_io->inputs) {
            if (in_tensor_iter.first == config_in.name) {
                size_t bs = in_tensor_iter.second->shape(0);
                auto shape = in_tensor_iter.second->shape();
                if (config_in.config_layout.ndim) {
                    bs = config_in.config_layout.shapes[0];
                    for (size_t i = 0; i < config_in.config_layout.ndim; ++i) {
                        shape.shape[i] = config_in.config_layout.shapes[i];
                    }
                }
                shape.shape[0] = 1;
                for (size_t i = 0; i < bs; ++i) {
                    HostTensorND tensor(
                            in_tensor_iter.second->comp_node(), shape,
                            in_tensor_iter.second->dtype(),
                            in_tensor_iter.second->format());
                    if (config_in.is_host) {
                        config_in.lite_tensors.push_back(std::make_shared<Tensor>(
                                device_id, stream_id, device_type, true));
                        TensorHelper::implement(config_in.lite_tensors[i])
                                ->cast_final_safe<TensorImplDft>()
                                .m_host_tensor = std::make_shared<HostTensorND>(tensor);
                        config_in.lite_tensors[i]->update_from_implement();
                    } else {
                        config_in.lite_tensors.push_back(std::make_shared<Tensor>(
                                device_id, stream_id, device_type));
                        config_in.lite_tensors[i]->set_layout(
                                to_lite_layout(tensor.layout()));
                    }
                    TensorHelper::implement(config_in.lite_tensors[i])
                            ->cast_final_safe<TensorImplDft>()
                            .m_record_reset =
                            m_user_config->options.comp_node_seq_record_level > 0;
                }
            }
        }
    }
}

void NetworkImplDft::update_output() {
    auto device_type = m_user_config->device_type;