Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

Use Copy-On-Write With Swift Value Types

DZone's Guide to

Use Copy-On-Write With Swift Value Types

Learn how to manually copy arrays in Swift to prevent performance problems in the app with this quick explanation and walkthrough.

· Mobile Zone ·
Free Resource

A variable in Swift can be either reference or value type. According to Apple, "The most basic distinguishing feature of a value type is that copying — the effect of assignment, initialization, and argument passing — creates an independent instance with its own unique copy of its data."

In this article, I explain an optimization of this copying: the copy-on-write.

What Is Copy-On-Write?

Every time we assign a value type to another one, we have a copy of the original object:

let myString = "Hello"
var myString2 = myString            // myString is copied to myString2
myString2.append(" World!")

print("\(myString) - \(myString2)") // prints "Hello - Hello World!"

If we copy just a plain String, we may not have problems with the performance. We may start having some trouble when we have Arrays with thousands of elements, and we copy them around our app. For this reason, the Array has a different way to copy, which is called copy-on-write.

When we assign an Array to another one, we don't have a copy. The two Arrays share the same instance. In this way, we don't have two different copies of a big Array and we can use the same instance, with a better performance. Then, just when one of the two Arrays change we have a copy.

Let's see an example:

var array1 = [1, 2, 3, 4]

address(of: array1)     // 0x60000006e420

var array2 = array1

address(of: array2)     // 0x60000006e420

array1.append(2)

address(of: array1)     // 0x6080000a88a0
address(of: array2)     // 0x60000006e420

We notice, in this example, that the two Arrays share the same address until one of them changes. In this way, we can assign array1 to other variables several times without copying the whole array every time, but just sharing the same instance until one of them changes. This is very useful for the performance of our app.

For your information, this is the function used to dump the address:

func address(of object: UnsafeRawPointer) -> String {
    let addr = Int(bitPattern: object)
    return String(format: "%p", addr)
}

Unfortunately, not all the value types have this behavior. This means that if we have a struct with a lot of information, we may need a copy-on-write to improve the performance of our app and avoid useless copies. For this reason, we have to create this behavior manually.

Manual Copy-On-Write

Let's consider a struct User in which we want to use copy-on-write:

struct User {
    var identifier = 1
}

We must start creating a class, with a generic property T, which wraps our value type:

final class Ref<T> {
    var value: T
    init(value: T) {
        self.value = value
    }
}

We use class—which is a reference type—because when we assign a reference type to another one the two variables will share the same instance, instead of copying it like the value type.

Then, we can create a struct to wrap Ref:

struct Box<T> {
    private var ref: Ref<T>
    init(value: T) {
        ref = Ref(value: value)
    }

    var value: T {
        get { return ref.value }
        set {
            guard isKnownUniquelyReferenced(&ref) else {
                ref = Ref(value: newValue)
                return
            }
            ref.value = newValue
        }
    }
}

Since struct is a value type, when we assign it to another variable, its value is copied, whereas the instance of the property refremains shared by the two copies since it's a reference type.

Then, the first time we change value of one the two Box variables, we create a new instance of ref thanks to:

guard isKnownUniquelyReferenced(&ref) else {
    ref = Ref(value: newValue)
    return
}

In this way, the two Box variables don't share the same ref instance anymore. isKnownUniquelyReferenced returns a boolean indicating whether the given object is known to have a single strong reference.

Here's the whole code:

final class Ref<T> {
    var value: T
    init(value: T) {
        self.value = value
    }
}

struct Box<T> {
    private var ref: Ref<T>
    init(value: T) {
        ref = Ref(value: value)
    }

    var value: T {
        get { return ref.value }
        set {
            guard isKnownUniquelyReferenced(&ref) else {
                ref = Ref(value: newValue)
                return
            }
            ref.value = newValue
        }
    }
}

We can use this wrapping like this:

let user = User()

let box = Box(value: user)
var box2 = box                  // box2 shares instance of box.ref

box2.value.identifier = 2       // Creates new object for box2.ref

An alternative to this approach is using an Array—instead of Box—to wrap the value type to copy on write. Unfortunately, the approach with the Array has some disadvantages. You can find more details in Apple's optimization tips.

Topics:
ios ,swift ,value types

Published at DZone with permission of

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}