import Foundation @testable import PureYAML import Testing /// Measures the resumable scanner's checkpoint-and-retry cost (issue #4) against /// the batch scanner, across a spread of chunk sizes, over the largest real-world /// fixture, plus a `singleChunk` control that isolates the floor from real /// rescanning (see CHANGELOG.md). The overhead splits into two independent /// costs: a fixed floor (~1.75x release-mode, present even with a single chunk, /// caused by copying the whole `Scanner` on every fetch whenever `isFinal` is /// false) and a rescan-driven tail that only appears below roughly 4096-scalar /// chunks. Persisted mid-token suspension, the deferred next increment, would /// remove the rescan tail but not the floor; a fix for the floor is not yet /// designed. Gated: release-mode timing on a 9.5MB fixture is not a default /// `swift test` concern. /// /// Run this in release mode; debug-mode numbers are not representative (Swift's /// `-Onone` inserts defensive retain/copy traffic around `mutating throws` /// methods on multi-field structs that the optimizer removes in release). This /// package's own test target needs `-enable-testing` explicitly in release, /// working around an unrelated `PureYAMLJSON` test-target issue: /// /// ```sh /// PUREYAML_STREAMING_PERF_MEASURE=1 swift test -c release -Xswiftc -enable-testing \ /// --filter StreamingScannerPerformanceTests /// ``` @Suite("Streaming Scanner Performance") struct StreamingScannerPerformanceTests { @Test("measure scanStep() overhead over scanAll() at a spread of chunk sizes") func test_measure() throws { guard ProcessInfo.processInfo.environment["PUREYAML_STREAMING_PERF_MEASURE"] == "1" else { return } let url = try #require(Bundle.module.url( forResource: "github-rest-api", withExtension: "yaml", subdirectory: "Fixtures/real-yaml", )) let yaml = try String(contentsOf: url, encoding: .utf8) let clock = ContinuousClock() var batchScanner = PureYAML.Parsing.LibYAML.Scanner(yaml) let batchDuration = try clock.measure { _ = try batchScanner.scanAll() } print("STREAMING-PERF batch bytes=\(yaml.utf8.count) time=\(batchDuration)") // Control: the whole input is present from construction (isFinal: true), so // ranDry can never be set and the checkpoint is never restored, meaning zero // chunking or retry ever happens. Any overhead this still shows over // scanAll() is intrinsic to scanStep()'s per-token loop (the checkpoint copy // taken before every fetch, and isFrontSafeToRelease's check), not to // chunking. This isolates that fixed cost from the chunk-size-dependent // rescan cost measured below. var noChunkScanner = PureYAML.Parsing.LibYAML.Scanner(yaml, isFinal: true) let noChunkDuration = try clock.measure { while true { switch try noChunkScanner.scanStep() { case .token: continue case .done: return case .needMoreInput: Issue.record("isFinal: true must never report needMoreInput") return } } } let noChunkRatio = noChunkDuration / batchDuration print("STREAMING-PERF noChunking(control) time=\(noChunkDuration) ratio=\(String(format: "%.2f", noChunkRatio))x") for chunkSize in [16, 64, 256, 1024, 4096, 65536, 1_000_000] { let duration = try streamingDuration(yaml: yaml, chunkSize: chunkSize, clock: clock) let ratio = duration / batchDuration print("STREAMING-PERF chunkSize=\(chunkSize) time=\(duration) ratio=\(String(format: "%.2f", ratio))x") } // Distinguishes two candidate explanations for the chunked-mode floor: (a) // real rescanning at chunk boundaries, which should vanish as chunk count // drops toward 1, or (b) a fixed per-fetchNextToken() cost paid on every // token regardless of how many chunks exist, which would not. A single // chunk covering the whole file means `isFinal` is false (so the checkpoint // is taken every fetch) but `ranDry` can only ever fire once, at the true // end: the only possible rescan is the very last token. let wholeFileAsOneChunk = yaml.unicodeScalars.count + 1 let singleChunkDuration = try streamingDuration(yaml: yaml, chunkSize: wholeFileAsOneChunk, clock: clock) let singleChunkRatio = singleChunkDuration / batchDuration print("STREAMING-PERF singleChunk(wholeFile) time=\(singleChunkDuration) ratio=\(String(format: "%.2f", singleChunkRatio))x") } } private func streamingDuration(yaml: String, chunkSize: Int, clock: ContinuousClock) throws -> Duration { let scalars = Array(yaml.unicodeScalars) var chunks: [String] = [] var index = 0 while index < scalars.count { let end = min(index + chunkSize, scalars.count) chunks.append(String(String.UnicodeScalarView(scalars[index ..< end]))) index = end } return try clock.measure { var scanner = PureYAML.Parsing.LibYAML.Scanner("", isFinal: false) var nextChunk = 0 while true { switch try scanner.scanStep() { case .token: continue case .done: return case .needMoreInput: if nextChunk < chunks.count { scanner.reader.append(chunks[nextChunk]) nextChunk += 1 } else { scanner.reader.markFinal() } } } } }