perf test

Author: weissi

Package.swift

@@ -17,6 +17,7 @@ import PackageDescription
 
 let package = Package(
     name: "async-http-client",
+    platforms: [.macOS(.v13)],
     products: [
         .library(name: "AsyncHTTPClient", targets: ["AsyncHTTPClient"]),
     ],
@@ -32,6 +33,10 @@ let package = Package(
         .package(url: "https://github.com/apple/swift-algorithms", from: "1.0.0"),
     ],
     targets: [
+        .executableTarget(
+            name: "AsyncHTTPClientPerfTester",
+            dependencies: ["AsyncHTTPClient"]
+        ),
         .target(
             name: "CAsyncHTTPClient",
             cSettings: [

Sources/AsyncHTTPClientPerfTester/AsyncDoFinally.swift

@@ -0,0 +1,62 @@
+/// Runs `body` and when body returns or throws, run `finally`.
+///
+/// This is useful as an async version of this code pattern
+///
+/// ```swift
+/// let resource = try createResource()
+/// defer {
+///     try? destroyResource()
+/// }
+/// return try useResource()
+/// ```
+///
+/// - note: Even if the task that `asyncDo` is running is is cancelled, the `finally` code will run in a task that
+///         is _not_ cancelled. This is crucial to not require all cleanup code to work in an already-cancelled task.
+@inlinable
+public func asyncDo<R: Sendable>(
+    returning: R.Type = R.self,
+    _ body: @Sendable () async throws -> R,
+    finally: @escaping @Sendable () async throws -> Void
+) async throws -> R {
+    try await asyncDo {
+        try await body()
+    } finally: { _ in
+        try await finally()
+    }
+}
+
+/// Runs `body` and when body returns or throws, run `finally`.
+///
+/// This is useful as an async version of this code pattern
+///
+/// ```swift
+/// let resource = try createResource()
+/// defer {
+///     try? destroyResource()
+/// }
+/// return try useResource()
+/// ```
+///
+/// - note: Even if the task that `asyncDo` is running is is cancelled, the `finally` code will run in a task that
+///         is _not_ cancelled. This is crucial to not require all cleanup code to work in an already-cancelled task.
+@inlinable
+public func asyncDo<R: Sendable>(
+    returning: R.Type = R.self,
+    _ body: @Sendable () async throws -> R,
+    finally: @escaping @Sendable (Error?) async throws -> Void
+) async throws -> R {
+    let result: R
+    do {
+        result = try await body()
+    } catch {
+        try? await withUncancelledTask {
+            try await finally(error)
+        }
+        throw error
+    }
+
+    try await withUncancelledTask {
+        try await finally(nil)
+    }
+    return result
+}

Sources/AsyncHTTPClientPerfTester/Main.swift

@@ -0,0 +1,73 @@
+import AsyncHTTPClient
+import NIO
+import Foundation
+
+func goFuture() throws {
+    let httpClient = HTTPClient(eventLoopGroup: MultiThreadedEventLoopGroup.singleton)
+
+    func doOne() -> EventLoopFuture<Void> {
+        let request = try! HTTPClient.Request(url: "http://127.0.0.1:8888/")
+        return httpClient.execute(request: request).map { response in
+            precondition(response.status.code == 200)
+        }
+    }
+
+    func doMany(_ count: Int, promise: EventLoopPromise<Void>) -> EventLoopFuture<Void> {
+        guard count > 0 else {
+            promise.succeed(())
+            return promise.futureResult
+        }
+
+        doOne().map {
+            doMany(count - 1, promise: promise)
+        }.cascadeFailure(to: promise)
+
+        return promise.futureResult
+    }
+
+    let loop = MultiThreadedEventLoopGroup.singleton.any()
+    try doMany(100_000, promise: loop.makePromise(of: Void.self))
+        .recover { _ in }
+        .flatMap {
+            httpClient.shutdown()
+        }
+        .wait()
+}
+
+func goAsync() async throws {
+    let httpClient = HTTPClient(eventLoopGroup: MultiThreadedEventLoopGroup.singleton)
+    try await asyncDo {
+        for _ in 0..<100_000 {
+            let request = HTTPClientRequest(url: "http://127.0.0.1:8888/")
+            let response = try await httpClient.execute(
+                request,
+                deadline: .now() + .seconds(100)
+            )
+            for try await _ in response.body {}
+            precondition(response.status.code == 200)
+        }
+    } finally: {
+        try await httpClient.shutdown()
+    }
+}
+
+@main
+struct Main {
+    static func main() async throws {
+        var tStart = SuspendingClock.now
+        try goFuture()
+        var tEnd = SuspendingClock.now
+        let diffFuture = tEnd - tStart
+
+        precondition(Thread.isMainThread)
+        let success = NIOSingletons.unsafeTryInstallSingletonPosixEventLoopGroupAsConcurrencyGlobalExecutor()
+        precondition(success)
+
+        tStart = SuspendingClock.now
+        try await goAsync()
+        tEnd = SuspendingClock.now
+        let diffAsync = tEnd - tStart
+        print("future", diffFuture)
+        print("async", diffAsync)
+    }
+}

Sources/AsyncHTTPClientPerfTester/WithUncancelledTask.swift

@@ -0,0 +1,25 @@
+public func withUncancelledTask<R: Sendable>(
+    returning: R.Type = R.self,
+    _ body: @Sendable @escaping () async throws -> R
+) async throws -> R {
+    // This looks unstructured but it isn't, please note that we `await` `.value` of this task.
+    // The reason we need this separate `Task` is that in general, we cannot assume that code performs to our
+    // expectations if the task we run it on is already cancelled. However, in some cases we need the code to
+    // run regardless -- even if our task is already cancelled. Therefore, we create a new, uncancelled task here.
+    try await Task {
+        try await body()
+    }.value
+}
+
+public func withUncancelledTask<R: Sendable>(
+    returning: R.Type = R.self,
+    _ body: @Sendable @escaping () async -> R
+) async -> R {
+    // This looks unstructured but it isn't, please note that we `await` `.value` of this task.
+    // The reason we need this separate `Task` is that in general, we cannot assume that code performs to our
+    // expectations if the task we run it on is already cancelled. However, in some cases we need the code to
+    // run regardless -- even if our task is already cancelled. Therefore, we create a new, uncancelled task here.
+    await Task {
+        await body()
+    }.value
+}