COOKIES: By using this website you agree that we can place Google Analytics Cookies on your device for performance monitoring. |
University of Cambridge > Talks.cam > Computer Laboratory Programming Research Group Seminar > Functional Abstractions for Practical and Scalable Concurrent Programming
Functional Abstractions for Practical and Scalable Concurrent ProgrammingAdd to your list(s) Download to your calendar using vCal
If you have a question about this talk, please contact Raphael Proust. This talk has been canceled/deleted Functional programming languages have long been viewed as particularly well-suited for expressing concurrent computations; first-class functions and expression oriented syntax make it convenient to express concurrent threads of control, while the lack of pervasive side-effects simplifies reasoning and facilitates optimizations. As functional programming languages are applied to new domains such as programming non-cache-coherent multicores, GPUs, and compute clouds, there is a need for new concurrency abstractions that are not only simple to reason about, but also ensure good performance. My research has focused on discovering these abstractions and realizing them in modern functional language runtimes; this talk will focus on two of these. First, I will present Rx-CML, an optimistic concurrency control mechanism for synchronous message-passing programs that simplifies the task of writing scalable programs for compute clouds. Rx-CML allows the programmers to express synchronous protocols, which are dynamically discharged asynchronously in order to hide inter-node latency. Executions that do not conform to the synchronous semantics of the protocol are dynamically detected and remediated. Next, I will describe a new concurrency substrate design for the long-standing goal of allowing user-written schedulers in concurrent/parallel Haskell. Through the use of software transactional memory and scheduler activations, the concurrency substrate simplifies the task of building user-level schedulers, which, by construction, safely interact with other runtime system components as well as concurrency libraries. This talk is part of the Computer Laboratory Programming Research Group Seminar series. This talk is included in these lists:This talk is not included in any other list Note that ex-directory lists are not shown. |
Other listsResearch Reports Events Faculty of Education Seminars Cambridge Climate Lecture Series Type the title of a new list here The Impact of Social Science Research Computer Laboratory Programming Research Group SeminarOther talksThe ‘Easy’ and ‘Hard’ Problems of Consciousness Putting Feminist New Materialism to work through affective methodologies in early childhood research Volcanoes and Explosions Localization and chiral splitting in scattering amplitudes Finding meaning in English writing Scale and anisotropic effects in necking of metallic tensile specimens Atiyah Floer conjecture Statistical Methods in Pre- and Clinical Drug Development: Tumour Growth-Inhibition Model Example Are hospital admissions for people with palliative care needs avoidable and unwanted? A polyfold lab report Designer Babies or Children of Frankenstein? Genome Editing and its Side Effects |