Static Dispatch with Final performance comparison - ios

Question

According to the article by Apple - Increasing Performance by Reducing Dynamic Dispatch, it suggests that dynamic dispatch is not good performance wise
dynamic dispatch, increases language expressivity at the cost of a
constant amount of runtime overhead for each indirect usage. In
performance sensitive code such overhead is often undesirable
Also,
three ways to improve performance by eliminating such dynamism: final,
private, and Whole Module Optimization.
From what I understood, it said that when we use final keyword, it ensures the compiler that class will never be subclassed and thus increases performance (as without that, there cannot be dynamic dispatch).
So to sum it up, final will increase the performance for that class.
So, I performed a basic test to make sure of it :
import Foundation
func calculateTimeElapsed(label: String, codeToRun: () -> Void ) {
let startTime = CFAbsoluteTimeGetCurrent()
codeToRun()
let timeElapsed = CFAbsoluteTimeGetCurrent() - startTime
print("Time elapsed for \(label): \(timeElapsed) sec")
}
class Foo {
var number: Int = 1
func incrementNumber() {
number += 1
}
}
final class Bar {
var number: Int = 1
func incrementNumber() {
number += 1
}
}
let fooObject = Foo()
calculateTimeElapsed(label: "Static Dispatch for Foo") {
for _ in 0...100000 {
fooObject.incrementNumber()
}
}
let barObject = Bar()
calculateTimeElapsed(label: "Static Dispatch for Bar") {
for _ in 0...100000 {
barObject.incrementNumber()
}
}
/// 100000
//Time elapsed for Static Dispatch for Foo: 7.20068895816803 sec
//Time elapsed for Static Dispatch for Bar: 7.22502601146698 sec
/// 200000
//Time elapsed for Static Dispatch for Foo: 13.975957989692688 sec
//Time elapsed for Static Dispatch for Bar: 14.329360961914062 sec
/// 500000
//Time elapsed for Static Dispatch for Foo: 36.355777978897095 sec
//Time elapsed for Static Dispatch for Bar: 36.50222206115723 sec
/// 700000
//Time elapsed for Static Dispatch for Foo: 51.68453896045685 sec
//Time elapsed for Static Dispatch for Bar: 51.46391808986664 sec
//
Two classes , one final(Bar) and one not (Foo)
Performed some operations over certain input on objects of both the classes
Measured the time required for executing both the operations
However, to my surprise, the class that is not final takes less time in 3/4 cases. It can be that when the number of iterations increases, the result may go into the favor of final class, but i need to be sure that this concept is correct to measure.
I know my example might be wrong, but if it is, then can anyone please tell me some other example with which the fact that final increases the performance is correct