Method dump_var

src/plugin/impl/opr_io_dump.cpp:260–360

}

void TextOprIODump::dump_var(VarNode* var, bool lazy_sync) {
    MGB_LOCK_GUARD(m_mtx);
    auto fout = m_fout.get();
    auto opr = var->owner_opr();
    bool valid = var->dev_tensor_valid();

    bool print_var_produce = true;
    if (lazy_sync) {
        if (!m_lazy_value) {
            m_lazy_value = std::make_unique<LazyValueRecorder>();
            fprintf(fout, "==== begin lazy value recording\n");
        }
        if (valid) {
            print_var_produce = m_lazy_value->record_var(var);
        } else {
            print_var_produce = false;
        }
    }

    if (print_var_produce) {
        fprintf(fout, "var%zd produced: name=%s layout=%s owner_opr=%s{%s} opr%zd\n",
                var->id(), var->cname(),
                valid ? var->layout().to_string().c_str() : "<invalid>", opr->cname(),
                opr->dyn_typeinfo()->name, opr->id());
    }

    if (!valid || !print_var_produce)
        return;

    auto print_var_val = [&](VarNode* var, bool print_stat = false) {
        if (lazy_sync) {
            fprintf(fout, "<see lazy value below>");
            return;
        }
        if (!var->dev_tensor_valid()) {
            fprintf(fout, "<invalid>");
            return;
        }

        HostTensorND hv;
        hv.copy_from(var->dev_tensor()).sync();
        print_host_val(fout, m_max_size, hv.as_megdnn(), print_stat);
        if (m_print_addr) {
            fprintf(fout, "  <%p>", var->dev_tensor().raw_ptr());
        }
    };

    fprintf(fout, " deps:\n");

    ThinHashMap<VarNode*, int> var2iid;
    for (size_t i = 0; i < opr->input().size(); ++i)
        var2iid[opr->input(i)] = i;

    using DT = cg::OperatorNodeBase::NodeProp::DepType;
    // [(input_id, var_id, var, dep_type)]
    SmallVector<std::tuple<int, size_t, VarNode*, DT>> dep_vars;
    for (auto&& dep_entry : opr->node_prop().dep_map()) {
        int inp_id = -1;