Adding the @inlinable attribute to library methods turns out to be the most important step to activate more aggressive compiler optimization across modules, some of which are placed in Swift packages. A Vector struct in the library (Swift package) uses this one-liner method very frequently:
// @inline(__always)
@inlinable
mutating func elem(_ k: Int, _ num: Grain) {
_array[istart + k*stride] = num
}
Replacing @inline(__always) with @inlinable solved the problem, and the running times of a simple test function, which increments a collection of 1000 random integers, reduced from 92 microseconds to 3 microseconds. This is quite surprising to me, as inlining this simple line sounds like a good option. However, it turns out that the compiler does a much better job with possibly having more flexibility with the @inlinable option.
Before solving the problem as described above, after posting this question yesterday, I started writing a simple package and a project importing it to reproduce the problem. I used the default Package.swift file and the default macOS command line project settings. Here is the package side code:
import Foundation
public struct Vector<Element> where Element: Numeric {
var data: [Element]
public init(_ data: [Element]) {
self.data = data
}
public var count: Int {
data.count
}
public subscript(k: Int) -> Element {
get {
return data[k]
}
set(num) {
data[k] = num
}
}
// @inlinable
@inline(__always)
public static func +(left: Self, right: [Element]) -> Self {
var y = Array<Element>(repeating: 0, count: left.count)
for k in 0..<left.count {
y[k] = left[k] + right[k]
}
return Self(y)
}
}
And the project-side code:
import Foundation
import SimplePackage
let N = 10000
let vArray = (1...N).map { _ in Int.random(in: 0...10) }
let v = Vector<Int>(vArray)
let w = (1...N).map { _ in Int.random(in: 0...10) }
let start = DispatchTime.now()
let y = v + w
let end = DispatchTime.now()
let nanoseconds = end.uptimeNanoseconds - start.uptimeNanoseconds
print("\(y[0] + y[5] + y[10])")
print("Execution time: \(nanoseconds/1000) microsecs")
With inline(__always), my computer prints out 445 microseconds, which is the shortest runtime out of at least 10 runs. When I remove inline(__always) (no use of attributes), I get similar times but the shortest one was 413 microseconds. If I use the @inlinable attribute for the plus operator, then I get 12 microseconds on an M3 Max MacBook Pro machine.
