18 · Data와 바이트

import Foundation

print("MemoryLayout<Data>.size =", MemoryLayout<Data>.size)       // 16 (실측)
print("MemoryLayout<[UInt8]>.size =", MemoryLayout<[UInt8]>.size) // 8  (실측, Array는 포인터 하나)
print("MemoryLayout<NSData>.size =", MemoryLayout<NSData>.size)   // 8  (실측, 참조 하나 = 포인터)

let a = Data([1, 2, 3])
var b = a                       // 아직은 같은 버퍼를 공유 (복사 없음)
b.append(4)                     // 이 순간 CoW가 발동해 b만 새 버퍼로 분리된다
print(Array(a), Array(b))       // [1, 2, 3] [1, 2, 3, 4] — a는 그대로

import Foundation

// ✅ Foundation/네트워킹 경계에서는 Data를 그대로 들고 다닌다.
// URLSession, Codable, 파일 I/O 전부 Data를 공용 화폐로 쓰므로
// 왕복마다 [UInt8]로 바꿨다 되돌리는 변환 비용이 사라진다.
func fetchPayload(from url: URL) async throws -> Data {
    let (data, response) = try await URLSession.shared.data(from: url)
    guard let http = response as? HTTPURLResponse, http.statusCode == 200 else {
        throw URLError(.badServerResponse)
    }
    return data   // 호출자도 Data 그대로 받아 Codable에 바로 넘길 수 있다
}

import Foundation

// ✅ Foundation을 전혀 몰라도 되는 순수 계산 루틴이라면 [UInt8]이 더 자연스럽다.
// 제네릭 알고리즘(체크섬, 파서 콤비네이터 등)에 Foundation 의존을 끌고 들어가지 않아도 된다.
func xorChecksum(_ bytes: [UInt8]) -> UInt8 {
    bytes.reduce(0) { $0 ^ $1 }
}

// Data가 들어오는 경계에서만 한 번 변환하고, 그 안쪽은 순수 Swift로 남긴다.
func xorChecksum(of data: Data) -> UInt8 {
    xorChecksum(Array(data))
}

import Foundation
import Darwin

// 지금 이 프로세스의 resident(물리 메모리에 실제로 올라온 양)를 MB 단위로 반환
func residentMB() -> Double {
    var info = mach_task_basic_info()
    var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size / MemoryLayout<natural_t>.size)
    let kerr = withUnsafeMutablePointer(to: &info) {
        $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
            task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), $0, &count)
        }
    }
    guard kerr == KERN_SUCCESS else { return -1 }
    return Double(info.resident_size) / 1024 / 1024
}

let url = URL(fileURLWithPath: CommandLine.arguments[2])
print("시작: \(residentMB())MB")

if CommandLine.arguments[1] == "plain" {
    let data = try! Data(contentsOf: url)
    print("일반 읽기 후: \(residentMB())MB, count=\(data.count)")
} else {
    let data = try! Data(contentsOf: url, options: .mappedIfSafe)
    print("mappedIfSafe 후(안 만짐): \(residentMB())MB, count=\(data.count)")
}

import Foundation

// ❌ 옵션 없는 읽기: 파일 전체가 새 힙 버퍼로 복사된다.
// 실측(400MB 파일): resident/footprint 모두 즉시 +400MB — iOS엔 dirty 스왑이 없어 그대로 Jetsam 후보가 된다.
func loadPayload(_ url: URL) throws -> Data {
    try Data(contentsOf: url)
}

// ✅ 큰 파일 로딩 진입점은 기본을 mappedIfSafe로 뒤집는다.
// 실측: 같은 파일을 이 옵션으로 열면 resident/footprint가 기준선(≈수 MB)에서 그대로 멈춘다.
func loadPayloadMapped(_ url: URL) throws -> Data {
    try Data(contentsOf: url, options: .mappedIfSafe)
}

import Foundation

