The convoy phenomenon Blasgen et al., IBM Research Report 1977 (revised 1979) Today we’re jumping from HotOS topics of 2019, to hot topics of 1977! With thanks to Pat Helland for the recommendation, and with Jim Gray as one of the authors, we have a combination that’s very hard to ignore :). Here’s the set-up … Continue reading The convoy phenomenon
Tag: Concurrency
Understanding real-world concurrency bugs in Go
Understanding real-world concurrency bugs in Go Tu, Liu et al., ASPLOS'19 The design of a programming (or data) model not only makes certain problems easier (or harder) to solve, but also makes certain classes of bugs easier (or harder) to create, detect, and subsequently fix. Today’s paper choice studies concurrency mechanisms in Go. Before we … Continue reading Understanding real-world concurrency bugs in Go
Bounding data races in space and time – part II
Bounding data races in space and time Dolan et al., PLDI'18 Yesterday we looked at the case for memory models supporting local data-race-freedom (local DRF). In today’s post we’ll push deeper into the paper and look at a memory model which does just that. Consider a memory store $latex S$ which maps locations to values. … Continue reading Bounding data races in space and time – part II
Bounding data races in space and time – part I
Bounding data races in space and time Dolan et al., PLDI'18 Are you happy with your programming language’s memory model? In this beautifully written paper, Dolan et al. point out some of the unexpected behaviours that can arise in mainstream memory models (C++, Java) and why we might want to strive for something better. Then … Continue reading Bounding data races in space and time – part I
A static verification framework for message passing in Go using behavioural types
A static verification framework for message passing in Go using behavioural types Lange et al., ICSE 18 With thanks to Alexis Richardson who first forwarded this paper to me. We’re jumping ahead to ICSE 18 now, and a paper that has been accepted for publication there later this year. It fits with the theme we’ve … Continue reading A static verification framework for message passing in Go using behavioural types
ffwd: delegation is (much) faster than you think
ffwd: delegation is (much) faster than you think Roghanchi et al., SOSP’17 (Note: the paper link above should give you access to this paper in the ACM DL when accessed from The Morning Paper blog. If you’re subscribed via email and don’t otherwise have access, you might need to go via the blog site to … Continue reading ffwd: delegation is (much) faster than you think
A concurrent perspective on smart contracts
A concurrent perspective on smart contracts Sergey & Hobor, Workshop on Trusted Smart Contracts, 2017 Maurice Herlihy gave a keynote on 'Blockchains and the future of distributed computing' at PODC'17. In his slides (I wasn't there to hear the talk in person), he recommends reading 'A concurrent perspective on smart contracts.' And here we are! … Continue reading A concurrent perspective on smart contracts
SyncPerf: Categorizing, detecting, and diagnosing synchronization performance bugs
SyncPerf: Categorizing, detecting, and diagnosing synchronization performance bugs Mejbah ul Alam et al., EuroSys'17 This paper is an investigation into the causes of synchronisation-related performance issues in concurrent systems, together with a pair of tools that can help to detect and diagnose them. The main SyncPerf detection tool is very lightweight (average overhead 2.3%). It … Continue reading SyncPerf: Categorizing, detecting, and diagnosing synchronization performance bugs
Fencing off Go: Liveness and safety for channel-based programming
Fencing off Go: Liveness and safety for channel-based programming, Lange et al. POPL 2017 In the true spirit of POPL (Principles of Programming Languages), I present today's summary of 'Fencing off Go' : What more do you need to know? Let's try again :) Fencing off Go: Liveness and safety for channel-based programming, Lange et … Continue reading Fencing off Go: Liveness and safety for channel-based programming
Transactional data structure libraries
Transactional Data Structure Libraries Spiegelman et al. PLDI 2016 Today’s choice won a distinguished paper award at the recent PLDI 2016 conference. Spiegelman et al. show how to add transactional support to in-memory concurrent data structure libraries in a way that doesn’t sacrifice performance. Since the advent of the multi-core revolution, many efforts have been … Continue reading Transactional data structure libraries
the morning paper 