Comparing the performance of concurrent linked-list implementations in Haskell

Authors:
Martin Sulzmann;Edmund S.L. Lam;Simon Marlow
Affiliations:
IT University of Copenhagen, Copenhagen, Denmark;National University of Singapore, Singapore, Singapore;Microsoft Research, Cambridge, Cambridge, Upper Volta
Venue:
Proceedings of the 4th workshop on Declarative aspects of multicore programming
Year:
2009

Citing 10
Cited 1

Concurrency of operations on B-trees

Readings in database systems
Concurrent Haskell

POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Asynchronous exceptions in Haskell

Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementation
A Pragmatic Implementation of Non-blocking Linked-Lists

DISC '01 Proceedings of the 15th International Conference on Distributed Computing
The Java memory model

Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Composable memory transactions

Proceedings of the tenth ACM SIGPLAN symposium on Principles and practice of parallel programming
Concurrent programming without locks

ACM Transactions on Computer Systems (TOCS)
Transactional boosting: a methodology for highly-concurrent transactional objects

Proceedings of the 13th ACM SIGPLAN Symposium on Principles and practice of parallel programming
The limits of software transactional memory (STM): dissecting Haskell STM applications on a many-core environment

Proceedings of the 5th conference on Computing frontiers
Foundations of the C++ concurrency memory model

Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation

Safe and familiar multi-core programming by means of a hybrid functional and imperative language

LCPC'09 Proceedings of the 22nd international conference on Languages and Compilers for Parallel Computing

Quantified Score

Hi-index	0.00

Visualization

Abstract

Haskell has a rich set of synchronization primitives for implementing shared-state concurrency abstractions, ranging from the very high level (Software Transactional Memory) to the very low level (mutable variables with atomic read-modify-write). In this paper we perform a systematic comparison of these different concurrent programming models by using them to implement the same abstraction: a concurrent linked-list. Our results are somewhat surprising: there is a full two orders of magnitude difference in performance between the slowest and the fastest implementation. Our analysis of the performance results gives new insights into the relative performance of the programming models and their implementation. Finally, we suggest the addition of a single primitive which in our experiments improves the performance of one of the STM-based implementations by more than a factor of 7.