mirror of
https://github.com/realm/SwiftLint.git
synced 2026-06-06 20:18:40 +00:00
Paul Taykalo
6175c004da
When the request is asked which tokens are have in an intersection, the previous solution was searching for first Index (linearly) and then filtered everything that was coming after that index using `intersect function`
The updated solution will search for the first token index using`binary search`
# Speedup
While this is only one function was updated, the next options were considered:
- [**lin+filter**] old solution
- [**lin+prefix**] old solution with `prefix:wihle` instead of filtering
- [**bin+filter**] binary search with filter
- [**bin+prefix**] binary search with `prefix:wihle` instead of filtering
The speedup highly depends on the file sizes. The bigger/longer files the bigger win is
# Benchmark
## Kickstarter
|lin+filter|lin+prefix|bin+filter|bin+prefix|speedup|
|-|-|-|-|-|
|0.494|0.243|0.390|\***0.117\***| ~4x |
## Swift
|lin+filter|lin+prefix|bin+filter|bin+prefix|speedup|
|-|-|-|-|-|
|1.739|0.740|1.273|\***0.103**\*| ~16x |
## WordPress
|lin+filter|lin+prefix|bin+filter|bin+prefix|speedup|
|-|-|-|-|-|
|1.270|0.526|0.918|0.148| ~8x |
# Testing code
This code was tested with these parts of code (in Release build)
```
fileprivate var counter = 0
fileprivate var times: [String: Double] = [:]
fileprivate let timesQueue = DispatchQueue.init(label: "benchmarks")
fileprivate func timeLog<T>(_ name: String, block: () -> T) -> T {
let start = DispatchTime.now()
let result = block()
let end = DispatchTime.now()
timesQueue.async {
let oldValue = times[name, default:0.0]
let diff = TimeInterval(end.uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
let newValue = oldValue + diff
times[name] = newValue
counter += 1
if counter % 1000 * times.count == 0 {
print("!!!!: \(times)")
}
}
return result
}
internal func tokens(inByteRange byteRange: NSRange) -> [SyntaxToken] {
let new = timeLog("new") { tokensFast(inByteRange: byteRange) }
let new2 = timeLog("old") { tokensOld(inByteRange: byteRange) }
return arc4random() % 2 == 1 ? new : new2
}
```
58 lines
2.2 KiB
Swift
58 lines
2.2 KiB
Swift
extension RandomAccessCollection where Index == Int {
|
|
/// Returns the first index in which an element of the collection satisfies the given predicate.
|
|
/// The collection assumed to be sorted. If collection is not have sorted values the result is undefined.
|
|
///
|
|
/// The idea is to get first index of a function for which the given predicate evaluates to true.
|
|
///
|
|
/// let values = [1,2,3,4,5]
|
|
/// let idx = values.firstIndexAssumingSorted(where: { $0 > 3 })
|
|
///
|
|
/// // false, false, false, true, true
|
|
/// // ^
|
|
/// // therefore idx == 3
|
|
///
|
|
/// - Parameter predicate: A closure that takes an element as its argument
|
|
/// and returns a Boolean value that indicates whether the passed element
|
|
/// represents a match.
|
|
///
|
|
/// - Returns: The index of the first element for which `predicate` returns
|
|
/// `true`. If no elements in the collection satisfy the given predicate,
|
|
/// returns `nil`.
|
|
///
|
|
/// - Complexity: O(log(*n*)), where *n* is the length of the collection.
|
|
@inlinable
|
|
func firstIndexAssumingSorted(where predicate: (Self.Element) throws -> Bool) rethrows -> Int? {
|
|
// Predicate should divide a collection to two pairs of values
|
|
// "bad" values for which predicate returns `false``
|
|
// "good" values for which predicate return `true`
|
|
|
|
// false false false false false true true true
|
|
// ^
|
|
// The idea is to get _first_ index which for which the predicate returns `true`
|
|
|
|
let lastIndex = count
|
|
|
|
// The index that represents where bad values start
|
|
var badIndex = -1
|
|
|
|
// The index that represents where good values start
|
|
var goodIndex = lastIndex
|
|
var midIndex = (badIndex + goodIndex) / 2
|
|
|
|
while badIndex + 1 < goodIndex {
|
|
if try predicate(self[midIndex]) {
|
|
goodIndex = midIndex
|
|
} else {
|
|
badIndex = midIndex
|
|
}
|
|
midIndex = (badIndex + goodIndex) / 2
|
|
}
|
|
|
|
// We're out of bounds, no good items in array
|
|
if midIndex == lastIndex {
|
|
return nil
|
|
}
|
|
return goodIndex
|
|
}
|
|
}
|