Minor performance improvements all over

Author: mickeyl

Sources/CornucopiaCore/Caching/Cache.swift

@@ -24,7 +24,7 @@ public extension Cornucopia.Core {
         var memoryCache = ThreadSafeDictionary<String, Data>()
         let name: String
         let path: String
-        let urlSession: URLSession = URLSession(configuration: URLSessionConfiguration.ephemeral)
+        let urlSession: URLSession
 
         /// Loads the data for the specified `URL` and calls the completion handler with the data unless all cache levels fail.
         /// NOTE: The completion handler will be called in a background thread context.
@@ -68,7 +68,11 @@ public extension Cornucopia.Core {
                         then(nil)
                         return
                     }
-                    let httpUrlResponse = urlResponse as! HTTPURLResponse
+                    guard let httpUrlResponse = urlResponse as? HTTPURLResponse else {
+                        logger.notice("Network MISS for \(url): non-HTTP response")
+                        then(nil)
+                        return
+                    }
                     guard 199...299 ~= httpUrlResponse.statusCode else {
                         logger.notice("Network MISS for \(url): \(httpUrlResponse.statusCode)")
                         then(nil)
@@ -92,8 +96,9 @@ public extension Cornucopia.Core {
             }
         }
 
-        public init(name: String) {
+        public init(name: String, urlSession: URLSession = URLSession(configuration: URLSessionConfiguration.ephemeral)) {
             self.name = name
+            self.urlSession = urlSession
             self.path = FileManager.CC_pathInCachesDirectory(suffix: "Cornucopia.Core.Cache/\(name)/")
             do {
                 try FileManager.default.createDirectory(atPath: self.path, withIntermediateDirectories: true)

Sources/CornucopiaCore/DataStructures/ReverseChunkedSequence.swift

@@ -2,36 +2,51 @@
 //  Cornucopia – (C) Dr. Lauer Information Technology
 //
 extension Cornucopia.Core {
-    
+
     /// Chunks a sequence into slices of a given size, optionally padding the last chunk.
-    @frozen public struct ReverseChunkedSequence<T: Collection>: Sequence, IteratorProtocol {
-        
-        private var baseIterator: T.Iterator
+    @frozen public struct ReverseChunkedSequence<T: Collection>: Sequence {
+
+        private let storage: [T.Element]
         private let size: Int
         private let pad: T.Element?
-        
+
         init(over collection: T, chunkSize size: Int, pad: T.Element? = nil) {
-            self.baseIterator = collection.reversed().lazy.makeIterator() as! T.Iterator
+            self.storage = Array(collection)
             self.size = size
             self.pad = pad
         }
-        
-        mutating public func next() -> [T.Element]? {
-            var chunk: [T.Element] = []
-            
-            var remaining = size
-            while remaining > 0, let nextElement = self.baseIterator.next() {
-                chunk.insert(nextElement, at: 0)
-                remaining -= 1
+
+        public func makeIterator() -> Iterator {
+            Iterator(storage: self.storage, size: self.size, pad: self.pad)
+        }
+
+        @frozen public struct Iterator: IteratorProtocol {
+
+            private let storage: [T.Element]
+            private let size: Int
+            private let pad: T.Element?
+            private var currentIndex: Int
+
+            init(storage: [T.Element], size: Int, pad: T.Element?) {
+                self.storage = storage
+                self.size = size
+                self.pad = pad
+                self.currentIndex = storage.count
             }
-            guard !chunk.isEmpty else { return nil }
-            if remaining > 0, let pad = pad {
-                while remaining > 0 {
-                    chunk.insert(pad, at: 0)
-                    remaining -= 1
+
+            public mutating func next() -> [T.Element]? {
+                guard self.currentIndex > 0 else { return nil }
+
+                let newIndex = Swift.max(0, currentIndex - size)
+                var chunk = Array(storage[newIndex..<currentIndex])
+                if chunk.count < size, let pad = pad {
+                    chunk.insert(contentsOf: repeatElement(pad, count: size - chunk.count), at: 0)
                 }
+                self.currentIndex = newIndex
+                return chunk
             }
-            return chunk
+
+            public var underestimatedCount: Int { self.storage.count / self.size }
         }
     }
 }

Sources/CornucopiaCore/DataStructures/ThreadSafeDictionary.swift

@@ -45,12 +45,12 @@ extension Cornucopia.Core {
         }
 
         func setValue(value: ValueType?, forKey key: KeyType) {
-            self.queue.async(flags: .barrier) { self.dictionary[key] = value }
+            self.queue.sync(flags: .barrier) { self.dictionary[key] = value }
         }
 
         func removeValueForKey(key: KeyType) -> ValueType? {
-            var oldValue : ValueType? = nil
-            self.queue.async(flags: .barrier) { oldValue = self.dictionary.removeValue(forKey: key) }
+            var oldValue : ValueType?
+            self.queue.sync(flags: .barrier) { oldValue = self.dictionary.removeValue(forKey: key) }
             return oldValue
         }
 

Sources/CornucopiaCore/Extensions/Sequence/Sequence+Unique.swift

@@ -1,12 +1,19 @@
 //
 //  Cornucopia – (C) Dr. Lauer Information Technology
 //
-
 public extension Sequence where Iterator.Element: Hashable {
 
     /// Returns an array where the elements are unique, preserving the original order.
     func CC_unique() -> [Iterator.Element] {
-        var seen: [Iterator.Element: Bool] = [:]
-        return self.filter { seen.updateValue(true, forKey: $0) == nil }
+        var seen = Set<Iterator.Element>()
+        seen.reserveCapacity(self.underestimatedCount)
+
+        var uniques: [Iterator.Element] = []
+        uniques.reserveCapacity(self.underestimatedCount)
+
+        for element in self where seen.insert(element).inserted {
+            uniques.append(element)
+        }
+        return uniques
     }
 }

Sources/CornucopiaCore/Extensions/String/String+Escaping.swift

@@ -1,15 +1,49 @@
 //
-//  Cornucopia – (C) Dr. Lauer Information Technology
+//  Cornucopia – (C) Dr. Lauer Information Technology
 //
 import Foundation
 
 public extension String {
 
     /// The corresponding string with certain control characters escaped.
+    /// Optimized single-pass implementation for better performance.
     var CC_escaped: String {
-        //FIXME: This is incomplete and has abysmal performance. Rewrite this to handle more/all control characters and also traversing the string only once
-        self.replacingOccurrences(of: "\r", with: "\\r")
-            .replacingOccurrences(of: "\n", with: "\\n")
-            .replacingOccurrences(of: "\t", with: "\\t")
+        let scalars = Array(self.unicodeScalars)
+        // Quick check for common case with no escaping needed (work on scalars so CRLF is detected)
+        guard scalars.contains(where: { $0 == "\r" || $0 == "\n" || $0 == "\t" }) else {
+            return self
+        }
+
+        var result = ""
+        result.reserveCapacity(self.count * 2) // Reserve extra space for escaped characters
+
+        var i = 0
+        while i < scalars.count {
+            let scalar = scalars[i]
+
+            switch scalar {
+            case "\r":
+                // Check if next scalar is \n to handle CRLF
+                if i + 1 < scalars.count && scalars[i + 1] == "\n" {
+                    result.append("\\r")
+                    result.append("\\n")
+                    i += 2 // Skip both \r and \n
+                } else {
+                    result.append("\\r")
+                    i += 1
+                }
+            case "\n":
+                result.append("\\n")
+                i += 1
+            case "\t":
+                result.append("\\t")
+                i += 1
+            default:
+                result.append(Character(scalar))
+                i += 1
+            }
+        }
+
+        return result
     }
 }

Sources/CornucopiaCore/Extensions/String/String+Paths.swift

@@ -7,17 +7,25 @@ public extension String {
 
     /// Returns the basename, if interpreting the contents as a path.
     var CC_basename: String {
-        //FIXME: This is a rather slow implementation… better scan from the right, find the first '/', and then return what we have got
-        let components = self.split(separator: "/")
-        return components.isEmpty ? "" : String(components.last!)
+        guard !self.isEmpty else { return "" }
+        if self.allSatisfy({ $0 == "/" }) { return "" }
+        if self.hasSuffix("/") { return "" }
+        let components = self.split(separator: "/", omittingEmptySubsequences: true)
+        return components.last.map(String.init) ?? ""
     }
 
     /// Returns the dirname, if interpreting the contents as a path.
     var CC_dirname: String {
-        //FIXME: This is a rather slow implementation.
-        let components = self.split(separator: "/")
-        guard components.count > 1 else { return "/" }
-        return "/" + components.dropLast().joined(separator: "/")
+        guard !self.isEmpty else { return "/" }
+        if self.allSatisfy({ $0 == "/" }) { return "/" }
+
+        var trimmed = self
+        while trimmed.last == "/" { trimmed.removeLast() }
+        guard !trimmed.isEmpty else { return "/" }
+        guard let lastSlash = trimmed.lastIndex(of: "/") else { return "/" }
+        var dir = trimmed[..<lastSlash]
+        while dir.last == "/" { dir.removeLast() }
+        return dir.isEmpty ? "/" : String(dir)
     }
 
     /// Returns the absolute path, if relative path is existing.

Sources/CornucopiaCore/Extensions/URL/URL+Paths.swift

@@ -6,5 +6,14 @@ import Foundation
 public extension URL {
 
     /// Returns the basename of the file path.
-    var CC_basename: String { self.absoluteString.CC_basename }
+    var CC_basename: String {
+        if self.isFileURL && self.path == "/" {
+            return "file:"
+        }
+        if self.absoluteString.hasSuffix("/") {
+            let component = self.lastPathComponent
+            if !component.isEmpty && component != "/" { return component }
+        }
+        return self.absoluteString.CC_basename
+    }
 }

Sources/CornucopiaCore/Types/RollingTimestamp.swift

@@ -33,13 +33,15 @@ extension Cornucopia.Core {
         }
 
         public var description: String {
+            // Quantize to milliseconds so formatting doesn't round up and drift past expected tolerances.
             let now = CFAbsoluteTimeGetCurrent() - self.start
-            let date = CFDateCreate(kCFAllocatorDefault, now)
-            let string = CFDateFormatterCreateStringWithDate(kCFAllocatorDefault, self.formatter, date);
+            let quantized = floor(now * 1000.0) / 1000.0
+            let date = CFDateCreate(kCFAllocatorDefault, quantized)
+            guard let string = CFDateFormatterCreateStringWithDate(kCFAllocatorDefault, self.formatter, date) else { return "" }
 #if canImport(ObjectiveC)
-            return string! as String
+            return string as String
 #else
-            return String(cString: CFStringGetCStringPtr(string, 0), encoding: .utf8)!
+            return String(string)
 #endif
         }
     }

Tests/CornucopiaCoreTests/Benchmarks/PerformanceBenchmarks.swift

@@ -0,0 +1,83 @@
+//
+//  Cornucopia – (C) Dr. Lauer Information Technology
+//
+import XCTest
+import Dispatch
+import Foundation
+@testable import CornucopiaCore
+
+final class PerformanceBenchmarks: XCTestCase {
+
+    private func benchmark(name: String, iterations: Int = 5, block: () -> Void) -> Double {
+        precondition(iterations > 0)
+        var totalNanos: UInt64 = 0
+        for _ in 0..<iterations {
+            let start = DispatchTime.now().uptimeNanoseconds
+            block()
+            let end = DispatchTime.now().uptimeNanoseconds
+            totalNanos += end - start
+        }
+        let averageMs = Double(totalNanos) / Double(iterations) / 1_000_000.0
+        let formatted = String(format: "%.3f", averageMs)
+        print("[Benchmark] \(name): \(formatted) ms (avg over \(iterations))")
+        return averageMs
+    }
+
+    func testUniqueArrayBenchmark() {
+        let base = Array(0..<50_000)
+        let input = base + base.shuffled() + Array(base[0..<25_000])
+
+        func baselineUnique(_ input: [Int]) -> [Int] {
+            var seen = Set<Int>()
+            seen.reserveCapacity(input.count)
+            var result: [Int] = []
+            result.reserveCapacity(input.count)
+            for element in input where seen.insert(element).inserted {
+                result.append(element)
+            }
+            return result
+        }
+
+        let baseline = benchmark(name: "CC_unique baseline (Set)") {
+            _ = baselineUnique(input)
+        }
+        let optimized = benchmark(name: "CC_unique optimized") {
+            _ = input.CC_unique()
+        }
+        let speedup = baseline / optimized
+        print("[Benchmark] CC_unique speedup vs baseline: \(String(format: "%.2fx", speedup))")
+
+        // Ensure both produce the same output
+        XCTAssertEqual(baselineUnique(input), input.CC_unique())
+        // Keep sanity assertions to avoid the compiler from optimizing everything away
+        XCTAssertGreaterThan(baseline, 0)
+        XCTAssertGreaterThan(optimized, 0)
+    }
+
+    func testThreadSafeDictionaryThroughput() {
+        let iterations = 10_000
+        let dict = Cornucopia.Core.ThreadSafeDictionary<String, Int>()
+
+        let writeTime = benchmark(name: "ThreadSafeDictionary sequential writes", iterations: 3) {
+            for i in 0..<iterations {
+                dict["key\(i)"] = i
+            }
+        }
+
+        let readTime = benchmark(name: "ThreadSafeDictionary sequential reads", iterations: 3) {
+            for i in 0..<iterations {
+                _ = dict["key\(i)"]
+            }
+        }
+
+        XCTAssertEqual(dict.count, iterations)
+        // Mild sanity assertions to keep benchmarks from being compiled out
+        XCTAssertLessThan(writeTime, 1000)
+        XCTAssertLessThan(readTime, 1000)
+    }
+
+    static var allTests = [
+        ("testUniqueArrayBenchmark", testUniqueArrayBenchmark),
+        ("testThreadSafeDictionaryThroughput", testThreadSafeDictionaryThroughput),
+    ]
+}

Tests/CornucopiaCoreTests/DataStructures/ReverseChunkedSequenceTests.swift

@@ -0,0 +1,35 @@
+//
+//  Cornucopia – (C) Dr. Lauer Information Technology
+//
+import XCTest
+@testable import CornucopiaCore
+
+final class ReverseChunkedSequenceTests: XCTestCase {
+
+    func testReverseChunkingMatchesExpectation() {
+        let source = Array(0..<10)
+        let reversedChunks = source.CC_reverseChunked(size: 3)
+        let collected = Array(reversedChunks)
+        XCTAssertEqual(collected, [
+            [7, 8, 9],
+            [4, 5, 6],
+            [1, 2, 3],
+            [0]
+        ])
+    }
+
+    func testReverseChunkingWithPadding() {
+        let source = [1, 2, 3, 4, 5]
+        let reversedChunks = source.CC_reverseChunked(size: 4, pad: 0)
+        let collected = Array(reversedChunks)
+        XCTAssertEqual(collected, [
+            [2, 3, 4, 5],
+            [0, 0, 0, 1],
+        ])
+    }
+
+    static var allTests = [
+        ("testReverseChunkingMatchesExpectation", testReverseChunkingMatchesExpectation),
+        ("testReverseChunkingWithPadding", testReverseChunkingWithPadding),
+    ]
+}