DOCSLIB.ORG

Deadlock Detection in Distributed Systems

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Deadlock Detection in Distributed Systems SURVEY & TUTORIAL SERIES Deadlock Detection in Distributed Systems Mukesh Singhal Ohio State University distributed system is a network process acquires a resource before access- of sites that exchange informa- <I ing it and relinquishes it after using it. A A tion with each other by message process that requires resources for execu- passing. A site consists of computing and tion cannot proceed until it has acquired all storage facilities and an interface to local is a constant those resources. A set of processes is re- users and to a communication network. A problem, often offsetting source-deadlocked if each process in the primary motivation for using distributed set requests a resource held by another systems is the possibility of resource shar- the advantages of process in the set. ing - a process can request and release In communication deadlocks, messages resources (local or remote) in an order not resource sharing. are the resources for which processes known apriori; aprocess can request some Deadlock handling is wait.' Reception of a message takes a pro- resources while holding others. In such an cess out of wait -that is, unblocks it. A set environment, if the sequence of resource difficult in distributed of processes is communication-dead- allocation to processes is not controlled, a locked if each process in the set is waiting deadlock may occur. systems because no site for a message from another process in the A deadlock occurs when processes hold- has accurate knowledge set and no process in the set ever sends a ing some resources request access to re- message. In this article we limit our discus- sources held by other processes in the same of the system state. sion to resource deadlocks in distributed set. The simplest illustration of a deadlock systems. consists of two processes, each holding a To present the state of the art of dead- different resource in exclusive mode and lock detection in distributed systems, this each requesting an access to resources held article describes a series of deadlock de- by other processes. Unless the deadlock is tection techniques based on centralized, resolved, all the processes involved are and restoring all the relinquished resources hierarchical, and distributed control or- blocked indefinitely. Therefore, a dead- to their original states. In the simplest case, ganizations. The article complements one lock requires the attention of a process a process is aborted by starting it afresh by Knapp, which discusses deadlock de- outside those involved in the deadlock for and relinquishing all the resources it held. tection in distributed database systems.' its detection and resolution. Knapp emphasizes the underlying theo- A deadlock is resolved by aborting one Resource vs. communication dead- retical principles of deadlock detection and or more processes involved in the deadlock lock. Two types of deadlock have been gives an example of each principle. In and granting the released resources to other discussed in the literature: resource dead- contrast, this article examines deadlock processes involved in the deadlock. A lock and communication deadlock. In re- detection in distributed systems more from process is aborted by withdrawing all its source deadlocks, processes make access the point of view of its practical implica- resource requests, restoring its state to an to resources (for example, data objects in tions. It presents an up-to-date and com- appropriate previous state, relinquishing database systems, buffers in store-and- prehensive survey of deadlock detection all the resources it acquired after that state, forward communication networks). A algorithms, discusses their merits and November 1989 0018-9162/89/1100-0037$01.00 0 1989 IEEE 37 drawbacks, and compares their perform- Deadlock handling is complicated in ance (delays as well as message complex- distributed systems because no site has ity). Moreover, this article examines re- accurate knowledge of the current state of lated issues, such as correctness of the the system and because every intersite algorithms, performance of the algorithms, communication involves a finite and un- and deadlock resolution, which require predictable delay. Next, we examine the further research. complexity and practicality of the three deadlock-handling approaches in distrib- Graph-theoretic model of deadlocks. uted systems. The state of a system is in general dynamic; that is, system processes continuously Deadlock prevention. Deadlock pre- acquire and release resources. Characteri- vention is commonly achieved either by zation of deadlocks requires a representa- having a process acquire all the needed tion of the state of process-resource inter- resources simultaneously before it begins actions. The state of process-resource executing or by preempting a process that interactions is modeled by a bipartite di- holds the needed resource. In the former rected graph called a resource allocation Figure 1. Resource allocation graph. method, a process requests (or releases) a graph. Nodes of this graph are processes remote resource by sending a request and resources of a system, and edges of the message (or release message) to the site graph depict assignments or pending re- where the resource is located. This method quests. A pending request is represented Deadlock-handling has the following drawbacks: by a request edge directed from the node of strategies (1) It is inefficient because it decreases a requesting process to the node of the system concurrency. requested resource. A resource assignment The three strategies for handling dead- (2) A set of processes may get dead- is represented by an assignment edge di- locks are deadlock prevention, deadlock locked in the resource-acquiring phase. rected from the node of an assigned re- avoidance, and deadlock detection. In For example, suppose process PI at site SI source to the node of the process assigned. deadlock prevention, resources are granted and process P, at site S, simultaneously For example, Figure 1 shows the resource to requesting processes in such a way that request two resources R, and R, located at allocation graph for two processes PI and a request for a resource never leads to a sites S, and S,, respectively. It may happen P, and two resources RI and R,, where deadlock. The simplest way to prevent a that S, grants R, to PI and S, grants R, to edges RI-+ PI and R,+ P, are assignment deadlock is to acquire all the needed re- P,, resulting in a deadlock. This problem edges and edges P,+ RI and PI-+ R, are sources before a process starts executing. can be handled by forcing processes to request edges. In another method of deadlock prevention, acquire needed resources one by one, but A system is deadlocked if its resource a blocked process releases the resources that approach is highly inefficient and allocation graph contains a directed cycle requested by an active process. impractical. in which each request edge is followed by In deadlock avoidance strategy, a re- (3) In many systems future resource an assignment edge. Since the resource source is granted to a process only if the requirements are unpredictable (not allocation graph of Figure 1 contains a resulting state is safe. (A state is safe if known a priori). directed cycle, processes PI and P, are there is at least one execution sequence deadlocked. A deadlock can be detected by that allows all processes to run to comple- In the latter method, an active process constructing the resource allocation graph tion.) Finally, in deadlock detection strat- forces a blocked process, which holds the and searching it for cycles. egy, resources are granted to a process needed resource, to abort. This method is In a distributed database system without any check. Periodically (or when- inefficient because several processes may (DDBS), the user accesses the data objects ever a request for a resource has to wait) be aborted without any deadlock. of the database by executing transactions. the status of resource allocation and pend- A transaction can be viewed as a process ing requests is examined to determine if a Deadlock avoidance. For deadlock that performs a sequence of reads and set of processes is deadlocked. This exami- avoidance in distributed systems, a re- writes on data objects. The data objects of nation is performed by a deadlock detec- source is granted to a process if the result- a database can be viewed as resources that tion algorithm. If a deadlock is discovered, ing global system state is safe (the global are acquired (by locking) and released (by the system recovers from it by aborting one state includes all the processes and re- unlocking) by transactions. In DDBS lit- or more deadlocked processes. sources of the distributed system). The erature the resource allocation graph is The suitability of a deadlock-handling following problems make deadlock avoid- referred to as a transaction-wait-for (TWF) strategy greatly depends on the applica- ance impractical in distributed systems: graph.3 In a TWF graph, nodes are transac- tion. Both deadlock prevention and dead- (1) Because every site has to keep track tions and there is adirected edge from node lock avoidance are conservative, overly of the global state of the system, huge TIto node T, if TI is blocked and must wait cautious strategies. They are preferred if storage capacity and extensive communi- for T, to release some data object. A sys- deadlocks are frequent or if the occurrence cation ability are necessary. tem is deadlocked if and only if there is a of a deadlock is highly undesirable. In (2) The process of checking for a safe directedcycle in its TWFgraph. Since both contrast, deadlock detection is a lazy, opti- global state must be mutually exclusive. graphs denote the state of process-resource mistic strategy, which grants a resource to Otherwise, if several sites concurrently interaction, we will collectively refer to a request if the resource is available, hop- perform checks fora safe global state (each them as state graphs.
Load more

Recommended publications
  • Israel-Palestine Through the Lens of Game Theory
    University of Massachusetts Amherst ScholarWorks@UMass Amherst Economics Department Working Paper Series Economics 2021 Land for peace? Israel-Palestine through the lens of game theory Amal Ahmad Department of Economics, University of Massachusetts Amherst Follow this and additional works at: https://scholarworks.umass.edu/econ_workingpaper Part of the Economics Commons Recommended Citation Ahmad, Amal, "Land for peace? Israel-Palestine through the lens of game theory" (2021). Economics Department Working Paper Series. 301. https://doi.org/10.7275/21792057 This Article is brought to you for free and open access by the Economics at ScholarWorks@UMass Amherst. It has been accepted for inclusion in Economics Department Working Paper Series by an authorized administrator of ScholarWorks@UMass Amherst. For more information, please contact [email protected]. Land for peace? Israel-Palestine through the lens of game theory Amal Ahmad∗ February 2021 Abstract Why have Israel and the Palestinians failed to implement a \land for peace" solution, along the lines of the Oslo Accords? This paper studies the applica- tion of game theory to this question. I show that existing models of the conflict largely rely on unrealistic assumptions about what the main actors are trying to achieve. Specifically, they assume that Israel is strategically interested in withdrawing from the occupied territories pending resolvable security concerns but that it is obstructed from doing so by violent Palestinians with other objec- tives. I use historical analysis along with bargaining theory to shed doubt on this assumption, and to argue that the persistence of conflict has been aligned with, not contrary to, the interests of the militarily powerful party, Israel.
    [Show full text]
  • Collusion Constrained Equilibrium
    Theoretical Economics 13 (2018), 307–340 1555-7561/20180307 Collusion constrained equilibrium Rohan Dutta Department of Economics, McGill University David K. Levine Department of Economics, European University Institute and Department of Economics, Washington University in Saint Louis Salvatore Modica Department of Economics, Università di Palermo We study collusion within groups in noncooperative games. The primitives are the preferences of the players, their assignment to nonoverlapping groups, and the goals of the groups. Our notion of collusion is that a group coordinates the play of its members among different incentive compatible plans to best achieve its goals. Unfortunately, equilibria that meet this requirement need not exist. We instead introduce the weaker notion of collusion constrained equilibrium. This al- lows groups to put positive probability on alternatives that are suboptimal for the group in certain razor’s edge cases where the set of incentive compatible plans changes discontinuously. These collusion constrained equilibria exist and are a subset of the correlated equilibria of the underlying game. We examine four per- turbations of the underlying game. In each case,we show that equilibria in which groups choose the best alternative exist and that limits of these equilibria lead to collusion constrained equilibria. We also show that for a sufficiently broad class of perturbations, every collusion constrained equilibrium arises as such a limit. We give an application to a voter participation game that shows how collusion constraints may be socially costly. Keywords. Collusion, organization, group. JEL classification. C72, D70. 1. Introduction As the literature on collective action (for example, Olson 1965) emphasizes, groups often behave collusively while the preferences of individual group members limit the possi- Rohan Dutta: [email protected] David K.
    [Show full text]
  • Deadlock: Why Does It Happen? CS 537 Andrea C
    UNIVERSITY of WISCONSIN-MADISON Computer Sciences Department Deadlock: Why does it happen? CS 537 Andrea C. Arpaci-Dusseau Introduction to Operating Systems Remzi H. Arpaci-Dusseau Informal: Every entity is waiting for resource held by another entity; none release until it gets what it is Deadlock waiting for Questions answered in this lecture: What are the four necessary conditions for deadlock? How can deadlock be prevented? How can deadlock be avoided? How can deadlock be detected and recovered from? Deadlock Example Deadlock Example Two threads access two shared variables, A and B int A, B; Variable A is protected by lock x, variable B by lock y lock_t x, y; How to add lock and unlock statements? Thread 1 Thread 2 int A, B; lock(x); lock(y); A += 10; B += 10; lock(y); lock(x); Thread 1 Thread 2 B += 20; A += 20; A += 10; B += 10; A += B; A += B; B += 20; A += 20; unlock(y); unlock(x); A += B; A += B; A += 30; B += 30; A += 30; B += 30; unlock(x); unlock(y); What can go wrong?? 1 Representing Deadlock Conditions for Deadlock Two common ways of representing deadlock Mutual exclusion • Vertices: • Resource can not be shared – Threads (or processes) in system – Resources (anything of value, including locks and semaphores) • Requests are delayed until resource is released • Edges: Indicate thread is waiting for the other Hold-and-wait Wait-For Graph Resource-Allocation Graph • Thread holds one resource while waits for another No preemption “waiting for” wants y held by • Resources are released voluntarily after completion T1 T2 T1 T2 Circular
    [Show full text]
  • The Dining Philosophers Problem Cache Memory
    The Dining Philosophers Problem Cache Memory 254 The dining philosophers problem: definition It is an artificial problem widely used to illustrate the problems linked to resource sharing in concurrent programming. The problem is usually described as follows. • A given number of philosopher are seated at a round table. • Each of the philosophers shares his time between two activities: thinking and eating. • To think, a philosopher does not need any resources; to eat he needs two pieces of silverware. 255 • However, the table is set in a very peculiar way: between every pair of adjacent plates, there is only one fork. • A philosopher being clumsy, he needs two forks to eat: the one on his right and the one on his left. • It is thus impossible for a philosopher to eat at the same time as one of his neighbors: the forks are a shared resource for which the philosophers are competing. • The problem is to organize access to these shared resources in such a way that everything proceeds smoothly. 256 The dining philosophers problem: illustration f4 P4 f0 P3 f3 P0 P2 P1 f1 f2 257 The dining philosophers problem: a first solution • This first solution uses a semaphore to model each fork. • Taking a fork is then done by executing a operation wait on the semaphore, which suspends the process if the fork is not available. • Freeing a fork is naturally done with a signal operation. 258 /* Definitions and global initializations */ #define N = ? /* number of philosophers */ semaphore fork[N]; /* semaphores modeling the forks */ int j; for (j=0, j < N, j++) fork[j]=1; Each philosopher (0 to N-1) corresponds to a process executing the following procedure, where i is the number of the philosopher.
    [Show full text]
  • CSC 553 Operating Systems Multiple Processes
    CSC 553 Operating Systems Lecture 4 - Concurrency: Mutual Exclusion and Synchronization Multiple Processes • Operating System design is concerned with the management of processes and threads: • Multiprogramming • Multiprocessing • Distributed Processing Concurrency Arises in Three Different Contexts: • Multiple Applications – invented to allow processing time to be shared among active applications • Structured Applications – extension of modular design and structured programming • Operating System Structure – OS themselves implemented as a set of processes or threads Key Terms Related to Concurrency Principles of Concurrency • Interleaving and overlapping • can be viewed as examples of concurrent processing • both present the same problems • Uniprocessor – the relative speed of execution of processes cannot be predicted • depends on activities of other processes • the way the OS handles interrupts • scheduling policies of the OS Difficulties of Concurrency • Sharing of global resources • Difficult for the OS to manage the allocation of resources optimally • Difficult to locate programming errors as results are not deterministic and reproducible Race Condition • Occurs when multiple processes or threads read and write data items • The final result depends on the order of execution – the “loser” of the race is the process that updates last and will determine the final value of the variable Operating System Concerns • Design and management issues raised by the existence of concurrency: • The OS must: – be able to keep track of various processes
    [Show full text]
  • Supervision 1: Semaphores, Generalised Producer-Consumer, and Priorities
    Concurrent and Distributed Systems - 2015–2016 Supervision 1: Semaphores, generalised producer-consumer, and priorities Q0 Semaphores (a) Counting semaphores are initialised to a value — 0, 1, or some arbitrary n. For each case, list one situation in which that initialisation would make sense. (b) Write down two fragments of pseudo-code, to be run in two different threads, that experience deadlock as a result of poor use of mutual exclusion. (c) Deadlock is not limited to mutual exclusion; it can occur any time its preconditions (especially hold-and-wait, cyclic dependence) occur. Describe a situation in which two threads making use of semaphores for condition synchronisation (e.g., in producer-consumer) can deadlock. int buffer[N]; int in = 0, out = 0; spaces = new Semaphore(N); items = new Semaphore(0); guard = new Semaphore(1); // for mutual exclusion // producer threads while(true) { item = produce(); wait(spaces); wait(guard); buffer[in] = item; in = (in + 1) % N; signal(guard); signal(items); } // consumer threads while(true) { wait(items); wait(guard); item = buffer[out]; out =(out+1) % N; signal(guard); signal(spaces); consume(item); } Figure 1: Pseudo-code for a producer-consumer queue using semaphores. 1 (d) In Figure 1, items and spaces are used for condition synchronisation, and guard is used for mutual exclusion. Why will this implementation become unsafe in the presence of multiple consumer threads or multiple producer threads, if we remove guard? (e) Semaphores are introduced in part to improve efficiency under contention around critical sections by preferring blocking to spinning. Describe a situation in which this might not be the case; more generally, under what circumstances will semaphores hurt, rather than help, performance? (f) The implementation of semaphores themselves depends on two classes of operations: in- crement/decrement of an integer, and blocking/waking up threads.
    [Show full text]
  • On Some Winning Strategies for the Iterated Prisoner's Dilemma Or Mr
    Chapter 1 On some winning strategies for the Iterated Prisoner’s Dilemma or Mr. Nice Guy and the Cosa Nostra Wolfgang Slany Wolfgang Kienreich Technical University Know-Center Graz, Austria Graz, Austria [email protected] [email protected] We submitted two kinds of strategies to the iterated prisoner’s dilemma (IPD) competitions organized by Graham Kendall, Paul Darwen and Xin Yao in 2004 and 20051. Our strategies performed exceedingly well in both years. One type is an intelligent and optimistic enhanced version of the well known TitForTat strategy which we named OmegaTitForTat. It recognizes common behaviour patterns and detects and recovers from repairable mutual defect deadlock situations, otherwise behaving much like TitForTat. OmegaTitForTat was placed as the first or second individual strategy in both competitions in the leagues in which it took part. The second type consists of a set of strategies working together as a team. The call for participation of the competitions explicitly stated that cooperative strategies would be allowed to participate. This allowed a form of implicit communication which is not in keeping with the original IPD idea, but represents a natural extension to the study of cooperative behaviour in reality as it is aimed at through the study of the simple, yet 1 See http://www.prisoners-dilemma.com/ for more details. 1 2 Book Title insightful, iterated prisoner’s dilemma model. Indeed, one’s behaviour towards another person in reality is very often influenced by one’s relation to the other person. In particular, we submitted three sets of strategies that work together as groups.
    [Show full text]
  • Order and Containment in Concurrent System Design Copyright Fall 2000
    Order and Containment in Concurrent System Design Copyright Fall 2000 by John Sidney Davis II 1 Abstract Order and Containment in Concurrent System Design by John Sidney Davis II Doctor of Philosophy in Engineering-Electrical Engineering and Computer Science University of California at Berkeley Professor Edward A. Lee, Chair This dissertation considers the dif®culty of modeling and designing complex, concurrent systems. The term concurrent is used here to mean a system consisting of a network of commu- nicating components. The term complex is used here to mean a system consisting of components with different models of computation such that the communication between different components has different semantics according to the respective interacting models of computation. Modeling and designing a concurrent system requires a clear understanding of the types of relationships that exist between the components found within a concurrent system. Two partic- ularly important types of relationships found in concurrent systems are the order relation and the containment relation. The order relation represents the relative timing of component actions within a concurrent system. The containment relation facilitates human understanding of a system by ab- stracting a system's components into layers of visibility. The consequence of improper management of the order and containment relationships in a complex, concurrent system is deadlock. Deadlock is an undesirable halting of a system's execution and is the most challenging type of concurrent system error to debug. The contents of this disserta- tion show that no methodology is currently available that can concisely, accurately and graphically 2 model both the order and containment relations found in complex, concurrent systems.
    [Show full text]
  • Q1. Multiple Producers and Consumers
    CS39002: Operating Systems Lab. Assignment 5 Floating date: 29/2/2016 Due date: 14/3/2016 Q1. Multiple Producers and Consumers Problem Definition: You have to implement a system which ensures synchronisation in a producer-consumer scenario. You also have to demonstrate deadlock condition and provide solutions for avoiding deadlock. In this system a main process creates 5 producer processes and 5 consumer processes who share 2 resources (queues). The producer's job is to generate a piece of data, put it into the queue and repeat. At the same time, the consumer process consumes the data i.e., removes it from the queue. In the implementation, you are asked to ensure synchronization and mutual exclusion. For instance, the producer should be stopped if the buffer is full and that the consumer should be blocked if the buffer is empty. You also have to enforce mutual exclusion while the processes are trying to acquire the resources. Manager (manager.c): It is the main process that creates the producers and consumer processes (5 each). After that it periodically checks whether the system is in deadlock. Deadlock refers to a specific condition when two or more processes are each waiting for another to release a resource, or more than two processes are waiting for resources in a circular chain. Implementation : The manager process (manager.c) does the following : i. It creates a file matrix.txt which holds a matrix with 2 rows (number of resources) and 10 columns (ID of producer and consumer processes). Each entry (i, j) of that matrix can have three values: ● 0 => process i has not requested for queue j or released queue j ● 1 => process i requested for queue j ● 2 => process i acquired lock of queue j.
    [Show full text]
  • Managing Coopetition: Is Transparency a Fallacy Or a Mandatory Condition? a Case Study of a Coopetition Project with an Opportunistic Partner
    XXVIe Conférence Internationale de Management Stratégique Managing coopetition: Is transparency a fallacy or a mandatory condition? A case study of a coopetition project with an opportunistic partner Sea Matilda Bez Université de Montpellier (MOMA) et Université Paris-Dauphine (PSL) [email protected] Frédéric Le Roy Université de Montpellier (MOMA) et Montpellier Business School [email protected] Stéphanie Dameron Université Paris-Dauphine (PSL) [email protected] Abstract : We investigate why and how knowledge transparency between competitors are needed for radical innovation. Previous scholars considered that coopetition (i.e. collaboration between competing firms) could not be a suitable strategy. Knowledge transparency invites opportunism. Thus, even for a radical innovation purpose, being highly transparent with a competitor is a fallacy. Our research goes beyond this specific approach of coopetition and reveals that firms can preserve transparency even if the partners behave opportunistically. We develop counter-intuitive propositions based on a conceptual discussion followed by insight from an extreme case study of a pharmaceutical company opening its innovation project to a competitor who behaves opportunistically (i.e. the Plavix). Our study mainly highlights that firms need to fight against the intuitive reaction of reducing transparency when the partner behaves opportunistically. Reducing the transparency inevitably leads to “shooting itself in the foot” because the reduction of transparency of one partner leads to the destruction of any possibility to create a radical innovation. Moreover, our research represents interesting guidelines for top managers by : (1) confirming that coopetition strategies are relevant in addressing the challenges of radical innovation, and (2) highlighting a specific organization design to manage transparency in a coopetitive project.
    [Show full text]
  • Deadlock-Free Oblivious Routing for Arbitrary Topologies
    Deadlock-Free Oblivious Routing for Arbitrary Topologies Jens Domke Torsten Hoefler Wolfgang E. Nagel Center for Information Services and Blue Waters Directorate Center for Information Services and High Performance Computing National Center for Supercomputing Applications High Performance Computing Technische Universitat¨ Dresden University of Illinois at Urbana-Champaign Technische Universitat¨ Dresden Dresden, Germany Urbana, IL 61801, USA Dresden, Germany [email protected] [email protected] [email protected] Abstract—Efficient deadlock-free routing strategies are cru- network performance without inclusion of the routing al- cial to the performance of large-scale computing systems. There gorithm or the application communication pattern. In reg- are many methods but it remains a challenge to achieve lowest ular operation these values can hardly be achieved due latency and highest bandwidth for irregular or unstructured high-performance networks. We investigate a novel routing to network congestion. The largest gap between real and strategy based on the single-source-shortest-path routing al- idealized performance is often in bisection bandwidth which gorithm and extend it to use virtual channels to guarantee by its definition only considers the topology. The effective deadlock-freedom. We show that this algorithm achieves min- bisection bandwidth [2] is the average bandwidth for routing imal latency and high bandwidth with only a low number messages between random perfect matchings of endpoints of virtual channels and can be implemented in practice. We demonstrate that the problem of finding the minimal number (also known as permutation routing) through the network of virtual channels needed to route a general network deadlock- and thus considers the routing algorithm.
    [Show full text]
  • Scalable Deadlock Detection for Concurrent Programs
    Sherlock: Scalable Deadlock Detection for Concurrent Programs Mahdi Eslamimehr Jens Palsberg UCLA, University of California, Los Angeles, USA {mahdi,palsberg}@cs.ucla.edu ABSTRACT One possible schedule of the program lets the first thread We present a new technique to find real deadlocks in con- acquire the lock of A and lets the other thread acquire the current programs that use locks. For 4.5 million lines of lock of B. Now the program is deadlocked: the first thread Java, our technique found almost twice as many real dead- waits for the lock of B, while the second thread waits for locks as four previous techniques combined. Among those, the lock of A. 33 deadlocks happened after more than one million com- Usually a deadlock is a bug and programmers should avoid putation steps, including 27 new deadlocks. We first use a deadlocks. However, programmers may make mistakes so we known technique to find 1275 deadlock candidates and then have a bug-finding problem: provide tool support to find as we determine that 146 of them are real deadlocks. Our tech- many deadlocks as possible in a given program. nique combines previous work on concolic execution with a Researchers have developed many techniques to help find new constraint-based approach that iteratively drives an ex- deadlocks. Some require program annotations that typically ecution towards a deadlock candidate. must be supplied by a programmer; examples include [18, 47, 6, 54, 66, 60, 42, 23, 35]. Other techniques work with unannotated programs and thus they are easier to use. In Categories and Subject Descriptors this paper we focus on techniques that work with unanno- D.2.5 Software Engineering [Testing and Debugging] tated Java programs.
    [Show full text]