{"abstract":[{"text":"Asynchronous programming has gained significant popularity over the last decade: support for this programming pattern is available in many popular languages via libraries and native language implementations, typically in the form of coroutines or the async/await construct. Instead of programming via shared memory, this concept assumes implicit synchronization through message passing. The key data structure enabling such communication is the rendezvous channel. Roughly, a rendezvous channel is a blocking queue of size zero, so both send(e) and receive() operations wait for each other, performing a rendezvous when they meet. To optimize the message passing pattern, channels are usually equipped with a fixed-size buffer, so sends do not suspend and put elements into the buffer until its capacity is exceeded. This primitive is known as a buffered channel.\r\n\r\nThis paper presents a fast and scalable algorithm for both rendezvous and buffered channels. Similarly to modern queues, our solution is based on an infinite array with two positional counters for send(e) and receive() operations, leveraging the unconditional Fetch-And-Add instruction to update them. Yet, the algorithm requires non-trivial modifications of this classic pattern, in order to support the full channel semantics, such as buffering and cancellation of waiting requests. We compare the performance of our solution to that of the Kotlin implementation, as well as against other academic proposals, showing up to 9.8× speedup. To showcase its expressiveness and performance, we also integrated the proposed algorithm into the standard Kotlin Coroutines library, replacing the previous channel implementations.","lang":"eng"}],"author":[{"first_name":"Nikita","last_name":"Koval","full_name":"Koval, Nikita","id":"2F4DB10C-F248-11E8-B48F-1D18A9856A87"},{"id":"4A899BFC-F248-11E8-B48F-1D18A9856A87","orcid":"0000-0003-3650-940X","full_name":"Alistarh, Dan-Adrian","last_name":"Alistarh","first_name":"Dan-Adrian"},{"first_name":"Roman","full_name":"Elizarov, Roman","last_name":"Elizarov"}],"citation":{"chicago":"Koval, Nikita, Dan-Adrian Alistarh, and Roman Elizarov. “Fast and Scalable Channels in Kotlin Coroutines.” In <i>Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming</i>, 107–18. Association for Computing Machinery, 2023. <a href=\"https://doi.org/10.1145/3572848.3577481\">https://doi.org/10.1145/3572848.3577481</a>.","apa":"Koval, N., Alistarh, D.-A., &#38; Elizarov, R. (2023). Fast and scalable channels in Kotlin Coroutines. In <i>Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming</i> (pp. 107–118). Montreal, QC, Canada: Association for Computing Machinery. <a href=\"https://doi.org/10.1145/3572848.3577481\">https://doi.org/10.1145/3572848.3577481</a>","short":"N. Koval, D.-A. Alistarh, R. Elizarov, in:, Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Association for Computing Machinery, 2023, pp. 107–118.","mla":"Koval, Nikita, et al. “Fast and Scalable Channels in Kotlin Coroutines.” <i>Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming</i>, Association for Computing Machinery, 2023, pp. 107–18, doi:<a href=\"https://doi.org/10.1145/3572848.3577481\">10.1145/3572848.3577481</a>.","ieee":"N. Koval, D.-A. Alistarh, and R. Elizarov, “Fast and scalable channels in Kotlin Coroutines,” in <i>Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming</i>, Montreal, QC, Canada, 2023, pp. 107–118.","ista":"Koval N, Alistarh D-A, Elizarov R. 2023. Fast and scalable channels in Kotlin Coroutines. Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming. PPoPP: Sympopsium on Principles and Practice of Parallel Programming, 107–118.","ama":"Koval N, Alistarh D-A, Elizarov R. Fast and scalable channels in Kotlin Coroutines. In: <i>Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming</i>. Association for Computing Machinery; 2023:107-118. doi:<a href=\"https://doi.org/10.1145/3572848.3577481\">10.1145/3572848.3577481</a>"},"_id":"12735","external_id":{"arxiv":["2211.04986"]},"publication_identifier":{"isbn":["9798400700156"]},"language":[{"iso":"eng"}],"type":"conference","quality_controlled":"1","year":"2023","oa_version":"Preprint","date_published":"2023-02-25T00:00:00Z","publisher":"Association for Computing Machinery","title":"Fast and scalable channels in Kotlin Coroutines","date_updated":"2023-03-20T07:29:28Z","user_id":"2DF688A6-F248-11E8-B48F-1D18A9856A87","month":"02","publication":"Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming","day":"25","publication_status":"published","department":[{"_id":"DaAl"}],"main_file_link":[{"open_access":"1","url":"https://doi.org/10.48550/arXiv.2211.04986"}],"status":"public","doi":"10.1145/3572848.3577481","article_processing_charge":"No","page":"107-118","conference":{"name":"PPoPP: Sympopsium on Principles and Practice of Parallel Programming","start_date":"2023-02-25","location":"Montreal, QC, Canada","end_date":"2023-03-01"},"scopus_import":"1","date_created":"2023-03-19T23:00:58Z","oa":1}