4 Search Results for "Taubenfeld, Gadi"

Document
DOI: 10.4230/LIPIcs.DISC.2023.33
Memory-Anonymous Starvation-Free Mutual Exclusion: Possibility and Impossibility Results

Authors: Gadi Taubenfeld

Published in: LIPIcs, Volume 281, 37th International Symposium on Distributed Computing (DISC 2023)

Abstract
In an anonymous shared memory system, all inter-process communications are via shared objects; however, unlike in standard systems, there is no a priori agreement between processes on the names of shared objects [G. Taubenfeld, 2017; G. Taubenfeld, 2022]. Furthermore, the algorithms are required to be symmetric; that is, the processes should execute precisely the same code, and the only way to distinguish processes is by comparing identifiers for equality. For such a system, read/write registers are called anonymous registers. It is known that symmetric deadlock-free mutual exclusion is solvable for any finite number of processes using anonymous registers [Z. Aghazadeh et al., 2019]. The main question left open in [G. Taubenfeld, 2017; G. Taubenfeld, 2022] is the existence of starvation-free mutual exclusion algorithms for two or more processes. We resolve this open question for memoryless algorithms, in which a process that tries to enter its critical section does not use any information about its previous attempts. Almost all known mutual exclusion algorithms are memoryless. We show that, 1) There is a symmetric memoryless starvation-free mutual exclusion algorithm for two processes using m ≥ 7 anonymous registers if and only if m is odd. 2) There is no symmetric memoryless starvation-free mutual exclusion algorithm for n ≥ 3 processes using (any number of) anonymous registers. Our impossibility result is the only example of a system with fault-free processes, where global progress (i.e., deadlock-freedom) can be ensured, while individual progress to each process (i.e., starvation-freedom) cannot. It complements a known result for systems with failure-prone processes, that there are objects with lock-free implementations but without wait-free implementations [H. Attiya et al., 2022; M. Herlihy, 1991].
Cite as

Gadi Taubenfeld. Memory-Anonymous Starvation-Free Mutual Exclusion: Possibility and Impossibility Results. In 37th International Symposium on Distributed Computing (DISC 2023). Leibniz International Proceedings in Informatics (LIPIcs), Volume 281, pp. 33:1-33:17, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2023)

Copy BibTex To Clipboard

@InProceedings{taubenfeld:LIPIcs.DISC.2023.33,
  author =	{Taubenfeld, Gadi},
  title =	{{Memory-Anonymous Starvation-Free Mutual Exclusion: Possibility and Impossibility Results}},
  booktitle =	{37th International Symposium on Distributed Computing (DISC 2023)},
  pages =	{33:1--33:17},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-301-0},
  ISSN =	{1868-8969},
  year =	{2023},
  volume =	{281},
  editor =	{Oshman, Rotem},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops-dev.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2023.33},
  URN =		{urn:nbn:de:0030-drops-191599},
  doi =		{10.4230/LIPIcs.DISC.2023.33},
  annote =	{Keywords: anonymous shared memory, memory-anonymous algorithms, anonymous registers, starvation-free mutual exclusion}
}
Document
DOI: 10.4230/LIPIcs.DISC.2021.30
Constant RMR Group Mutual Exclusion for Arbitrarily Many Processes and Sessions

Authors: Liat Maor and Gadi Taubenfeld

Published in: LIPIcs, Volume 209, 35th International Symposium on Distributed Computing (DISC 2021)

Abstract
Group mutual exclusion (GME), introduced by Joung in 1998, is a natural synchronization problem that generalizes the classical mutual exclusion and readers and writers problems. In GME a process requests a session before entering its critical section; processes are allowed to be in their critical sections simultaneously provided they have requested the same session. We present a GME algorithm that (1) is the first to achieve a constant Remote Memory Reference (RMR) complexity for both cache coherent and distributed shared memory machines; and (2) is the first that can be accessed by arbitrarily many dynamically allocated processes and with arbitrarily many session names. Neither of the existing GME algorithms satisfies either of these two important properties. In addition, our algorithm has constant space complexity per process and satisfies the two strong fairness properties, first-come-first-served and first-in-first-enabled. Our algorithm uses an atomic instruction set supported by most modern processor architectures, namely: read, write, fetch-and-store and compare-and-swap.
Cite as

