reduce string processing overhead

Author: pingchen114

BuildTimeAnalyzer/CompileMeasure.swift

@@ -37,19 +37,21 @@ import Foundation
     }
 
     init?(time: Double, rawPath: String, code: String, references: Int) {
-        let untrimmedFilename = rawPath.split(separator: "/").map(String.init).last
-        
-        guard let filepath = rawPath.split(separator: ":").map(String.init).first,
-            let filename = untrimmedFilename?.split(separator: ":").map(String.init).first else { return nil }
-        
-        let locationString = String(rawPath[filepath.endIndex...].dropFirst())
-        let locations = locationString.split(separator: ":").compactMap{ Int(String.init($0)) }
+        let untrimmedFilename: Substring
+        if let lastIdx = rawPath.lastIndex(of: "/") {
+            untrimmedFilename = rawPath.suffix(from: rawPath.index(after: lastIdx))
+        } else {
+            untrimmedFilename = rawPath[...]
+        }
+        let filepath = rawPath.prefix(while: {$0 != ":"})
+        let filename = untrimmedFilename.prefix(while: {$0 != ":"})
+        let locations = untrimmedFilename.split(separator: ":").dropFirst().compactMap({Int(String($0))})
         guard locations.count == 2 else { return nil }
 
         self.time = time
         self.code = code
-        self.path = filepath
-        self.filename = filename
+        self.path = String(filepath)
+        self.filename = String(filename)
         self.locationArray = locations
         self.references = references
     }

BuildTimeAnalyzer/LogProcessor.swift

@@ -7,6 +7,8 @@ import Foundation
 
 typealias CMUpdateClosure = (_ result: [CompileMeasure], _ didComplete: Bool, _ didCancel: Bool) -> ()
 
+fileprivate let regex = try! NSRegularExpression(pattern:  "^\\d*\\.?\\d*ms\\t/", options: [])
+
 protocol LogProcessorProtocol: class {
     var rawMeasures: [String: RawMeasure] { get set }
     var updateHandler: CMUpdateClosure? { get set }
@@ -32,25 +34,30 @@ extension LogProcessorProtocol {
     // MARK: Private methods
 
     private func process(text: String) {
+        let text = text as NSString
         let characterSet = CharacterSet(charactersIn:"\r\"")
-        var remainingRange = text.startIndex..<text.endIndex
-        let regex = try! NSRegularExpression(pattern:  "^\\d*\\.?\\d*ms\\t/", options: [])
+        var remainingRange = NSMakeRange(0, text.length)
 
         rawMeasures.removeAll()
 
         processingDidStart()
 
-        while let nextRange = text.rangeOfCharacter(from: characterSet, options: [], range: remainingRange) {
-            let text = String(text[remainingRange.lowerBound..<nextRange.upperBound])
-            
+        while true {
+            let nextRange = text.rangeOfCharacter(from: characterSet, options: .literal, range: remainingRange)
+            guard nextRange.location != NSNotFound else { break }
+
+            let beginIdx = remainingRange.lowerBound
+            let endIdx = nextRange.upperBound
+            let textCount = endIdx - beginIdx
+            let text = text.substring(with: NSMakeRange(beginIdx, textCount))
+
             defer {
-                remainingRange = nextRange.upperBound..<remainingRange.upperBound
+                remainingRange = NSMakeRange(endIdx, remainingRange.upperBound - endIdx)
             }
 
-            // From LuizZak: (text as NSString).length improves the performance by about 2x compared to text.characters.count
-            let range = NSMakeRange(0, (text as NSString).length)
+            let range = NSMakeRange(0, textCount)
             guard let match = regex.firstMatch(in: text, options: [], range: range) else { continue }
-            
+
             let timeString = text[..<text.index(text.startIndex, offsetBy: match.range.length - 4)]
             if let time = Double(timeString) {
                 let value = String(text[text.index(text.startIndex, offsetBy: match.range.length - 1)...])