Class MemAllocPlan

src/core/include/megbrain/graph/var_node.h:34–222

! * \brief memory allocation plan held by a variable * * A MemAllocPlan is a view (i.e. with offset and layout) for some Chunk; Memory * sharing between vars is implemented by sharing a Chunk of their mem plans. */

 * sharing between vars is implemented by sharing a Chunk of their mem plans.
 */
class MemAllocPlan final : public json::Serializable, public NonCopyableObj {
public:
    /*!
     * \brief identifier for allocated memory
     *
     * Each Chunk object corresponds to an allocated memory chunk. Memory
     * forwarding and force updating are implemented by sharing Chunk
     * objects between vars.
     *
     * If mem_alloc_status is not invalid, the memory region for this chunk
     * is owner_var->dev_tensor().storage().
     */
    class Chunk : public NonCopyableObj {
        friend class MemAllocPlan;
        friend class VarDevMemDefragmenter;

        std::atomic_size_t m_refcnt;
        size_t m_size;

    public:
        /*!
         * \brief memory allocation status for this chunk
         *
         * Allocation status can either be INVALID, FROM_OWNER_VAR, or an
         * offset in a static allocation buffer. This status is compactly
         * represented by an integer value. No error check is performed in
         * the accessors.
         *
         * Note that for static_offset, it is set in
         * SeqMemOptimizer::plan_chunk_allocation() and accessed in
         * VarNodeMemManager::make_static_var_tensor_from_alloc_plan()
         */
        class MemAllocStatus {
            static constexpr size_t INVALID = 0, FROM_OWNER_VAR = 1, OFFSET = 2;
            size_t m_val = INVALID;

        public:
            //! whether memory is not allocated yet
            bool is_invalid() const { return m_val == INVALID; }

            //! whether memory comes from owner_var->dev_tensor()
            bool is_from_owner_var() const { return m_val == FROM_OWNER_VAR; }

            //! whether memory is statically allocated
            bool is_static_offset() const { return m_val >= OFFSET; }

            size_t static_offset() const { return m_val - OFFSET; }

            void set_invalid() { m_val = INVALID; }

            void set_from_owner_var() { m_val = FROM_OWNER_VAR; }

            void set_static_offset(size_t offset) { m_val = offset + OFFSET; }
        };

        //! var that first creates this chunk
        VarNode* const owner_var;