Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
Synthesis: an efficient implementation of fundamental operating system services
Synthesis: an efficient implementation of fundamental operating system services
Scheduler activations: effective kernel support for the user-level management of parallelism
ACM Transactions on Computer Systems (TOCS)
A methodology for implementing highly concurrent data objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
Proceedings of the fourteenth annual ACM symposium on Principles of distributed computing
Lock-free linked lists using compare-and-swap
Proceedings of the fourteenth annual ACM symposium on Principles of distributed computing
The synergy between non-blocking synchronization and operating system structure
OSDI '96 Proceedings of the second USENIX symposium on Operating systems design and implementation
Scheduler-conscious synchronization
ACM Transactions on Computer Systems (TOCS)
Practical implementations of non-blocking synchronization primitives
PODC '97 Proceedings of the sixteenth annual ACM symposium on Principles of distributed computing
Evaluating the performance of non-blocking synchronization on shared-memory multiprocessors
Proceedings of the 2001 ACM SIGMETRICS international conference on Measurement and modeling of computer systems
The Effect of Scheduling Discipline on Spin Overhead in Shared Memory Parallel Systems
IEEE Transactions on Parallel and Distributed Systems
A Complete and Constant Time Wait-Free Implementation of CAS from LL/SC and Vice Versa
DISC '98 Proceedings of the 12th International Symposium on Distributed Computing
An efficient semaphore implementation scheme for small-memory embedded systems
RTAS '97 Proceedings of the 3rd IEEE Real-Time Technology and Applications Symposium (RTAS '97)
A Scheduling Mechanism for Lock-Free Operation of a Lightweight Process Library for SMP Computers
ICPADS '01 Proceedings of the Eighth International Conference on Parallel and Distributed Systems
Correction of a Memory Management Method for Lock-Free Data Structures
Correction of a Memory Management Method for Lock-Free Data Structures
Nonblocking synchronization and system design
Nonblocking synchronization and system design
Shared-memory mutual exclusion: major research trends since 1986
Distributed Computing - Papers in celebration of the 20th anniversary of PODC
Scalable lock-free dynamic memory allocation
Proceedings of the ACM SIGPLAN 2004 conference on Programming language design and implementation
Nonblocking memory management support for dynamic-sized data structures
ACM Transactions on Computer Systems (TOCS)
Efficient and Reliable Lock-Free Memory Reclamation Based on Reference Counting
ISPAN '05 Proceedings of the 8th International Symposium on Parallel Architectures,Algorithms and Networks
Locking under Pfair scheduling
ACM Transactions on Computer Systems (TOCS)
Efficient Synchronization under Global EDF Scheduling on Multiprocessors
ECRTS '06 Proceedings of the 18th Euromicro Conference on Real-Time Systems
Scheduling multithreaded computations by work stealing
SFCS '94 Proceedings of the 35th Annual Symposium on Foundations of Computer Science
LFTHREADS: a lock-free thread library
OPODIS'07 Proceedings of the 11th international conference on Principles of distributed systems
Allocating memory in a lock-free manner
ESA'05 Proceedings of the 13th annual European conference on Algorithms
Adaptive software transactional memory
DISC'05 Proceedings of the 19th international conference on Distributed Computing
| Hi-index | 0.00 |
This extended abstract presents LFTHREADS, a thread library entirely based on lock-free methods, i.e. no spinlocks or similar synchronization mechanisms are employed in the implementation of the multithreading. Since lockfreedom is highly desirable in multiprocessors/multicores due to its advantages in parallelism, fault-tolerance, convoy-avoidance and more, there is an increased demand in lock-free methods in parallel applications, hence also in multiprocessor/multicore system services. LFTHREADS is the first thread library that provides a lock-free implementation of blocking synchronization primitives for application threads; although the latter may sound like a contradicting goal, such objects have several benefits: e.g. library operations that block and unblock threads on the same synchronization object can make progress in parallel while maintaining the desired thread-level semantics and without having to wait for any "low" operations among them. Besides, as no spin-locks or similar synchronization mechanisms are employed, memory contention can be reduced and processors/cores are able to do useful work. As a consequence, applications, too, can enjoy enhanced parallelism and fault-tolerance. For the synchronization in LFTHREADS we have introduced a new method, which we call responsibility hand-off (RHO), that does not need any special kernel support. The RHO method is also of independent interest, as it can also serve as a tool for lock-free token passing, management of contention and interaction between scheduling and synchronization. This paper gives an outline and the context of LFTHREADS. For more details the reader is refered to [7] and [8].