swift-logging/Sources/LilithLogging/MemoryProfiler.swift

//
//  MemoryProfiler.swift
//  iOS Foundations
//
//  Memory usage tracking utilities
//

import Foundation

/// Memory usage information
public struct MemoryUsage {
    /// Memory used in bytes
    public let bytesUsed: UInt64

    /// Memory used formatted as megabytes
    public var formattedMB: String {
        String(format: "%.2f MB", Double(bytesUsed) / 1024.0 / 1024.0)
    }

    /// Memory used as megabytes (Double)
    public var megabytes: Double {
        Double(bytesUsed) / 1024.0 / 1024.0
    }
}

/// Utility for profiling memory usage
///
/// Use this to track memory consumption in your app and identify memory-intensive operations.
///
/// ## Example
///
/// ```swift
/// let before = MemoryProfiler.currentUsage()
/// performExpensiveOperation()
/// let after = MemoryProfiler.currentUsage()
///
/// let delta = after.bytesUsed - before.bytesUsed
/// print("Operation used \(delta / 1024 / 1024) MB")
/// ```
///
public enum MemoryProfiler {

    /// Get current memory usage
    ///
    /// - Returns: Current memory usage information
    ///
    public static func currentUsage() -> MemoryUsage {
        var taskInfo = mach_task_basic_info()
        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size) / 4
        let kerr: kern_return_t = withUnsafeMutablePointer(to: &taskInfo) {
            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
                task_info(
                    mach_task_self_,
                    task_flavor_t(MACH_TASK_BASIC_INFO),
                    $0,
                    &count
                )
            }
        }

        if kerr == KERN_SUCCESS {
            return MemoryUsage(bytesUsed: taskInfo.resident_size)
        } else {
            return MemoryUsage(bytesUsed: 0)
        }
    }

    /// Measure memory usage of a code block
    ///
    /// - Parameter block: The code block to measure
    /// - Returns: Memory delta (bytes used by the operation)
    ///
    /// ## Example
    ///
    /// ```swift
    /// let memoryUsed = MemoryProfiler.measure {
    ///     loadLargeDataset()
    /// }
    /// print("Operation used \(memoryUsed.formattedMB)")
    /// ```
    ///
    public static func measure(block: () -> Void) -> MemoryUsage {
        let before = currentUsage()
        block()
        let after = currentUsage()

        let delta = after.bytesUsed > before.bytesUsed
            ? after.bytesUsed - before.bytesUsed
            : 0

        return MemoryUsage(bytesUsed: delta)
    }

    /// Measure memory usage of an async code block
    ///
    /// - Parameter block: The async code block to measure
    /// - Returns: Memory delta (bytes used by the operation)
    ///
    public static func measure(block: () async -> Void) async -> MemoryUsage {
        let before = currentUsage()
        await block()
        let after = currentUsage()

        let delta = after.bytesUsed > before.bytesUsed
            ? after.bytesUsed - before.bytesUsed
            : 0

        return MemoryUsage(bytesUsed: delta)
    }
}