The Experts below are selected from a list of 1017 Experts worldwide ranked by ideXlab platform
Xu Liu - One of the best experts on this subject based on the ideXlab platform.
-
efficient abortable locking protocol for multi level numa systems design and correctness
Parallel Computing, 2020Co-Authors: Milind Chabbi, Abdelhalim Amer, Xu LiuAbstract:The popularity of Non-Uniform Memory Access (NUMA) architectures has led to numerous locality-preserving hierarchical lock designs, such as HCLH, HMCS, and cohort locks. Locality-preserving locks trade fairness for higher throughput. Hence, some instances of acquisitions can incur long latencies, which can be intolerable for certain applications. Few locks allow a Waiting Thread to abort on a timeout. State-of-the-art abortable locks are not fully locality aware, introduce high overheads, and are unsuitable for frequent aborts. Enhancing locality-aware locks with lightweight timeout capability is critical for their adoption. In this article, we describe the design and implementation of the HMCS-T lock, a Hierarchical MCS (HMCS) lock variant that admits timeout. HMCS-T maintains the locality benefits of HMCS while ensuring aborts are lightweight. HMCS-T offers the progress guarantee missing in most abortable queuing locks. The resulting locking algorithm is complex and stateful. Proving the correctness of a complex, stateful synchronization algorithm is challenging. We prove the correctness of HMCS-T by first decomposing the problem via a novel technique that uses non-deterministic finite acceptors (NFAs). The decomposed problems become small enough to be mechanically model checked without a state-space explosion. Then, we generalize the correctness proof of any arbitrary lock configuration using a construction argument.
-
an efficient abortable locking protocol for multi level numa systems
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Milind Chabbi, Abdelhalim Amer, Shasha Wen, Xu LiuAbstract:The popularity of Non-Uniform Memory Access (NUMA) architectures has led to numerous locality-preserving hierarchical lock designs, such as HCLH, HMCS, and cohort locks. Locality-preserving locks trade fairness for higher throughput. Hence, some instances of acquisitions can incur long latencies, which may be intolerable for certain applications. Few locks admit a Waiting Thread to abandon its protocol on a timeout. State-of-the-art abortable locks are not fully locality aware, introduce high overheads, and unsuitable for frequent aborts. Enhancing locality-aware locks with lightweight timeout capability is critical for their adoption. In this paper, we design and evaluate the HMCS-T lock, a Hierarchical MCS (HMCS) lock variant that admits a timeout. HMCS-T maintains the locality benefits of HMCS while ensuring aborts to be lightweight. HMCS-T offers the progress guarantee missing in most abortable queuing locks. Our evaluations show that HMCS-T offers the timeout feature at a moderate overhead over its HMCS analog. HMCS-T, used in an MPI runtime lock, mitigated the poor scalability of an MPI+OpenMP BFS code and resulted in 4.3x superior scaling.
Milind Chabbi - One of the best experts on this subject based on the ideXlab platform.
-
efficient abortable locking protocol for multi level numa systems design and correctness
Parallel Computing, 2020Co-Authors: Milind Chabbi, Abdelhalim Amer, Xu LiuAbstract:The popularity of Non-Uniform Memory Access (NUMA) architectures has led to numerous locality-preserving hierarchical lock designs, such as HCLH, HMCS, and cohort locks. Locality-preserving locks trade fairness for higher throughput. Hence, some instances of acquisitions can incur long latencies, which can be intolerable for certain applications. Few locks allow a Waiting Thread to abort on a timeout. State-of-the-art abortable locks are not fully locality aware, introduce high overheads, and are unsuitable for frequent aborts. Enhancing locality-aware locks with lightweight timeout capability is critical for their adoption. In this article, we describe the design and implementation of the HMCS-T lock, a Hierarchical MCS (HMCS) lock variant that admits timeout. HMCS-T maintains the locality benefits of HMCS while ensuring aborts are lightweight. HMCS-T offers the progress guarantee missing in most abortable queuing locks. The resulting locking algorithm is complex and stateful. Proving the correctness of a complex, stateful synchronization algorithm is challenging. We prove the correctness of HMCS-T by first decomposing the problem via a novel technique that uses non-deterministic finite acceptors (NFAs). The decomposed problems become small enough to be mechanically model checked without a state-space explosion. Then, we generalize the correctness proof of any arbitrary lock configuration using a construction argument.
-
an efficient abortable locking protocol for multi level numa systems
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Milind Chabbi, Abdelhalim Amer, Shasha Wen, Xu LiuAbstract:The popularity of Non-Uniform Memory Access (NUMA) architectures has led to numerous locality-preserving hierarchical lock designs, such as HCLH, HMCS, and cohort locks. Locality-preserving locks trade fairness for higher throughput. Hence, some instances of acquisitions can incur long latencies, which may be intolerable for certain applications. Few locks admit a Waiting Thread to abandon its protocol on a timeout. State-of-the-art abortable locks are not fully locality aware, introduce high overheads, and unsuitable for frequent aborts. Enhancing locality-aware locks with lightweight timeout capability is critical for their adoption. In this paper, we design and evaluate the HMCS-T lock, a Hierarchical MCS (HMCS) lock variant that admits a timeout. HMCS-T maintains the locality benefits of HMCS while ensuring aborts to be lightweight. HMCS-T offers the progress guarantee missing in most abortable queuing locks. Our evaluations show that HMCS-T offers the timeout feature at a moderate overhead over its HMCS analog. HMCS-T, used in an MPI runtime lock, mitigated the poor scalability of an MPI+OpenMP BFS code and resulted in 4.3x superior scaling.
Abdelhalim Amer - One of the best experts on this subject based on the ideXlab platform.
-
efficient abortable locking protocol for multi level numa systems design and correctness
Parallel Computing, 2020Co-Authors: Milind Chabbi, Abdelhalim Amer, Xu LiuAbstract:The popularity of Non-Uniform Memory Access (NUMA) architectures has led to numerous locality-preserving hierarchical lock designs, such as HCLH, HMCS, and cohort locks. Locality-preserving locks trade fairness for higher throughput. Hence, some instances of acquisitions can incur long latencies, which can be intolerable for certain applications. Few locks allow a Waiting Thread to abort on a timeout. State-of-the-art abortable locks are not fully locality aware, introduce high overheads, and are unsuitable for frequent aborts. Enhancing locality-aware locks with lightweight timeout capability is critical for their adoption. In this article, we describe the design and implementation of the HMCS-T lock, a Hierarchical MCS (HMCS) lock variant that admits timeout. HMCS-T maintains the locality benefits of HMCS while ensuring aborts are lightweight. HMCS-T offers the progress guarantee missing in most abortable queuing locks. The resulting locking algorithm is complex and stateful. Proving the correctness of a complex, stateful synchronization algorithm is challenging. We prove the correctness of HMCS-T by first decomposing the problem via a novel technique that uses non-deterministic finite acceptors (NFAs). The decomposed problems become small enough to be mechanically model checked without a state-space explosion. Then, we generalize the correctness proof of any arbitrary lock configuration using a construction argument.
-
an efficient abortable locking protocol for multi level numa systems
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Milind Chabbi, Abdelhalim Amer, Shasha Wen, Xu LiuAbstract:The popularity of Non-Uniform Memory Access (NUMA) architectures has led to numerous locality-preserving hierarchical lock designs, such as HCLH, HMCS, and cohort locks. Locality-preserving locks trade fairness for higher throughput. Hence, some instances of acquisitions can incur long latencies, which may be intolerable for certain applications. Few locks admit a Waiting Thread to abandon its protocol on a timeout. State-of-the-art abortable locks are not fully locality aware, introduce high overheads, and unsuitable for frequent aborts. Enhancing locality-aware locks with lightweight timeout capability is critical for their adoption. In this paper, we design and evaluate the HMCS-T lock, a Hierarchical MCS (HMCS) lock variant that admits a timeout. HMCS-T maintains the locality benefits of HMCS while ensuring aborts to be lightweight. HMCS-T offers the progress guarantee missing in most abortable queuing locks. Our evaluations show that HMCS-T offers the timeout feature at a moderate overhead over its HMCS analog. HMCS-T, used in an MPI runtime lock, mitigated the poor scalability of an MPI+OpenMP BFS code and resulted in 4.3x superior scaling.
Shasha Wen - One of the best experts on this subject based on the ideXlab platform.
-
an efficient abortable locking protocol for multi level numa systems
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017Co-Authors: Milind Chabbi, Abdelhalim Amer, Shasha Wen, Xu LiuAbstract:The popularity of Non-Uniform Memory Access (NUMA) architectures has led to numerous locality-preserving hierarchical lock designs, such as HCLH, HMCS, and cohort locks. Locality-preserving locks trade fairness for higher throughput. Hence, some instances of acquisitions can incur long latencies, which may be intolerable for certain applications. Few locks admit a Waiting Thread to abandon its protocol on a timeout. State-of-the-art abortable locks are not fully locality aware, introduce high overheads, and unsuitable for frequent aborts. Enhancing locality-aware locks with lightweight timeout capability is critical for their adoption. In this paper, we design and evaluate the HMCS-T lock, a Hierarchical MCS (HMCS) lock variant that admits a timeout. HMCS-T maintains the locality benefits of HMCS while ensuring aborts to be lightweight. HMCS-T offers the progress guarantee missing in most abortable queuing locks. Our evaluations show that HMCS-T offers the timeout feature at a moderate overhead over its HMCS analog. HMCS-T, used in an MPI runtime lock, mitigated the poor scalability of an MPI+OpenMP BFS code and resulted in 4.3x superior scaling.
Jacobs Bart - One of the best experts on this subject based on the ideXlab platform.
-
Deadlock-Free Monitors
'Springer Science and Business Media LLC', 2018Co-Authors: Hamin Jafar, Jacobs BartAbstract:Monitors constitute one of the common techniques to synchronize Threads in multiThreaded programs, where calling a wait command on a condition variable suspends the caller Thread and notifying a condition variable causes the Threads Waiting for that condition variable to resume their execution. One potential problem with these programs is that a Waiting Thread might be suspended forever leading to deadlock, a state where each Thread of the program is Waiting for a condition variable or a lock. In this paper, a modular verification approach for deadlock-freedom of such programs is presented, ensuring that in any state of the execution of the program if there are some Threads suspended then there exists at least one Thread running. The main idea behind this approach is to make sure that for any condition variable v for which a Thread is Waiting there exists a Thread obliged to fulfil an obligation for v that only waits for a waitable object whose wait level, an arbitrary number associated with each waitable object, is less than the wait level of v. The relaxed precedence relation introduced in this paper, aiming to avoid cycles, can also benefit some other verification approaches, verifying deadlock-freedom of other synchronization constructs such as channels and semaphores, enabling them to accept a wider range of deadlock-free programs. We encoded the proposed proof rules in the VeriFast program verifier and by defining some appropriate invariants for the locks associated with some condition variables succeeded in verifying some popular use cases of monitors including unbounded/bounded buffer, sleeping barber, barrier, and readers-writers locks. A soundness proof for the presented approach is provided; some of the trickiest lemmas in this proof have been machine-checked with Coq.status: publishe
-
Deadlock-free monitors: Extended version
Leuven Belgium, 2018Co-Authors: Hamin Jafar, Jacobs BartAbstract:Monitors constitute one of the common techniques to synchronize Threads in multiThreaded programs, where calling a wait command on a condition variable suspends the caller Thread and notifying a condition variable causes the Threads Waiting for that condition variable to resume their execution. One potential problem with these programs is that a Waiting Thread might be suspended forever leading to deadlock, a state where each Thread of the program is Waiting for a condition variable or a lock. In this paper, a modular verification approach for deadlock-freedom of such programs is presented, ensuring that in any state of the execution of the program if there are some Threads suspended then there exists at least one Thread running. The main idea behind this approach is to make sure that for any condition variable v for which a Thread is Waiting there exists a Thread obliged to fulfil an obligation for v that only waits for a waitable object whose wait level, an arbitrary number associated with each waitable object, is less than the wait level of v. The relaxed precedence relation introduced in this paper, aiming to avoid cycles, can also benefit some other verification approaches, verifying deadlock-freedom of other synchronization constructs such as channels and semaphores, enabling them to accept a wider range of deadlock-free programs. We encoded the proposed proof rules in the VeriFast program verifier and by defining some appropriate invariants for the locks associated with some condition variables succeeded in verifying some popular use cases of monitors including unbounded/bounded buffer, sleeping barber, barrier, and readers-writers locks. A soundness proof for the presented approach is provided; some of the trickiest lemmas in this proof have been machine-checked with Coq.nrpages: 36status: publishe
-
Modular verification of deadlock-freedom in the presence of condition variables
Department of Computer Science KU Leuven, 2017Co-Authors: Hamin Jafar, Jacobs BartAbstract:One of the common methods to synchronize Threads in multiThreaded programs is using condition variables, where calling the wait command for a condition variable blocks the caller Thread and calling a signal command over that condition variable unblocks all the blocked Threads Waiting for that condition variable. One potential problem with these programs is that a Waiting Thread is not signaled and is blocked forever. In this paper a verification approach for deadlock-freedom of such programs is presented. In this approach a correspondence is established between a condition variable and a ghost variable, such that its value when a condition variable is created and a wait command for that variable is called is non-negative and non-positive, respectively. Calling a wait command for a condition variable requires a credit for that variable, where a credit for that condition variable can be achieved when another Thread increments the corresponding ghost variable and also signals that condition variable if the old value is zero. We are now developing a Coq formalization to formally prove soundness of the presented approach.nrpages: 15status: publishe
