Fast asymmetric thread synchronization

Abstract

For most multi-threaded applications, data structures must be shared between threads. Ensuring thread safety on these data structures incurs overhead in the form of locking and other synchronization mechanisms. Where data is shared among multiple threads these costs are unavoidable. However, a common access pattern is that data is accessed primarily by one dominant thread, and only very rarely by the other, non-dominant threads. Previous research has proposed biased locks, which are optimized for a single dominant thread, at the cost of greater overheads for non-dominant threads. In this paper we propose a new family of biased synchronization mechanisms that, using a modified interface, push accesses to shared data from the non-dominant threads to the dominant one, via a novel set of message passing mechanisms. We present mechanisms for protecting critical sections, for queueing work, for caching shared data in registers where it is safe to do so, and for asynchronous critical section accesses. We present results for the conventional Intel R Sandy Bridge processor and for the emerging network-optimized many-core IBM R PowerEN TM processor. We find that our algorithms compete well with existing biased locking algorithms, and, in particular, perform better than existing algorithms as accesses from non-dominant threads increase.

On the Performance of Delegation over Cache-Coherent Shared Memory

“…An alternative is to pass a token (usually an integer) the server can use to decide what to execute [3]. This avoids function pointers and thus enables the compiler to optimize away the function call for every request, but this did not show performance benefits in our experiments because the other synchronization overheads on the tested processors dominate the overhead of a function call.…”

“…Remote Core Locking (RCL) [10] is an efficient implementation of the server approach over shared memory. Cleary et al [3] take a similar approach, but apply it to asymmetric synchronization, where one thread executes the CS much more often then the others. Suleman et al [19] propose delegation over dedicated hardware and evaluate how much chip real estate should be used for the server core.…”

Leveraging hardware message passing for efficient thread synchronization

“…We assume that shared data is accessed only inside CSes, which holds for the concurrent objects we evaluate. A more conservative use of memory fences would be necessary when this is not the case [9]. To obtain the best possible performance, we augment all of the implementations with a simple interface that allows a thread to send a unique opcode of the CS to the servicing thread, rather than a function pointer.…”

“…If contention is high, this results in a substantial performance increase over classic locks. We can identify two approaches that exploit this idea: the client-server approach [9,17], and the combiner approach [10,11,13,24].…”

Effective hardware-level thread synchronization for high performance and power efficiency in application specific multi-threaded embedded processors

“…Works on thread synchronization can be commonly found at the system level implementations, where operating system or special firmware coordinates and synchronizes threads execution to ensure the overall applications' functionality and performance [6] [7] [8].…”