Liat Maor and Gadi Taubenfeld. Constant RMR Group Mutual Exclusion for Arbitrarily Many Processes and Sessions. In 35th International Symposium on Distributed Computing (DISC 2021). Leibniz International Proceedings in Informatics (LIPIcs), Volume 209, pp. 30:1-30:16, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)

Copy BibTex To Clipboard

@InProceedings{maor_et_al:LIPIcs.DISC.2021.30,
  author =	{Maor, Liat and Taubenfeld, Gadi},
  title =	{{Constant RMR Group Mutual Exclusion for Arbitrarily Many Processes and Sessions}},
  booktitle =	{35th International Symposium on Distributed Computing (DISC 2021)},
  pages =	{30:1--30:16},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-210-5},
  ISSN =	{1868-8969},
  year =	{2021},
  volume =	{209},
  editor =	{Gilbert, Seth},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops-dev.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2021.30},
  URN =		{urn:nbn:de:0030-drops-148322},
  doi =		{10.4230/LIPIcs.DISC.2021.30},
  annote =	{Keywords: Group mutual exclusion, RMR complexity, unbounded number of processes, fetch\&store (FAS), compare\&swap (CAS)}
}
Document
DOI: 10.4230/LIPIcs.DISC.2020.2
Intermediate Value Linearizability: A Quantitative Correctness Criterion

Authors: Arik Rinberg and Idit Keidar

Published in: LIPIcs, Volume 179, 34th International Symposium on Distributed Computing (DISC 2020)

Abstract
Big data processing systems often employ batched updates and data sketches to estimate certain properties of large data. For example, a CountMin sketch approximates the frequencies at which elements occur in a data stream, and a batched counter counts events in batches. This paper focuses on correctness criteria for concurrent implementations of such objects. Specifically, we consider quantitative objects, whose return values are from a totally ordered domain, with a particular emphasis on (ε,δ)-bounded objects that estimate a numerical quantity with an error of at most ε with probability at least 1 - δ. The de facto correctness criterion for concurrent objects is linearizability. Intuitively, under linearizability, when a read overlaps an update, it must return the object’s value either before the update or after it. Consider, for example, a single batched increment operation that counts three new events, bumping a batched counter’s value from 7 to 10. In a linearizable implementation of the counter, a read overlapping this update must return either 7 or 10. We observe, however, that in typical use cases, any intermediate value between 7 and 10 would also be acceptable. To capture this additional degree of freedom, we propose Intermediate Value Linearizability (IVL), a new correctness criterion that relaxes linearizability to allow returning intermediate values, for instance 8 in the example above. Roughly speaking, IVL allows reads to return any value that is bounded between two return values that are legal under linearizability. A key feature of IVL is that we can prove that concurrent IVL implementations of (ε,δ)-bounded objects are themselves (ε,δ)-bounded. To illustrate the power of this result, we give a straightforward and efficient concurrent implementation of an (ε, δ)-bounded CountMin sketch, which is IVL (albeit not linearizable). Finally, we show that IVL allows for inherently cheaper implementations than linearizable ones. In particular, we show a lower bound of Ω(n) on the step complexity of the update operation of any wait-free linearizable batched counter from single-writer objects, and propose a wait-free IVL implementation of the same object with an O(1) step complexity for update.
Cite as

Arik Rinberg and Idit Keidar. Intermediate Value Linearizability: A Quantitative Correctness Criterion. In 34th International Symposium on Distributed Computing (DISC 2020). Leibniz International Proceedings in Informatics (LIPIcs), Volume 179, pp. 2:1-2:17, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2020)

Copy BibTex To Clipboard

@InProceedings{rinberg_et_al:LIPIcs.DISC.2020.2,
  author =	{Rinberg, Arik and Keidar, Idit},
  title =	{{Intermediate Value Linearizability: A Quantitative Correctness Criterion}},
  booktitle =	{34th International Symposium on Distributed Computing (DISC 2020)},
  pages =	{2:1--2:17},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-168-9},
  ISSN =	{1868-8969},
  year =	{2020},
  volume =	{179},
  editor =	{Attiya, Hagit},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops-dev.dagstuhl.de/entities/document/10.4230/LIPIcs.DISC.2020.2},
  URN =		{urn:nbn:de:0030-drops-130801},
  doi =		{10.4230/LIPIcs.DISC.2020.2},
  annote =	{Keywords: concurrency, concurrent objects, linearizability}
}
Document
DOI: 10.4230/LIPIcs.OPODIS.2017.17
Mutual Exclusion Algorithms with Constant RMR Complexity and Wait-Free Exit Code

