Method trace_input

imperative/src/impl/transformations/trace.cpp:606–658

}

ValueRef CompiledTransformation::trace_input(size_t id, ValueRef value) {
    try {
        auto& var = m_vars[id];
        auto& var_accessor = m_var_accessors[id];
        switch (var.kind) {
            case VarKind::External: {
                trace_assert(
                        !value.is(m_value_type), "expect external node, got internal");
                if (var.bound_data) {
                    assert_tensor_equal(var.bound_data, value);
                } else {
                    DType dtype = *value.dtype();
                    CompNode device = *value.device();
                    trace_assert(
                            *var.dtype == dtype, "dtype mismatch: %s vs %s",
                            var.dtype->name(), dtype.name());
                    trace_assert(
                            *var.device == device, "comp_node mismatch: %s vs %s",
                            var.device->to_string().c_str(),
                            device.to_string().c_str());
                }
                if (m_setted_extern.find(id) == m_setted_extern.end()) {
                    var_accessor.data_setter(value.dev_tensor()->as_nd());
                    m_setted_extern.insert(id);
                }
                return value;
            }
            case VarKind::Constant: {
                // expect host value here
                mgb_assert(var.bound_data, "const var without data bound");
                assert_tensor_equal(var.bound_data, value);
                // TODO: use value
                return var.bound_data;
            }
            case VarKind::Internal: {
                trace_assert(
                        value.is(m_value_type), "expect internal node, got external");
                auto& traced_value = value.cast(m_value_type);
                trace_assert(traced_value.id() == id, "input id mismatch");
                return traced_value.get_imperative_value();
            }
            default:
                trace_assert(false, "unknown var kind");
        }
    } catch (TraceError&) {
        throw;
    } catch (const std::exception& exc) {
        mgb_log_error("unexpected error %s", exc.what());
        throw;
    } catch (...) {
        mgb_assert(false, "unexpected error");
    }
}

auto CompiledTransformation::trace_output(size_t id, ValueRef value)
        -> TracedValue::ref_t {