Shared-Pointer Memory Access for Fine-Grained Data Tiering

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Traditional virtual memory techniques in computing systems are computationally expensive, rely on host processor intervention, and result in coarse-grained changes to memory mappings, leading to inefficiencies as system memory capacity increases.

Innovation Solution

Indirect memory access using a shared pointer allows for lightweight, fine-grained memory management by enabling another device, such as a CXL memory device, to move data to new locations and update pointers, with cache coherency mechanisms ensuring consistency across devices.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If traditional virtual memory techniques are used, then memory management and process isolation are enabled, but computational overhead increases and system performance deteriorates as memory capacity scales

Engineering Contradiction:
Improvememory management capabilityVSAvoidsystem performance
Core Design Contradiction:
ReliabilityVSProductivity

Solution Approach 1:

The patent extracts the memory management functionality from the host processor to a dedicated memory device. The memory device independently manages its own address space, allocation, and mapping without requiring host processor intervention, thereby eliminating the computational overhead while maintaining memory management capabilities.

Inventive Principle:
Principle #2Taking out (Extraction)

Solution Approach 2:

The memory device performs self-service by autonomously handling memory allocation, address translation, and mapping operations. The device maintains its own page tables and can independently translate virtual addresses to physical addresses without burdening the host processor, improving system performance while maintaining reliability.

Inventive Principle:
Principle #25Self-service

2Reliability

If host processor manages memory allocations, then memory access control is maintained, but hardware overhead and processing overhead increase

Engineering Contradiction:
Improvememory access controlVSAvoidhardware overhead
Core Design Contradiction:
ReliabilityVSDevice complexity

Solution Approach 1:

The patent extracts memory control functionality from the host processor to the memory device itself. The memory device now independently performs allocation decisions, address translation, and access control, removing the hardware overhead from the host while maintaining proper memory access control through dedicated control logic in the memory device.

Inventive Principle:
Principle #2Taking out (Extraction)

3Reliability

If traditional memory mapping is used, then memory isolation is achieved, but memory changes are coarse-grained and flexibility is reduced

Engineering Contradiction:
Improvememory isolationVSAvoidmemory management flexibility
Core Design Contradiction:
ReliabilityVSAdaptability or versatility

Solution Approach 1:

The patent segments the memory address space into finer-grained units that can be independently managed. Instead of coarse-grained page-level management, the system allows for more granular allocation and mapping units, enabling flexible memory management while maintaining isolation through the segmented structure and independent control in the memory device.

Inventive Principle:
Principle #1Segmentation

Data Source

PatentUS20250321885A1Indirect memory access using shared pointer
Publication Date: 2025.10.16 MICRON TECHNOLOGY INC
  • US20250321885A1 patent drawing
  • US20250321885A1 patent drawing
  • US20250321885A1 patent drawing

AI summary

System and techniques for indirectly accessing an object in memory are described herein. A memory allocation request for an object is received that specifies use of a shared pointer. A memory address to fulfill this allocation is identified and a pointer to this address is written in a shared memory location accessible by both a host and a memory device. When the host requests the object, the host references the pointer to get the memory address of the object for the request. The memory device can then return the requested data.