Why `String(describing: Class.self)` is slower than `NSStringFromClass(Class.self)`?

Question

Consider the following programm:

import Foundation
import QuartzCore

class C: NSObject {}

func benchmark() {
    let swift1 = CACurrentMediaTime()
    let swiftString = String(describing: C.self)
    let swift2 = CACurrentMediaTime()

    let objc1 = CACurrentMediaTime()
    let objcString = NSStringFromClass(C.self)
    let objc2 = CACurrentMediaTime()

    let timeForSwiftString = swift2 - swift1
    let timeForObjcString = objc2 - objc1
    print("timeForSwiftString / timeForObjcString:", timeForSwiftString / timeForObjcString)
}

for _ in 0..<20 {
    benchmark()
}

The output will look something like

timeForSwiftString / timeForObjcString: 21.023079257409023
timeForSwiftString / timeForObjcString: 1.8032004909527086
timeForSwiftString / timeForObjcString: 2.929076507541501
timeForSwiftString / timeForObjcString: 3.1707763580662034
timeForSwiftString / timeForObjcString: 2.884789101770234
timeForSwiftString / timeForObjcString: 3.167761588431754
timeForSwiftString / timeForObjcString: 3.0066055331053776
timeForSwiftString / timeForObjcString: 3.0707174733951255
timeForSwiftString / timeForObjcString: 3.213085166384659
timeForSwiftString / timeForObjcString: 2.830997374357457
timeForSwiftString / timeForObjcString: 3.24157236450268
timeForSwiftString / timeForObjcString: 3.0462955824531646
timeForSwiftString / timeForObjcString: 2.887874789238326
timeForSwiftString / timeForObjcString: 3.1071486398963732
timeForSwiftString / timeForObjcString: 2.995876045716979
timeForSwiftString / timeForObjcString: 3.073833893272912
timeForSwiftString / timeForObjcString: 2.965068621921414
timeForSwiftString / timeForObjcString: 3.0622197750334306
timeForSwiftString / timeForObjcString: 3.0484172031541656
timeForSwiftString / timeForObjcString: 1.9362930766842597

The first measurement is always the most expensive (perhaps due to some lazy runtime actions), so we will skip it.

All other measurements show, that swift is slower.

I also have a demo project with a benchmark on getting string from 1000 different classes which shows:

Swift's String(describing: Class.self) works slower, than Objective-C's NSClassFromString(Class.self) (30..150μs vs 4..12μs)
Calling Swift's String(describing: Class.self) on different classes gets slower and slower with every new class, while Objective-C times remain the same

Any ideas for such a behavior?

score 3 · Answer 1 · answered Mar 17 '19 at 14:34

perhaps due to some lazy runtime actions

Spot on, first calls to anything can be slower for various reasons including resolution of dynamically loaded libraries.

Any ideas for such a behavior?

A first guess would be that String(describing:) takes any value, figures out what kind of value it is (it's description states it tests for conformance to three different protocols), and then calls the appropriate functions to describe the value. However NSStringFromClass takes only Class values, which is checked at compile time, and then directly calls the runtime functions needed to get the class name as a string without any need for testing and branching on the kind of value passed.

TLDR: More work takes more time, testing and branching slows you down.

HTH

score 2 · Accepted Answer · answered Mar 17 '19 at 15:07

2

You’re comparing apples with motorcars.

NSStringFromClass does a highly specific job, involving only class types, and is used for a conversion related to the dynamic nature of Objective-C programs.
String(describing:) in Swift turns anything into a string representation and is intended (and suitable) only for debugging. It will not be used for any user-facing code and no meaningful program action will depend upon its output. Thus it will not appear in a released app and its speed is of no account. Your question therefore optimizes not only prematurely but unnecessarily; the speed of String(describing:) is unimportant.

answered Mar 17 '19 at 15:07

matt

515,959
87
875
1,141

Thanks for your answer! I ask this, bucause I want to optimize some code in a library for dependency injection in swift. This code uses `String(describing:)` for creating dictionary keys depending on the Type description: https://github.com/AliSoftware/Dip/blob/815e9ccd6660d7f0084334edc1105a803968acfc/Sources/Definition.swift#L38. Can you suggest an alternative? – Tim Mar 17 '19 at 15:27
We cannot use `NSStringFromClass`, because the types we create keys from are always protocol types. We could use `NSStringFromProtocol`, but it would require us to make all protocols `@objc`, which is imposibble for most of our protocols (they use pure swift types, associated types and other swift stuff) – Tim Mar 17 '19 at 15:34
If we could make Types conform to `Hashable`... This would solve all the problems, but seems to be impossible to implement, because afaic only type instances can conform to `Hashable` – Tim Mar 17 '19 at 15:37
@Tim You can use `ObjectIdentifier`, see for example https://stackoverflow.com/q/42459484/2976878 – Hamish Mar 17 '19 at 15:49
Hi @Tim The trouble in that case is that this becomes an “xy” question. Please ask a full new question describing the problem you were _really_ trying to solve all along! Thanks. I stand by my assertion, though, that if you are thinking of using `String(describing:)` in production code, you’re doing it wrong. – matt Mar 17 '19 at 16:37

Why `String(describing: Class.self)` is slower than `NSStringFromClass(Class.self)`?

2 Answers2