Soma Chaudhuri

More choices allow more faults : set consensus problems in totally asynchronous systems

Abstract We define the k-SET CONSENSUS PROBLEM as an extension of the CONSENSUS problem, where each processor decides on a single value such that the set of decided values in any run is of size at most k. We require the agreement condition that all values decided upon are initial values of some processor. We show that the problem has a simple (k−1)-resilient protocol in a totally asynchronous system. In an attempt to come up with a matching lower bound on the number of failures, we study the uncertainty condition, which requires that there must be some initial configuration from which all possible input values can be decided. We prove using a combinatorial argument that any k-resilient protocol for the k-set agreement problem would satisfy the uncertainty condition, while this is not true for any (k−1)-resilient protocol. This result seems to strengthen the conjecture that there is no k-resilient protocol for this problem. We prove this result for a restricted class of protocols. Our motivation for studying this problem is to test whether the number of choices allowed to the processors is related to the number of faults. We hope that this will provide intuition towards achieving better bounds for more practical problems that arise in distributed computing, e.g., the renaming problem. The larger goal is to characterize the boundary between possibility and impossibility in asynchronous systems given multiple faults.

Graph bisection algorithms with good average case behavior

In the paper, we describe a polynomial time algorithm that, for every input graph, either outputs the minimum bisection of the graph or halts without output. More importantly, we show that the algorithm chooses the former course with high probability for many natural classes of graphs. In particular, for every fixedd≧3, all sufficiently largen and allb=o(n1−1/[(d+1)/2]), the algorithm finds the minimum bisection for almost alld-regular labelled simple graphs with 2n nodes and bisection widthb. For example, the algorithm succeeds for almost all 5-regular graphs with 2n nodes and bisection widtho(n2/3). The algorithm differs from other graph bisection heuristics (as well as from many heuristics for other NP-complete problems) in several respects. Most notably:(i)the algorithm provides exactly the minimum bisection for almost all input graphs with the specified form, instead of only an approximation of the minimum bisection,(ii)whenever the algorithm produces a bisection, it is guaranteed to be optimal (i.e., the algorithm also produces a proof that the bisection it outputs is an optimal bisection),(iii)the algorithm works well both theoretically and experimentally,(iv)the algorithm employs global methods such as network flow instead of local operations such as 2-changes, and(v)the algorithm works well for graphs with small bisections (as opposed to graphs with large bisections, for which arbitrary bisections are nearly optimal).

Control flow based obfuscation

A software obfuscator is a program O to transform a source program P for protection against malicious reverse engineering. O should be correct (O(P) has same functionality with P), resilient (O(P) is resilient against attacks), and effective (O(P) is not too much slower than P). In this paper we describe the design of an obfuscator which consists of two parts. The first part extracts the control flow information from the program and saves it in another process named Monitor-process. The second part protects Monitor-process converting it into an Aucsmith like self-modifying version. We prove the correctness of the obfuscation scheme. We assess its resilience and efficiency to show that both are This supports the claim that our approach is practical.

A tight lower bound for k-set agreement

We prove tight bounds on the time needed to solve k-set agreement, a natural generalization of consensus. We analyze this problem in a synchronous, message-passing model where processors fail by crashing. We prove a lower bound of [f/k]+1 rounds of communication for solutions to k-set agreement that tolerate f failures. This bound is tight, and shows that there is an inherent tradeoff between the running time, the degree of coordination required, and the number of faults tolerated, even in idealized models like the synchronous model. The proof of this result is interesting because it is a geometric combination of other well-known proof techniques.<<ETX>>

Shared memory consistency conditions for non-sequential execution: definitions and programming strategies

To enhartce performance on shared memory multiprocessors, various techniques have been proposed to reduce the latency of memory accesses, including pipelining of accesses, out-of-order execution of accesses, and branch prediction with speculative execution, These optimisations however can complicate the user’s model of memory. Thn paper attacks the problem of simplifying programming on two fronts. First, a general framework is presented for defining shared memory consistency conditions that allows non-sequential execution of memory accesses. The interface at which conditions are defined is between the program and the system, and is architecture-independent. The framework is used to generalize four known consistency conditions-sequential consistency, hybrid consistency, weak consistency, and release consistency-for non-sequential execution. Second, several techniques are described for structuring programs so that a shared memory that provides the weaker “Department of Computer Science, The Tec.hnion, Haifa 32000, Israel. Ems& hagit~cs .technion. ac. il and roy@cs. technion. ac. il. Partially supported by B. and G. Greenberg Research Fund (Ottawa), by Tecbnion V.P.R. funds, and by the fund for the promotion of research at the Technion. f Laboratory for Computer Science, M=eaehueetts ~stitute of Technology, Cambridge, MA 02139. Email: soma@theory.lcs .rnit. edn. On leave from the Department of Computer Science, Iowa State University. Supported in part by NSF grant CCR-89-1520S, DARPA contracts NOO014-89-J-1988 and NO0014-92-J-4033

Graph Bisection Algorithins With Good Average Case Behavior

ONR contrast NOOO14-91-J-1O46, and a grant from the ISU Graduate College.

Wait-free implementations in message-passing systems

Department of Computer Science, Texas A&M University, College Station, TX 77843-3112. Email: uelch~ca. tamu. du. Much of this work was performed while this author was with the Department of Computer Science, University of North Carolina, Chapel Hill, NC 27599-3175. Supported in part by NSF grant CCR-9010730, an IBM Faculty Development Award, an NSF Presidential Young Investigator Award CCR-915S478, and TAMU Engineering Excellence funds. Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for diract commercial advantage, the ACM copyright notice and the title of the publication and its date appear, and notice is given that Copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requirea a fee and/or specific permission. ACM-SPAA’93-6/93 Nelen,Germany. @1993 ACM ()-89791 -599-2193 j(JC)06\024~ ...

Shared Memory Consistency Conditions for Nonsequential Execution: Definitions and Programming Strategies

1.50 ABSTRACT) Roy Friedman* Jennifer L. Welch

Understanding the Set Consensus Partial Order using the Borowsky-Gafni Simulation

(and more efficient) condition of hybrid consistency appears to guarantee the stronger (and more costly) condition of sequential consistency. The benefit is that sequentially consistent executions are easier to reason about. The first and second techniques statically classify accesses based on their type. This approach is extremely simple to use and leads to a general methodology for writing efficient synchronization code. The third technique is to avoid data races in the program; th~ technique also works on a simple variant of release consistent hardware, with an appropriate change to the definition of data race.

Designing algorithms for distributed systems with partially synchronized clocks

We describe a polynomial time algorithm that, for every input graph, either outputs the minimum bisection of the graph or halts without output. More importantly, we show that the algorithm chooses the former course with high probability for many natural classes of graphs. In particular, for every fixed d⩾3, all suffciently large n and all b = o(n1-(1/[(d+1)/2]), the algorithm finds the minimum bisection for almost all d-regular labelled simple graphs with 2n nodes and bisection width b.