// ⚠️ 매핑해놓고 이렇게 처음부터 끝까지 훑어버리면(체크섬, 전수 파싱 등)
// 결국 모든 페이지를 건드리게 되어 "안 쓰는 페이지는 안 올라온다"는 이점이 사라진다.
func fullScanChecksum(_ data: Data) -> UInt8 {
    var sum: UInt8 = 0
    data.withUnsafeBytes { (buf: UnsafeRawBufferPointer) in
        for byte in buf { sum ^= byte }
    }
    return sum
}

// ✅ 정말 필요한 부분만 슬라이스해서 다룬다 — 예: 포맷 헤더만 읽고 나머지는 그대로 둔다.
func readHeader(_ data: Data, headerSize: Int = 4096) -> Data {
    data.prefix(headerSize)   // 이 4KB(=페이지 일부)만 실제로 물리 메모리에 올라온다
}

import Darwin

// phys_footprint — iOS가 Jetsam 여부를 판단할 때 실제로 비교하는 값
func footprintMB() -> Double {
    var info = task_vm_info_data_t()
    var count = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<integer_t>.size)
    let kerr = withUnsafeMutablePointer(to: &info) {
        $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
            task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), $0, &count)
        }
    }
    guard kerr == KERN_SUCCESS else { return -1 }
    return Double(info.phys_footprint) / 1024 / 1024
}

// Q2의 residentMB()와 나란히 찍으면 이 챕터 표의 세 시나리오를 그대로 재현할 수 있다.
print("resident=\(residentMB())MB footprint=\(footprintMB())MB")

import Darwin
import os

// 메모리 관련 로그에 resident 하나만 남기지 말고 footprint(및 남은 예산)를 함께 남긴다.
func logMemory(_ tag: String) {
    let remainingMB = os_proc_available_memory() / 1024 / 1024
    print("[\(tag)] resident=\(residentMB())MB footprint=\(footprintMB())MB 남은예산=\(remainingMB)MB")
}

import Foundation

// ✅ 매핑된 리소스는 읽기 전용으로만 접근해야 clean 상태(=footprint 열외)가 유지된다.
final class TileCache {
    private var tiles: [String: Data] = [:]

    func tile(named name: String, at url: URL) -> Data {
        if let cached = tiles[name] { return cached }
        // mappedIfSafe로 열어두면, 압박 시 커널이 알아서 회수했다가
        // 다시 접근할 때 파일에서 재적재해준다 — 앱이 직접 언로드 코드를 안 짜도 된다.
        let mapped = (try? Data(contentsOf: url, options: .mappedIfSafe)) ?? Data()
        tiles[name] = mapped
        return mapped
    }

    // ⚠️ 여기서 tiles[name]을 직접 수정(mutating)하면 그 순간 CoW가 발동해
    //    dirty 버퍼로 복사되며 clean 상태의 이점을 잃는다. 항상 새 Data로 교체할 것.
}

import Foundation
import Dispatch

func describeRegions<D: DataProtocol>(_ label: String, _ data: D) {
    let fast = data.withContiguousStorageIfAvailable { buf in buf.count }
    print("\(label): regions=\(data.regions.count) 연속뷰=\(fast != nil ? "성공" : "nil")")
}

let plain = Data(repeating: 0x11, count: 24)
describeRegions("Data(단일)", plain)   // regions=1 연속뷰=성공

var combined = DispatchData.empty
let a: [UInt8] = Array(repeating: 0xAA, count: 8)
let b: [UInt8] = Array(repeating: 0xBB, count: 8)
a.withUnsafeBytes { combined.append($0) }
b.withUnsafeBytes { combined.append($0) }
describeRegions("DispatchData(2조각)", combined)   // regions=2 연속뷰=nil

describeRegions("Data(DispatchData에서 생성)", Data(combined))  // regions=1 연속뷰=성공(복사됨)

import Foundation

