Class ParamFusePass::VarNamer

src/gopt/impl/inference.cpp:431–495

! * \brief get name for new param */

 * \brief get name for new param
 */
class ParamFusePass::VarNamer {
#if MGB_BUILD_SLIM_SERVING
public:
    const std::string& name(VarNode*) {
        static std::string ret("fuse");
        return ret;
    }
#else
    using SrcSet = SharedSet<OperatorNodeBase*>;
    //! map from var to source SharedDeviceTensor/MultiSharedDeviceHolder oprs
    //! that it depends on
    ThinHashMap<OperatorNodeBase*, SrcSet> m_opr2srcs;
    std::string m_name_cache;
    std::vector<const char*> m_cur_name;

    SrcSet& get_src_set(OperatorNodeBase* opr) {
        auto opr_typeinfo = opr->dyn_typeinfo();

        auto iter = m_opr2srcs.find(opr);
        if (iter != m_opr2srcs.end()) {
            return iter->second;
        }
        auto&& ret = m_opr2srcs[opr];
        if (opr->input().empty()) {
            if (opr_typeinfo == opr::SharedDeviceTensor::typeinfo() ||
                opr_typeinfo == opr::MultipleDeviceTensorHolder::typeinfo()) {
                ret.insert(opr);
            } else {
                mgb_assert(opr_typeinfo == opr::ImmutableTensor::typeinfo());
            }
            return ret;
        }

        for (auto i : opr->input()) {
            ret.merge_from(get_src_set(i->owner_opr()));
        }
        return ret;
    }

public:
    const std::string& name(VarNode* var) {
        m_cur_name.clear();
        for (auto i : get_src_set(var->owner_opr())) {
            m_cur_name.push_back(i->cname());
        }

        auto cmp = [](const char* x, const char* y) { return strcmp(x, y) < 0; };
        std::sort(m_cur_name.begin(), m_cur_name.end(), cmp);
        m_name_cache.clear();
        m_name_cache.append(mgb_cstr_log("fuse("));
        bool first = true;
        for (auto i : m_cur_name) {
            if (first) {
                first = false;
            } else {
                m_name_cache.push_back(',');
            }
            m_name_cache.append(i);