Copy-On-Write в Swift: семантика, заблуждения и кастомная реализация

Разработчики Swift сталкиваются с механизмом копирования при записи (Copy-on-Write, COW) на ранних этапах работы с коллекциями, такими как массивы или строки. Эти типы ведут себя как типы значений, но при этом внутренне разделяют память между копиями. Этот метод позволяет Swift сохранять семантику значений, одновременно уменьшая ненужное дублирование памяти.

Понимание того, как работает этот механизм, дает практические преимущества. Оно проясняет, как коллекции Swift достигают своих характеристик производительности, улучшает понимание поведения памяти и позволяет проектировать пользовательские структуры данных, которые сочетают семантику значений с эффективным управлением памятью.

В этой статье рассматривается проектирование хранилища с механизмом копирования при записи в Swift, модели мышления, которые разработчики часто используют при рассуждениях об этом, и практическая реализация пользовательского контейнера COW.

Семантика значений и изоляция данных

Система типов Swift различает семантику значений (value semantics) и ссылочную семантику (reference semantics). Типы значений гарантируют изоляцию между экземплярами: при присваивании или передаче значения в функцию создаётся независимая копия, которая может изменяться без влияния на исходный объект.

Рассмотрим простую структуру, представляющую координату:

struct Coordinate {
    var latitude: Double
    var longitude: Double
}

var home = Coordinate(latitude: 51.5074, longitude: -0.1278)
var office = home

office.latitude = 40.7128

print(home.latitude)   // 51.5074
print(office.latitude) // 40.7128

Каждая переменная имеет собственное значение. Изменение одного значения оставляет другое неизменным.

Для небольших структур, состоящих из тривиальных типов, таких как Int, Bool или Double, копирование обычно включает в себя простое копирование в память, выполняемое компилятором.

Эта модель хорошо масштабируется для легковесных данных. С большими значениями в дело вступают дополнительные соображения.

Стоимость копирования больших значений

Представьте себе структуру, представляющую собой набор данных, загруженный в память:

struct LogArchive {
    var entries: [String]
    var source: String
}

При копировании этого значения массив элементов и исходная строка также должны быть скопированы в соответствии с семантикой значений. Когда значения содержат большие буферы или часто встречаются в присваиваниях, эти копирования могут стать дорогостоящими.

Стандартные коллекции Swift решают эту проблему за счет совместного использования хранилища. Несколько значений могут временно ссылаться на одно и то же базовое хранилище, при этом сохраняя семантику значений для внешнего мира.

Шаринг хранилища как метод проектирования

Механизм Copy-on-Write основан на разделении публичного типа-значения и его внутреннего хранилища.

• Тип значения выступает в качестве публичного интерфейса
• Ссылочный тип хранит фактические данные

Несколько значений могут совместно использовать один и тот же объект хранилища. При возникновении изменений значение, которое изменяется, получает собственную уникальную копию хранилища.

Концептуально, структура памяти выглядит следующим образом:

Value A ──┐
          ├── Shared Storage
Value B ──┘

После изменения:

Value A ─── Storage A
Value B ─── Storage B

Этот шаблон позволяет недорого копировать данные, сохраняя при этом предсказуемое поведение.

Проверка уникальности

Swift предоставляет рантайм функцию, которая позволяет реализовать этот подход:

isKnownUniquelyReferenced(_:)

Эта функция определяет, имеет ли экземпляр класса ровно одну сильную ссылку. Когда тип значения управляет хранением данных через класс, эта проверка позволяет реализации решить, необходимо ли копирование перед изменением.

Логика обычно следует следующему шаблону:

mutating func ensureUniqueStorage() {
    if !isKnownUniquelyReferenced(&storage) {
        storage = Storage(copying: storage)
    }
}

Изменение происходит только после того, как хранилище становится уникальным.

Разработка Copy-On-Write контейнера

Пользовательский тип с механизмом копирования при записи состоит из двух слоев:

• Тип значения, предоставляющий публичный API
• Ссылочный тип, хранящий базовое состояние

Следующий пример демонстрирует универсальный контейнер, в котором применяется эта архитектура.

public struct SharedBuffer<Element> {

    private final class Storage {
        var elements: [Element]

