8-29.【内存管理机制】在自定义 CoW 类型中，如何使用 isKnownUniquelyReferenced 优化性能？

在自定义类型中实现 写时复制（Copy-on-Write, CoW） ，核心目标是减少不必要的堆内存分配（Heap Allocation）。通过 isKnownUniquelyReferenced，我们可以让自定义 struct 在独占底层数据时表现得像“原地修改”的引用类型，在被共享时表现得像安全的值类型。

以下是实现高性能 CoW 类型的标准模式和优化策略：

---

1. 标准实现模式：三位一体结构

要实现 CoW，你需要三个组件：

1. Storage (Class) ：实际存放数据的引用类型。
2. Wrapper (Struct) ：暴露给用户的值类型。
3. Unique Check：在修改前通过 isKnownUniquelyReferenced 进行判定。

Swift

final class BigDataStorage {
    var data: [Int]
    init(data: [Int]) { self.data = data }
    
    // 关键优化：提供一个克隆方法
    func copy() -> BigDataStorage {
        return BigDataStorage(data: self.data)
    }
}

struct MyOptimizedArray {
    private var _storage: BigDataStorage

    init(data: [Int]) {
        _storage = BigDataStorage(data: data)
    }

    mutating func append(_ item: Int) {
        // 核心性能开关
        if !isKnownUniquelyReferenced(&_storage) {
            // 只有当存在多个引用时，才执行 O(n) 的拷贝
            _storage = _storage.copy() 
        }
        // 引用唯一，执行 O(1) 的原地修改
        _storage.data.append(item)
    }
}

---

2. 进阶性能优化技巧

A. 避免“检查前增计”

isKnownUniquelyReferenced 接收的是 inout 参数。在调用它之前，千万不要将 storage 赋值给临时变量，否则会因为临时引用导致检查永远返回 false。

Swift

// ❌ 错误做法：性能损耗，导致每次都拷贝
mutating func update() {
    let currentStorage = _storage 
    if !isKnownUniquelyReferenced(&_storage) { ... } 
}

// ✅ 正确做法：直接传入
mutating func update() {
    if !isKnownUniquelyReferenced(&_storage) { ... }
}

B. 使用 final 类加速

确保你的 Storage 类被标记为 final。这可以禁用动态派发（Dynamic Dispatch），让编译器进行更激进的内联优化，进一步提升访问速度。

C. 批量修改优化

如果你有一系列连续的写操作，isKnownUniquelyReferenced 只会在第一次修改时触发拷贝。一旦拷贝完成，后续操作由于引用计数已降为 1，将全部变为原地修改。

Swift

var myArr = MyOptimizedArray(data: [1, 2, 3])
var otherArr = myArr // 引用计数 = 2

myArr.append(4) // 触发拷贝，O(n)
myArr.append(5) // 原地修改，O(1)
myArr.append(6) // 原地修改，O(1)

---

3. 内存布局视图

通过 CoW 优化，你可以显著降低内存峰值。当多个实例共享同一数据时，它们在内存中只占用一份大内存块和多个微小的结构体指针。

---

4. 为什么要手动实现？

Swift 虽然为 Array 实现了 CoW，但以下情况需要你手动实现：

• 复合数据结构：你的类型内部包含多个数组或大型嵌套结构。
• 自定义缓存：你需要精确控制什么时候释放底层资源。
• 特定协议要求：你需要一个符合 RandomAccessCollection 且具备值语义的高性能类型。

总结建议

使用 isKnownUniquelyReferenced 优化性能时，请始终牢记：它是针对“写”操作的优化。对于只读操作，CoW 本身是无感知的。在编写 mutating 方法时，养成“先检查唯一性，再修改”的习惯，是写出高性能 Swift 代码的关键。

8-29. [Memory Management] How to use isKnownUniquelyReferenced to optimize performance in custom CoW types?

In custom types, the primary goal of implementing Copy-on-Write (CoW) is to reduce unnecessary heap allocations. By using isKnownUniquelyReferenced, you can make a custom struct behave like a high-performance reference type (in-place mutation) when it exclusively owns its data, while maintaining the safety of a value type when shared.

Here is the standard implementation pattern and optimization strategies for high-performance CoW types:

---

1. The Standard Implementation Pattern: The "Trinity" Structure

To implement CoW effectively, you need three components:

1. Storage (Class) : A private reference type that actually holds the data.
2. Wrapper (Struct) : The public value type exposed to users.
3. Uniqueness Check: A logic gate using isKnownUniquelyReferenced before any mutation.

Swift

final class BigDataStorage {
    var data: [Int]
    init(data: [Int]) { self.data = data }
    
    // Key Optimization: Provide a cloning method
    func copy() -> BigDataStorage {
        return BigDataStorage(data: self.data)
    }
}

struct MyOptimizedArray {
    private var _storage: BigDataStorage

    init(data: [Int]) {
        _storage = BigDataStorage(data: data)
    }

    mutating func append(_ item: Int) {
        // The Core Performance Switch
        if !isKnownUniquelyReferenced(&_storage) {
            // Only perform the O(n) copy when multiple references exist
            _storage = _storage.copy() 
        }
        // If unique, perform O(1) in-place mutation
        _storage.data.append(item)
    }
}

---

2. Advanced Performance Optimization Tips

A. Avoid "Pre-check Increment"

isKnownUniquelyReferenced takes an inout parameter. Do not assign the storage to a temporary local variable before calling it. Doing so creates an additional strong reference, causing the check to always return false and forcing a redundant copy.

Swift

// ❌ INCORRECT: Performance loss, forces copy every time
mutating func update() {
    let currentStorage = _storage  // Reference count becomes 2
    if !isKnownUniquelyReferenced(&_storage) { ... } 
}

// ✅ CORRECT: Pass directly
mutating func update() {
    if !isKnownUniquelyReferenced(&_storage) { ... } // Checks the original count
}

B. Use final Classes for Speed

Ensure your Storage class is marked as final. This prevents subclassing and allows the compiler to use static dispatch instead of dynamic dispatch, enabling aggressive inlining and faster access speeds.

C. Batch Mutation Optimization

If you have a sequence of consecutive write operations, isKnownUniquelyReferenced will only trigger a copy during the first modification. Once the copy is made, the reference count for the new storage will be 1, turning all subsequent operations into $O(1)$ in-place mutations.

Swift

var myArr = MyOptimizedArray(data: [1, 2, 3])
var otherArr = myArr // Reference count = 2

myArr.append(4) // Triggers copy, O(n)
myArr.append(5) // In-place mutation, O(1)
myArr.append(6) // In-place mutation, O(1)

---

3. Why Implement it Manually?

While Swift provides CoW for Array, you should implement it manually for:

• Composite Data Structures: Your type contains multiple arrays or large nested structures that should be treated as a single value.
• Custom Caching: You need precise control over when the underlying heap resources are allocated or freed.
• Protocol Requirements: You are building a high-performance type that conforms to RandomAccessCollection but requires strict value semantics.

---

Summary and Advice

When optimizing with isKnownUniquelyReferenced, remember: it is an optimization for "Write" operations. For read-only operations, CoW is completely transparent. Developing the habit of "check uniqueness first, then mutate" in your mutating methods is key to writing high-performance Swift code.