199,515 research outputs found
Timed Multiparty Session Types
We propose a typing theory, based on multiparty session types, for modular verification of real-time choreographic interactions. To model real-time implementations, we introduce a simple calculus with delays and a decidable static proof system. The proof system ensures type safety and time-error freedom, namely processes respect the prescribed timing and causalities between interactions. A decidable condition on timed global types guarantees time-progress for validated processes with delays, and gives a sound and complete characterisation of a new class of CTAs with general topologies that enjoys progress and liveness
Are Lock-Free Concurrent Algorithms Practically Wait-Free?
Lock-free concurrent algorithms guarantee that some concurrent operation will
always make progress in a finite number of steps. Yet programmers prefer to
treat concurrent code as if it were wait-free, guaranteeing that all operations
always make progress. Unfortunately, designing wait-free algorithms is
generally a very complex task, and the resulting algorithms are not always
efficient. While obtaining efficient wait-free algorithms has been a long-time
goal for the theory community, most non-blocking commercial code is only
lock-free.
This paper suggests a simple solution to this problem. We show that, for a
large class of lock- free algorithms, under scheduling conditions which
approximate those found in commercial hardware architectures, lock-free
algorithms behave as if they are wait-free. In other words, programmers can
keep on designing simple lock-free algorithms instead of complex wait-free
ones, and in practice, they will get wait-free progress.
Our main contribution is a new way of analyzing a general class of lock-free
algorithms under a stochastic scheduler. Our analysis relates the individual
performance of processes with the global performance of the system using Markov
chain lifting between a complex per-process chain and a simpler system progress
chain. We show that lock-free algorithms are not only wait-free with
probability 1, but that in fact a general subset of lock-free algorithms can be
closely bounded in terms of the average number of steps required until an
operation completes.
To the best of our knowledge, this is the first attempt to analyze progress
conditions, typically stated in relation to a worst case adversary, in a
stochastic model capturing their expected asymptotic behavior.Comment: 25 page
On the Space Complexity of Set Agreement
The -set agreement problem is a generalization of the classical consensus
problem in which processes are permitted to output up to different input
values. In a system of processes, an -obstruction-free solution to the
problem requires termination only in executions where the number of processes
taking steps is eventually bounded by . This family of progress conditions
generalizes wait-freedom () and obstruction-freedom (). In this
paper, we prove upper and lower bounds on the number of registers required to
solve -obstruction-free -set agreement, considering both one-shot and
repeated formulations. In particular, we show that repeated set agreement
can be solved using registers and establish a nearly matching lower
bound of
Anonymous Obstruction-free -Set Agreement with Atomic Read/Write Registers
The -set agreement problem is a generalization of the consensus problem.
Namely, assuming each process proposes a value, each non-faulty process has to
decide a value such that each decided value was proposed, and no more than
different values are decided. This is a hard problem in the sense that it
cannot be solved in asynchronous systems as soon as or more processes may
crash. One way to circumvent this impossibility consists in weakening its
termination property, requiring that a process terminates (decides) only if it
executes alone during a long enough period. This is the well-known
obstruction-freedom progress condition. Considering a system of {\it
anonymous asynchronous} processes, which communicate through atomic {\it
read/write registers only}, and where {\it any number of processes may crash},
this paper addresses and solves the challenging open problem of designing an
obstruction-free -set agreement algorithm with atomic registers
only. From a shared memory cost point of view, this algorithm is the best
algorithm known so far, thereby establishing a new upper bound on the number of
registers needed to solve the problem (its gain is with respect to the
previous upper bound). The algorithm is then extended to address the repeated
version of -set agreement. As it is optimal in the number of atomic
read/write registers, this algorithm closes the gap on previously established
lower/upper bounds for both the anonymous and non-anonymous versions of the
repeated -set agreement problem. Finally, for 1 \leq x\leq k
\textless{} n, a generalization suited to -obstruction-freedom is also
described, which requires atomic registers only
Modular termination verification for non-blocking concurrency
© Springer-Verlag Berlin Heidelberg 2016.We present Total-TaDA, a program logic for verifying the total correctness of concurrent programs: that such programs both terminate and produce the correct result. With Total-TaDA, we can specify constraints on a threadâs concurrent environment that are necessary to guarantee termination. This allows us to verify total correctness for nonblocking algorithms, e.g. a counter and a stack. Our specifications can express lock- and wait-freedom. More generally, they can express that one operation cannot impede the progress of another, a new non-blocking property we call non-impedance. Moreover, our approach is modular. We can verify the operations of a module independently, and build up modules on top of each other
- âŠ