Does swift copy on write for all structs?

by

Array is implemented with copy-on-write behaviour – you’ll get it regardless of any compiler optimisations (although of course, optimisations can decrease the number of cases where a copy needs to happen).

At a basic level, Array is just a structure that holds a reference to a heap-allocated buffer containing the elements – therefore multiple Array instances can reference the same buffer. When you come to mutate a given array instance, the implementation will check if the buffer is uniquely referenced, and if so, mutate it directly. Otherwise, the array will perform a copy of the underlying buffer in order to preserve value semantics.

However, with your Point structure – you’re not implementing copy-on-write at a language level. Of course, as @Alexander says, this doesn’t stop the compiler from performing all sorts of optimisations to minimise the cost of copying whole structures about. These optimisations needn’t follow the exact behaviour of copy-on-write though – the compiler is simply free to do whatever it wishes, as long as the program runs according to the language specification.

In your specific example, both p1 and p2 are global, therefore the compiler needs to make them distinct instances, as other .swift files in the same module have access to them (although this could potentially be optimised away with whole-module optimisation). However, the compiler still doesn’t need to copy the instances – it can just evaluate the floating-point addition at compile-time and initialise one of the globals with 0.0, and the other with 1.0.

And if they were local variables in a function, for example:

struct Point {
    var x: Float = 0
}

func foo() {
    var p1 = Point()
    var p2 = p1
    p2.x += 1
    print(p2.x)
}

foo()

The compiler doesn’t even have to create two Point instances to begin with – it can just create a single floating-point local variable initialised to 1.0, and print that.

Regarding passing value types as function arguments, for large enough types and (in the case of structures) functions that utilise enough of their properties, the compiler can pass them by reference rather than copying. The callee can then make a copy of them only if needed, such as when needing to work with a mutable copy.

In other cases where structures are passed by value, it’s also possible for the compiler to specialise functions in order to only copy across the properties that the function needs.

For the following code:

struct Point {
    var x: Float = 0
    var y: Float = 1
}

func foo(p: Point) {
    print(p.x)
}

var p1 = Point()
foo(p: p1)

Assuming foo(p:) isn’t inlined by the compiler (it will in this example, but once its implementation reaches a certain size, the compiler won’t think it worth it) – the compiler can specialise the function as:

func foo(px: Float) {
    print(px)
}

foo(px: 0)

It only passes the value of Point‘s x property into the function, thereby saving the cost of copying the y property.

So the compiler will do whatever it can in order to reduce the copying of value types. But with so many various optimisations in different circumstances, you cannot simply boil the optimised behaviour of arbitrary value types down to just copy-on-write.

More Related Contents:

  1. AnyObject and Any in Swift
  2. Dictionary in Swift with Mutable Array as value is performing very slow? How to optimize or construct properly?
  3. How to seed the Int.random method call in Swift?
  4. Concatenate dictionary values in Swift
  5. Migrating Swift code to Swift 3.0 LOADS of errors
  6. Overriding methods in Swift extensions
  7. Alternative to performSelector in Swift?
  8. NSObject subclass in Swift: hash vs hashValue, isEqual vs ==
  9. Return instancetype in Swift
  10. Changing the Status Bar Color for specific ViewControllers using Swift in iOS8
  11. Does Swift have documentation generation support?
  12. == overload for custom class is not always called
  13. Is it possible to replicate Swifts automatic numeric value bridging to Foundation (NSNumber) for (U)Int8/16/32/64 types?
  14. Sheet inside ForEach doesn’t loop over items SwiftUI
  15. Fetch data from CoreData for iOS 14 widget
  16. fatal error: swapping a location with itself is not supported with Swift 2.0
  17. Swift and mutating struct
  18. How do I import a Swift file from another Swift file?
  19. What is the point of having two different names for the same parameter?
  20. Swift lazy instantiating using self
  21. What’s the simplest way to convert from a single character String to an ASCII value in Swift?
  22. How to create local scopes in Swift?
  23. Swift – How to mutate a struct object when iterating over it
  24. How add tabs programmatically in UITabBarController with swift?
  25. How to use a @FetchRequest with the new searchable modifier in SwiftUI?
  26. No such module ‘RestKit’ with cocoapods and swift
  27. What’s the difference between using ARAnchor to insert a node and directly insert a node?
  28. How String Comparison happens in Swift
  29. What is the reduce() function doing, in Swift
  30. Core Data Predicate Filter By Today’s Date

Leave a Comment