Authors: Rotem Dvir and Gadi Taubenfeld

Published in: LIPIcs, Volume 95, 21st International Conference on Principles of Distributed Systems (OPODIS 2017)

Abstract
Two local-spinning queue-based mutual exclusion algorithms are presented that have several de- sired properties: (1) their exit codes are wait-free, (2) they satisfy FIFO fairness, (3) they have constant RMR complexity in both the CC and the DSM models, (4) it is not assumed that the number of processes, n, is a priori known, that is, processes may appear or disappear intermit- tently, (5) they use only O(n) shared memory locations, and (6) they make no assumptions on what and how memory is allocated. The algorithms are inspired by J. M. Mellor-Crummey and M. L. Scott famous MCS queue- based algorithm [13] which, except for not having a wait-free exit code, satisfies similar properties. A drawback of the MCS algorithm is that executing the exit code (i.e., releasing a lock) requires spinning – a process executing its exit code may need to wait for the process that is behind it in the queue to take a step before it can proceed. The two new algorithms overcome this drawback while preserving the simplicity and elegance of the original algorithm. Our algorithms use exactly the same atomic instruction set as the original MCS algorithm, namely: read, write, fetch-and-store and compare-and-swap. In our second algorithm it is possible to recycle memory locations so that if there are L mutual exclusion locks, and each process accesses at most one lock at a time, then the algorithm needs only O(L + n) space, as compared to O(Ln) needed by our first algorithm.
Cite as

Rotem Dvir and Gadi Taubenfeld. Mutual Exclusion Algorithms with Constant RMR Complexity and Wait-Free Exit Code. In 21st International Conference on Principles of Distributed Systems (OPODIS 2017). Leibniz International Proceedings in Informatics (LIPIcs), Volume 95, pp. 17:1-17:16, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2018)

Copy BibTex To Clipboard

@InProceedings{dvir_et_al:LIPIcs.OPODIS.2017.17,
  author =	{Dvir, Rotem and Taubenfeld, Gadi},
  title =	{{Mutual Exclusion Algorithms with Constant RMR Complexity and Wait-Free Exit Code}},
  booktitle =	{21st International Conference on Principles of Distributed Systems (OPODIS 2017)},
  pages =	{17:1--17:16},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-061-3},
  ISSN =	{1868-8969},
  year =	{2018},
  volume =	{95},
  editor =	{Aspnes, James and Bessani, Alysson and Felber, Pascal and Leit\~{a}o, Jo\~{a}o},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops-dev.dagstuhl.de/entities/document/10.4230/LIPIcs.OPODIS.2017.17},
  URN =		{urn:nbn:de:0030-drops-86523},
  doi =		{10.4230/LIPIcs.OPODIS.2017.17},
  annote =	{Keywords: Mutual exclusion, locks, local-spinning, cache coherent, distributed shared memory, RMR complexity}
}
  • Refine by Author
  • 3 Taubenfeld, Gadi
  • 1 Dvir, Rotem
  • 1 Keidar, Idit
  • 1 Maor, Liat
  • 1 Rinberg, Arik

  • Refine by Classification
  • 2 Theory of computation → Distributed algorithms
  • 2 Theory of computation → Distributed computing models
  • 2 Theory of computation → Shared memory algorithms
  • 1 Computer systems organization → Parallel architectures
  • 1 Computing methodologies → Concurrent computing methodologies
  • Show More...

  • Refine by Keyword
  • 2 RMR complexity
  • 1 Group mutual exclusion
  • 1 Mutual exclusion
  • 1 anonymous registers
  • 1 anonymous shared memory
  • Show More...

  • Refine by Type
  • 4 document

  • Refine by Publication Year
  • 1 2018
  • 1 2020
  • 1 2021
  • 1 2023

Questions / Remarks / Feedback
X

Feedback for Dagstuhl Publishing


Thanks for your feedback!

Feedback submitted

Could not send message

Please try again later or send an E-mail
© 2023-2024 Schloss Dagstuhl – LZI GmbH Imprint Privacy Contact