        init(_ elements: [Element]) {
            self.elements = elements
        }

        init(copying other: Storage) {
            self.elements = other.elements
        }
    }

    private var storage: Storage

    public init(_ elements: [Element]) {
        storage = Storage(elements)
    }

    public var elements: [Element] {
        get { 
        		storage.elements 
        }
        set {
            ensureUniqueStorage()
            storage.elements = newValue
        }
    }

    public mutating func append(_ element: Element) {
        ensureUniqueStorage()
        storage.elements.append(element)
    }

    private mutating func ensureUniqueStorage() {
        if !isKnownUniquelyReferenced(&storage) {
            storage = Storage(copying: storage)
        }
    }
}

Этот дизайн повторяет шаблон, используемый в стандартных коллекциях Swift.

Наблюдение за поведением

С точки зрения вызывающей стороны, контейнер ведёт себя как обычный тип значения.

var archiveA = SharedBuffer(["log1", "log2"])
var archiveB = archiveA

archiveB.append("log3")

print(archiveA.elements)
print(archiveB.elements)

После присваивания обе переменные ссылаются на одно и то же хранилище.

Когда archiveB изменяет буфер, проверка уникальности создает новый экземпляр хранилища.

Оптимизация изменений с помощью _modify

Swift предоставляет модификаторы доступа, которые позволяют более эффективно изменять хранимые свойства. Модификатор доступа _modify предоставляет вызывающей стороне доступ к изменяемому хранилищу, сохраняя при этом copy-on-write поведение.

Оптимизированная версия контейнера выглядит следующим образом:

public struct SharedBuffer<Element> {

    private final class Storage {
        var elements: [Element]

        init(_ elements: [Element]) {
            self.elements = elements
        }

        init(copying other: Storage) {
            self.elements = other.elements
        }
    }

    private var storage: Storage

    public init(_ elements: [Element]) {
        storage = Storage(elements)
    }

    public var elements: [Element] {
        _read {
            yield storage.elements
        }
        _modify {
            ensureUniqueStorage()
            yield &storage.elements
        }
    }

    private mutating func ensureUniqueStorage() {
        if !isKnownUniquelyReferenced(&storage) {
            storage = Storage(copying: storage)
        }
    }
}

Этот паттерн позволяет выполнять мутации «на месте» (in-place), сохраняя при этом гарантии семантики значений.

Мысленные модели, приводящие к путанице

В обсуждениях модели памяти Swift часто встречаются несколько упрощенных объяснений.

Распространенный мысленный шорткат предполагает, что структуры автоматически используют механизм копирования при записи. Вместо этого языковая модель Swift определяет семантику значений как наблюдаемое поведение. Копирование при записи представляет собой стратегию реализации, выбираемую конкретными типами.

Еще одно заблуждение приравнивает копирование при записи к глубокому копированию вложенных значений. Копирование при записи защищает хранилище контейнера. Элементы внутри контейнера могут по-прежнему ссылаться на разделяемые объекты.

Понимание этих различий помогает избежать неверных предположений об изоляции памяти.

Когда имеет смысл использовать кастомный COW

Собственные реализации механизма «копирование при записи» становятся ценными при соблюдении определенных условий:

• структура управляет большими объемами данных
• экземпляры копируются часто
• изменения происходят реже, чем чтения
• семантика значений остается желательной для проектирования API

Это сочетание часто встречается в коллекциях, буферах и доменных объектах, содержащих большие наборы данных.

Для небольших структур, состоящих из нескольких полей, прямое копирование обычно остается достаточно простым и эффективным.

Заключительные мысли

Механизм «копирование при записи» предоставляет практичный механизм для объединения семантики значений с эффективным использованием памяти. Этот метод позволяет нескольким значениям совместно использовать хранилище, сохраняя при этом предсказуемое поведение, ожидаемое от типов значений. Стандартные коллекции Swift в значительной степени основаны на этом дизайне, демонстрируя, как общее хранилище может сосуществовать с моделью программирования, ориентированной на значения.

Собственная реализация имеет простую структуру: обёртка-значение, ссылочное хранилище и проверка уникальности перед мутацией. Когда эти компоненты понятны, паттерн становится мощным инструментом при проектировании высокопроизводительных структур данных в Swift.

Источник