Rock. Paper. blackHole(_:)

[oscbyspro]

I want to optimize some things, and need a way of telling the compiler to not erase my benchmarks. I mean, the current setup can identify some qualities, like whether the compiler can optimize it at all, but not much beyond that when it does. I have tried using the following function, but I saw no change in behavior.

@inline(never) func blackHole(_ value: some Any) { } // 😞

[oscbyspro]

Got a bit excited about this, but it seldom differentiates UInt192 and UInt256. Sad.

@_optimize(none) @inline(never) @discardableResult func blackHole(_ x: @autoclosure () -> some Any) -> some Any { x() }

[oscbyspro]

That moment when you realize you have spent an hour trying various combinations of:

@inline(never)
@_optimize(none)
@discardableResult
@_semantics("optimize.no.crossmodule")
public func blackHole<T>(_ x: T) {  }
public func blackHole<T>(_ x: T) {  _ = x }
public func blackHole<T>(_ x: T) -> T { x }
public func blackHole<T>(_ x: @autoclosure () -> T) {  _ = x() }
public func blackHole<T>(_ x: @autoclosure () -> T) -> T { x() }

[oscbyspro]

With optimize(none) and/or @_semantics("optimize.no.crossmodule") I can get something that takes time proportional to the number of loops, and to some extent to how expensive the operation is. I'm struggling, however, with reliably getting something with a predictable (or any) difference between UInt192 and UInt256.

[oscbyspro]

/.../TestsUtils.swift uses this function:

@inline(never)
@_semantics("optimize.no.crossmodule")
public func blackHole<T>(_ x: T) { }

[oscbyspro]

Hm. So far, I've only tried using the blackHole(_:) method to obfuscate the loops, but when I have the time I might also try using the identity(_:) method to obfuscate all the constants and variables. I suppose that could be a problem.

@inline(never)
@_semantics("optimize.no.crossmodule")
@inlinable public func identity<T>(_ x: T) -> T { x }

[oscbyspro]

Well, I remain skeptical. But at least they are no longer reduced to nothing.

[oscbyspro]

I wonder if I also need to trick the compiler into thinking that constants could change between loops. Maybe it knows enough to copy-paste some initial computation into the black hole? 💭

[oscbyspro]

I inserted fake mutations because if I can do it, the compiler can do it (probably).

[oscbyspro]

I'm not sure how I would measure @inlinable constant expressions, but oh well.