Struct IntegratedMemoryManager 

pub struct IntegratedMemoryManager { /* private fields */ }

Integrated memory management system

Implementations

impl IntegratedMemoryManager

pub fn new(config: MemoryManagementConfig) -> Self

Create new integrated memory manager

pub fn start_background_management( &mut self, ) -> Result<(), MemoryManagementError>

Start background memory management

pub fn stop_background_management(&mut self)

Stop background memory management

pub fn run_garbage_collection( &mut self, _memory_regions: &HashMap<usize, MemoryRegion>, ) -> Result<usize, MemoryManagementError>

Run garbage collection

memory_regions describes the caller’s current view of live allocations, but it is intentionally not registered with GarbageCollectionEngine: that engine only selects a collector for a region when region.utilization < mark_threshold (see MarkSweepCollector::can_collect), while every region built by the current caller is a single allocation at 100% utilization. Feeding such regions in would turn every call into a hard GCError::NoSuitableCollector instead of today’s harmless no-op. Tracked as a finding rather than force-integrated; see the crate’s lint/unwrap sweep notes.

pub fn prefetch( &mut self, address: *mut c_void, size: usize, access_pattern: Option<&str>, ) -> Result<bool, MemoryManagementError>

Perform prefetch operation

Records the access with the PrefetchingEngine so its access-history tracker and pattern strategies see real data; the returned bool reflects whether this access was itself a hit against data the engine had already prefetched (a genuine cache hit), not a fabricated value.

pub fn evict_memory( &mut self, target_bytes: usize, memory_regions: &HashMap<usize, MemoryRegion>, ) -> Result<usize, MemoryManagementError>

Perform memory eviction

Registers memory_regions with the EvictionEngine (most-pressured, then largest, region first) and evicts real objects from it via the engine’s active policy until target_bytes have been reclaimed or there is nothing left to evict. The returned count is the true sum of evicted object sizes, not an estimate.

pub fn defragment( &mut self, _memory_regions: &HashMap<usize, MemoryRegion>, ) -> Result<usize, MemoryManagementError>

Run defragmentation

memory_regions is intentionally not registered with DefragmentationEngine: both built-in compaction strategies require MemoryLayoutTracker::get_total_free_space() > 0 to be eligible (can_handle), but the current caller only ever reports one region per live allocation with no free space (region size == its single object’s size). Registering that data would not change the outcome (DefragError::NoSuitableStrategy either way) and free-space tracking would need to be added at the caller first. Tracked as a finding rather than force-integrated; see the crate’s lint/unwrap sweep notes.

pub fn handle_memory_pressure( &mut self, memory_usage_ratio: f64, memory_regions: &HashMap<usize, MemoryRegion>, ) -> Result<(), MemoryManagementError>

Check memory pressure and trigger appropriate management

pub fn update_access_pattern( &mut self, address: *mut c_void, size: usize, access_type: AccessType, ) -> Result<(), MemoryManagementError>

Update access patterns for adaptive management

Feeds the access into the PrefetchingEngine’s access-history tracker (mapped from this module’s coarse AccessType to prefetching::AccessType) so its pattern strategies observe real traffic instead of being permanently starved of data.

pub fn get_stats(&self) -> &ManagementStats

Get management statistics

pub fn get_gc_stats(&self) -> GCStats

Get garbage collection stats

pub fn get_prefetch_performance(&self) -> PrefetchPerformance

Get prefetch performance

pub fn optimize_policies(&mut self) -> Result<(), MemoryManagementError>

Optimize management policies based on workload