Class OperatorNodeConfig

src/core/include/megbrain/graph/operator_node.h:22–134

! * \brief configuration for operator nodes */

 * \brief configuration for operator nodes
 */
class OperatorNodeConfig final : public Hashable {
    MGB_DYN_TYPE_OBJ_FINAL_DECL_WITH_EXPORT;

public:
    using CompNodeArray = SmallVector<CompNode, 1>;

    OperatorNodeConfig() = default;
    MGE_WIN_DECLSPEC_FUC ~OperatorNodeConfig();

    OperatorNodeConfig(std::string name) : m_name{std::move(name)} {}

    OperatorNodeConfig(const CompNode& cn) { comp_node(cn); }

    OperatorNodeConfig(std::string name, const CompNode& cn, DType dtype = {})
            : m_name{std::move(name)}, m_output_dtype{dtype} {
        comp_node(cn);
    }

    explicit OperatorNodeConfig(DType dtype) : m_output_dtype{dtype} {};

    /*!
     * \brief make a name according to default name and input vars
     */
    std::string make_name(
            std::string default_name, const VarNodeArrayView& input_var,
            size_t opr_id) const;

    /*!
     * \brief set node name
     */
    OperatorNodeConfig& name(std::string name) {
        m_name = std::move(name);
        return *this;
    }

    const Maybe<std::string>& name() const { return m_name; }

    /*!
     * \brief update instance ID
     *
     * Instance ID is a hashed value used to differentiate multiple
     * instances of the same operator (with same inputs, params and
     * config), so the deduplication system can be bypassed.
     *
     * This method always updates underlying instance_id.
     */
    template <typename T>
    OperatorNodeConfig& update_instance_id(const T& p) {
        static_assert(
                std::is_pointer<T>::value,
                "update_instance_id can only accept a pointer");
        m_instance_id_hashed = hash_pair_combine(m_instance_id_hashed, mgb::hash(p));
        return *this;
    }

    /*!
     * \brief reset instance ID to the initial value
     */