Hexagen: True coroutines for Swift (opens in new tab)

(github.com)

47 pointsglittershark11y ago3 comments

3 comments

3 comments · 2 top-level

Sidnicious11y ago· 1 in thread

Wouldn't it be possible to implement all of the same semantics in pure Swift using a concurrent dispatch queue and some semaphores? I tried making a generator like the one in Hexagen:

https://gist.github.com/Sidnicious/8e57892b14629c5ec740

I understand the main benefits of coroutines as:

- Cheap creation

- Cheap context switching

- Predictable context switching

…and I don't know the performance characteristics of Grand Central Dispatch. Could someone who's more familiar with GCD explain why using it for this kind of concurrency is an okay/bad idea and how it compares to coroutines?

(FWIW I'm a huge fan of hacking async semantics into languages and made a thing like this for C++: https://github.com/Sidnicious/team)

eridius11y ago

Every time you block while on a dispatch queue, you're suspending the entire OS thread. GCD will spin up new threads to service queues when the old ones are blocked, but it won't do this forever. At some point you'll hit a limit where GCD refuses to spin up any new threads and you can't make any progress until one of your existing queues resumes doing work.

You can test this yourself. Experimentally, the limit on OS X 10.10.2 (with the global background queue) is 64 blocked threads. I used the following program to see that: https://gist.github.com/kballard/ff3640e08f2238875680

puls11y ago

Previously on HN: https://news.ycombinator.com/item?id=9132385

j / k navigate · click thread line to collapse