Sleeping tasks high memory usage after being cancelled

[MarSe32m]

Describe the bug
Memory usage of a program, which cancels one million sleeping tasks, doesn't go down but stays at around 500-550MB.

Steps To Reproduce

public func sleepy() async throws {
    var tasks = [Task<Void, Never>]()
    for _ in 0..<1_000_000 {
        tasks.append(Task.detached {
            try? await Task.sleep(nanoseconds: UInt64(Int.max))
        })
    }
    
    for task in tasks {
        task.cancel()
        await task.value
    }
    tasks.removeAll()
}

@main
struct Main {
    public static func main() async throws {
        try await sleepy()
        // After running sleepy(), Xcode shows a memory usage of around 500-550MB
        try await Task.sleep(nanoseconds: 120_000_000_000)
    }
}

Expected behavior
The memory usage is expected to go down to around 30MB, since that is the amount of memory used for starting one million empty tasks.

Screenshots

Environment

• OS: macOS 12.5 Xcode Version 13.4.1, Ubuntu 20.04, Windows 10, Windows 11. Any platform I could get my hands on.
• Swift version 5.6.2 and Swift Development Snapshot 2022-08-01

Additional context
I suspect the issue arises from the fact that enqueued sleep tasks stay in the system for the duration of the sleep even though the sleep is cancelled. And the culprit being the call to dispatch_after_f since there is no way currently to remove the enqueued block.

[sliemeobn]

most likely I stumbled over this same issue, but I wanted to add my use case for more context:

I use this little helper to provide an auto-cancel-task-on-timeout behavior, and I believe the implementation is pretty much "as intended" for structured concurrency.

public struct TimedOutError: Error, Equatable {}

public func withTimeout<R>(
    deadline: ContinuousClock.Instant,
    operation: @escaping @Sendable () async throws -> R
) async rethrows -> R {
    return try await withThrowingTaskGroup(of: R.self) { group in
        group.addTask { try await operation() }

        // if I comment this Task.sleep task out, the leak is gone
        group.addTask {
            try await Task.sleep(until: deadline, clock: .continuous)
            throw TimedOutError()
        }
        
        let result = try await group.next()!
        group.cancelAll()
        return result
    }
}

Running this test shows the issue quite clearly: It will drive up memory >100MB within seconds:

func testMemoryLeak() async throws {
    for _ in 1...10000000 {
      await withTimeout(deadline: .now.advanced(by: .seconds(100))) {
        await Task.yield()
      }
    }
  }

As far as I can tell the callstack for leaky allocations is this

swift_slowAlloc	
swift_allocObject	
closure #1 in closure #1 in static Task<>._sleep(until:_:tolerance:clock:)	
static Task<>._sleep(until:_:tolerance:clock:)	
swift::runJobInEstablishedExecutorContext(swift::Job*)	
swift_job_runImpl(swift::Job*, swift::ExecutorRef)	
_dispatch_root_queue_drain	
_dispatch_worker_thread2	
_pthread_wqthread	
start_wqthread	

[AnthonyLatsis]

@ktoso Does this sound more like a memory leak or an implementation quirk?

[sliemeobn]

as I see the tags I realize that I forgot to mention that I saw this behavior on Swift 5.8, both macOS (arm) and swift docker image (x64)