// ✅ some/any DataProtocol을 받는 코드는 "포인터 하나"를 가정하지 않는다.
func hash<D: DataProtocol>(_ data: D) -> UInt64 {
    if let fast = data.withContiguousStorageIfAvailable({ buf -> UInt64 in
        computeHash(buf)   // 빠른 경로: 진짜 연속이면 복사 없이 바로 처리
    }) {
        return fast
    }
    // 느린 경로: 진짜 discontiguous하면 한 번 복사해서 연속 버퍼로 만든 뒤 처리한다.
    let contiguous = Array(data)
    return contiguous.withUnsafeBufferPointer { computeHash($0) }
}

func computeHash(_ buffer: UnsafeBufferPointer<UInt8>) -> UInt64 {
    var h: UInt64 = 0xcbf29ce484222325
    for byte in buffer { h = (h ^ UInt64(byte)) &* 0x100000001b3 }
    return h
}

import Foundation

var stash: UnsafeRawBufferPointer?

// ❌ 클로저가 끝나면 포인터가 가리키던 버퍼의 생존을 보장할 수 없다.
//    Apple 문서도 "클로저 호출 수명 밖에서 쓰지 말라"고 명시한다.
func captureDangling(_ data: Data) {
    data.withUnsafeBytes { buf in
        stash = buf   // ⚠️ 여기서 저장해봤자 클로저가 끝나면 무효화될 수 있다
    }
}

// ✅ 포인터가 아니라 내용을 복사해서 들고 나온다.
func captureSafely(_ data: Data) -> [UInt8] {
    data.withUnsafeBytes { buf in
        Array(buf)   // 클로저 안에서 값으로 복사해 반환 — 포인터 자체는 탈출하지 않는다
    }
}

import Foundation

// ❌ 흔한 실수: reduce(_:+)는 매 스텝마다 지금까지 만든 문자열을 통째로 새로 이어붙인다.
func hexSlow(_ data: Data) -> String {
    data.reduce("") { $0 + String(format: "%02x", $1) }
}

// ✅ 크기를 미리 계산해 버퍼를 한 번만 잡고 lookup table로 채운다 — O(n)
func hexFast(_ data: Data) -> String {
    let digits: [UInt8] = Array("0123456789abcdef".utf8)
    var out = [UInt8](repeating: 0, count: data.count * 2)
    var i = 0
    for byte in data {
        out[i] = digits[Int(byte >> 4)]
        out[i + 1] = digits[Int(byte & 0x0F)]
        i += 2
    }
    return String(decoding: out, as: UTF8.self)
}

// 실측(이 문서 작성 시): 5,000바이트 → hexSlow 3.8ms / hexFast 0.0ms
//                     200,000바이트 → hexSlow 701.9ms / hexFast 0.5ms

import Foundation

enum DecodeResult {
    case text(String)
    case invalidEncoding
}

// ✅ nil을 그냥 삼키지 않고 실패 경로를 명시적으로 분기한다.
func decodeStrict(_ data: Data) -> DecodeResult {
    guard let text = String(data: data, encoding: .utf8) else {
        return .invalidEncoding   // 잘린 응답/잘못된 charset을 여기서 잡아낸다
    }
    return .text(text)
}

// ⚠️ "일단 보여주기" 용도(로그, 디버깅 화면)가 아니라면 이 함수를 기본값으로 쓰지 않는다.
//    U+FFFD로 조용히 치환된 문자열이 실제 데이터인 것처럼 흘러들어갈 수 있다.
func decodeLossy(_ data: Data) -> String {
    String(decoding: data, as: UTF8.self)
}

import Foundation

// Base64는 3바이트를 4글자로 묶으므로 원본의 약 4/3배로 불어난다 — 용량 예산에 반영해야 한다.
func base64Size(of byteCount: Int) -> Int {
    Int((Double(byteCount) * 4 / 3).rounded(.up))
}

// 디버깅용 hex 로그는 hexFast(위)를 그대로 재사용한다 — reduce(_:+)로 새로 짜지 않는다.
func debugDescription(_ data: Data) -> String {
    "\(data.count)바이트, hex=\(hexFast(data.prefix(16)))..."
}