Parallel graph reduction with the (v , G)-machine
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
Scheduler activations: effective kernel support for the user-level management of parallelism
ACM Transactions on Computer Systems (TOCS)
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Visual haskell: a full-featured haskell development environment
Proceedings of the 2005 ACM SIGPLAN workshop on Haskell
Haskell on a shared-memory multiprocessor
Proceedings of the 2005 ACM SIGPLAN workshop on Haskell
A history of Haskell: being lazy with class
Proceedings of the third ACM SIGPLAN conference on History of programming languages
Lightweight concurrency primitives for GHC
Haskell '07 Proceedings of the ACM SIGPLAN workshop on Haskell workshop
Runtime support for multicore Haskell
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
Scalable i/o event handling for GHC
Proceedings of the third ACM Haskell symposium on Haskell
Multicore garbage collection with local heaps
Proceedings of the international symposium on Memory management
A high-level implementation of composable memory transactions in concurrent haskell
IFL'05 Proceedings of the 17th international conference on Implementation and Application of Functional Languages
Parallel and concurrent programming in Haskell
CEFP'11 Proceedings of the 4th Summer School conference on Central European Functional Programming School
Mio: a high-performance multicore io manager for GHC
Proceedings of the 2013 ACM SIGPLAN symposium on Haskell
| Hi-index | 0.00 |
A Haskell system that includes both the Foreign Function Interface and the Concurrent Haskell extension must consider how Concurrent Haskell threads map to external Operating System threads for the purposes of specifying in which thread a foreign call is made.Many concurrent languages take the easy route and specify a one-to-one correspondence between the language's own threads and external OS threads. However, OS threads tend to be expensive, so this choice can limit the performance and scalability of the concurrent language.The main contribution of this paper is a language design that provides a neat solution to this problem, allowing the implementor of the language enough flexibility to provide cheap lightweight threads, while still providing the programmer with control over the mapping between internal threads and external threads where necessary.