memory-management

Mobile Memory Management

When to Use

Use this skill when:

• Optimizing for mobile memory constraints
• Preventing memory leaks
• Managing texture memory
• Implementing object pooling
• Handling low memory warnings
• Optimizing garbage collection

Core Principles

1. Proactive Disposal: Clean up resources explicitly
2. Object Pooling: Reuse instead of allocate
3. Texture Management: Compress and limit VRAM
4. Lazy Loading: Load resources on demand
5. Memory Monitoring: Track and respond to pressure
6. GC Optimization: Minimize garbage collection pauses

Memory Management Implementation

1. Resource Manager

// memory/ResourceManager.ts
export interface Disposable {
  dispose(): void;
}

export class ResourceManager {
  private resources = new Map<string, Disposable>();
  private refCounts = new Map<string, number>();
  private memoryUsage = 0;

  register<T extends Disposable>(id: string, resource: T): T {
    if (this.resources.has(id)) {
      // Resource already exists, increment ref count
      this.refCounts.set(id, (this.refCounts.get(id) ?? 0) + 1);
      return this.resources.get(id) as T;
    }

    this.resources.set(id, resource);
    this.refCounts.set(id, 1);

    // Track memory usage
    if ('memory' in resource) {
      this.memoryUsage += (resource as any).memory;
    }

    return resource;
  }

  get<T extends Disposable>(id: string): T | undefined {
    return this.resources.get(id) as T | undefined;
  }

  release(id: string): void {
    const refCount = this.refCounts.get(id) ?? 0;

    if (refCount <= 1) {
      // Last reference, dispose resource
      const resource = this.resources.get(id);
      if (resource) {
        resource.dispose();

        if ('memory' in resource) {
          this.memoryUsage -= (resource as any).memory;
        }
      }

      this.resources.delete(id);
      this.refCounts.delete(id);
    } else {
      // Decrement ref count
      this.refCounts.set(id, refCount - 1);
    }
  }

  getMemoryUsage(): number {
    return this.memoryUsage;
  }

  clear(): void {
    for (const resource of this.resources.values()) {
      resource.dispose();
    }

    this.resources.clear();
    this.refCounts.clear();
    this.memoryUsage = 0;
  }

  // Get resources sorted by memory usage
  getResourcesByMemory(): Array<{ id: string; memory: number }> {
    const resources: Array<{ id: string; memory: number }> = [];

    for (const [id, resource] of this.resources) {
      if ('memory' in resource) {
        resources.push({ id, memory: (resource as any).memory });
      }
    }

    return resources.sort((a, b) => b.memory - a.memory);
  }
}