ictonyx.memory

GPU and system memory monitoring utilities.

Memory management for ictonyx with two modes: 1. Standard (default): Fast in-process execution with best-effort cleanup 2. Process isolation (opt-in): Guaranteed cleanup via subprocess with smart serialization

Process isolation uses cloudpickle when available to serialize notebook-defined functions, making it work seamlessly in Jupyter environments.

class ictonyx.memory.MemoryResult(success, actions=<factory>, errors=<factory>, memory_before_mb=None, memory_after_mb=None, memory_freed_mb=None, mode='standard')

Bases: object

Result of memory operations.

Parameters:

• success (bool)

• actions (list)

• errors (list)

• memory_before_mb (float | None)

• memory_after_mb (float | None)

• memory_freed_mb (float | None)

• mode (str)

success: bool

actions: list

errors: list

memory_before_mb: float | None = None

memory_after_mb: float | None = None

memory_freed_mb: float | None = None

mode: str = 'standard'

class ictonyx.memory.MemoryManager(use_process_isolation=False, gpu_memory_limit=None, process_timeout=3600, allow_memory_growth=True, verbose=True)

Bases: object

Unified memory manager for both standard and process-isolated training.

Standard mode (default): Fast in-process execution with cleanup Process isolation mode: Subprocess execution with guaranteed cleanup

Parameters:

• use_process_isolation (bool)

• gpu_memory_limit (int | None)

• process_timeout (int)

• allow_memory_growth (bool)

• verbose (bool)

__init__(use_process_isolation=False, gpu_memory_limit=None, process_timeout=3600, allow_memory_growth=True, verbose=True)

Initialize memory manager.

Parameters:

• use_process_isolation (bool) – If True, run in isolated subprocess

• gpu_memory_limit (int | None) – GPU memory limit in MB

• process_timeout (int) – Timeout for subprocess execution

• allow_memory_growth (bool) – Allow GPU memory to grow as needed

• verbose (bool) – Print informative messages

setup()

Configure memory constraints for standard mode. Must be called before any GPU operations.

Return type:

bool

cleanup()

Perform memory cleanup (standard mode only).

Return type:

MemoryResult

run_isolated(func, args=(), kwargs=None)

Run function in isolated subprocess with smart serialization.

Automatically uses cloudpickle if available for notebook functions, falls back to standard pickle for module functions.

Parameters:

• func (Callable)

• args (tuple)

• kwargs (Dict | None)

Return type:

Dict[str, Any]

ictonyx.memory.get_memory_manager(use_process_isolation=False, **kwargs)

Create a memory manager.

Parameters:

• use_process_isolation (bool) – Enable subprocess isolation (default: False)

• **kwargs – Additional options

Returns:

Configured MemoryManager

Return type:

MemoryManager

ictonyx.memory.managed_memory(use_process_isolation=False, **kwargs)

Context manager for memory-managed operations.

Examples

# Standard mode (default) with managed_memory():

model.fit(…)

# Process isolation for extended runs with managed_memory(use_process_isolation=True):

for i in range(100):

train_model()

Parameters:

use_process_isolation (bool)

ictonyx.memory.cleanup_gpu_memory()

Quick GPU memory cleanup.

Return type:

MemoryResult

ictonyx.memory.get_memory_info()

Get current memory usage.

Return type:

Dict[str, Any]

ictonyx.memory.check_isolation_capability(func)

Check if a function can be used with process isolation.

Returns:

(can_isolate, reason)

Parameters:

func (Callable)

Return type:

Tuple[bool, str]