It might just be the difference between -Os and -Oz in GCC and Clang ("optimize for size" and "optimize for size even at the cost of speed"). This new flag might be "optimize for speed even at the cost of code size and compile time"—something to set on the client module rather than the library module.
I have no position on the spelling, as long as there's a way to do it.
The main thing here is that we don't want to just do it blindly, we are worried about other implications like code-size for instance. So the idea has been, ok use a heuristic so that we can tune this thing to not have too much of a code-size impact/vs the perf win and carefully expand the cases that we support over time.
Exactly. That's the idea
FWIW, this flag is implemented; you can use it by adding -Xllvm -sil-cross-module-serialize-all to your swiftc command line.
/cc @Edward_Connell
13 Likes
Sorry just to double check since I'm also interested in your initial proposal. Does this flag doe exactly what you wanted to achieve in your initial post? (basically adding inlinable to all your code without having to do this manually)
Can this be used from a simple swift build command as well? (Since you seem to be using swiftc directly)
Edit: I can't actually find an -Xllvm flag for swiftc.
1 Like
It’s not listed by swift --help, but the compiler doesn’t complain if you use it correctly, so I can only assume it’s an undocumented flag.
Hmm I couldn't get it to work. Would you have an example command? I'm probably missing something obvious
To be clear, I haven’t tried the specific LLVM flag mentioned. However, with -Xllvm --version, I do get a message saying I’m using LLVM 13.0.0.
Interestingly I don't get that message
That is my understanding
That is my understanding
Have you been able to use it? I've not been able to use this flag correctly unfortunately. If you'd have a usage example that'd be awesome!
dave@DaveA-MBP14 ~ % cat > /tmp/foo.swift
func main() { print("foo") }
main()
dave@DaveA-MBP14 ~ % swiftc -Xllvm -sil-cross-module-serialize-all /tmp/foo.swift -o /tmp/foo
dave@DaveA-MBP14 ~ %
In your Package.swift you can add swiftSettings: .unsafeFlags(["-Xllvm", "-sil-cross-module-serialize-all"]) to each target description. Seems to work for me.
2 Likes
Hmmm interesting I'm not getting the expected results with the following code in two targets:
target1 (library):
public func doPublicThing<T: FloatingPoint>(values: [T]) -> [T] {
var finalValues: [T] = []
for value in values {
let finalValue = doInternalThing(value: value)
finalValues.append(finalValue)
}
return finalValues
}
internal func doInternalThing<T: FloatingPoint>(value: T) -> T {
var value = value
for i in 0 ..< 1000 {
value += T.init(i * 2)
}
return value
}
target2 (executable):
import Library
let values: [Double] = (0 ..< 1000).map(Double.init)
var results: [Double] = []
for i in 0 ..< 1000 {
let values = values.map { $0 + Double(i) }
let newValues = doPublicThing(values: values)
results.append(newValues.reduce(0, +))
}
print(results)
When marking these with @inlinable there's a clear speed improvement but adding the unsafe flags in the Package.swift file this speed up does not show unfortunately.
Package.swift:
// swift-tools-version: 5.8
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription
let package = Package(
name: "two-targets",
products: [
.library(name: "Library", targets: ["Library"]),
.executable(name: "Run", targets: ["TwoTargetExecutable"]),
],
targets: [
.target(
name: "Library",
swiftSettings: [.unsafeFlags(["-Xllvm", "-sil-cross-module-serialize-all"])]
),
.executableTarget(
name: "TwoTargetExecutable",
dependencies: ["Library"],
swiftSettings: [.unsafeFlags(["-Xllvm", "-sil-cross-module-serialize-all"])]
),
]
)
1 Like
@Michael_Gottesman as the implementor of these flags, do you have any comment?
1 Like
flag mentioned in swiftc --help-hidden