Debuggers are an integral part, albeit often neglected, of the development of distributed applications. Ambient-oriented programming (AmOP) is a distributed paradigm for applications running on mobile ad hoc networks....
详细信息
Debuggers are an integral part, albeit often neglected, of the development of distributed applications. Ambient-oriented programming (AmOP) is a distributed paradigm for applications running on mobile ad hoc networks. In AmOP the complexity of programming in a distributed setting is married with the network fragility and open topology of mobile applications. To our knowledge, there is no debugging approach that tackles both these issues. In this paper we argue that a novel kind of distributed debugger that we term an ambient-oriented debugger, is required. We present REME-D (read as remedy), an online ambient-oriented debugger that integrates techniques from distributed debugging (event-based debugging, message breakpoints) and proposes facilities to deal with ad hoc, fragile networks - epidemic debugging, and support for frequent disconnections. (C) 2013 Elsevier Inc. All rights reserved.
distributed applications written in Hermes typically consist of a large number of sequential processes. The use of a hierarchy of process clusters can facilitate the debugging of such applications. Ideally, such a hie...
详细信息
distributed applications written in Hermes typically consist of a large number of sequential processes. The use of a hierarchy of process clusters can facilitate the debugging of such applications. Ideally, such a hierarchy should be derived automatically. This paper discusses two approaches to automatic process clustering, one analyzing runtime information with a statistical approach and one utilizing additional semantic information. Tools realizing these approaches were developed and a quantitative measure to evaluate process clusters is proposed. The results obtained under both approaches are compared, and indicate that the additional semantic information improves the cluster hierarchies derived. We demonstrate the value of automatic process clustering with an example. It is shown how appropriate process clusters reduce the complexity of the understanding process, facilitating program maintenance activities such as debugging.
For the course of even-based distributed debugging, a great deal of event messages must be collected and handled. This process is not only complicated but also can disturbs the real execution of distributed program. T...
详细信息
For the course of even-based distributed debugging, a great deal of event messages must be collected and handled. This process is not only complicated but also can disturbs the real execution of distributed program. This paper introduces an Object-Oriented event model, which simplifies the collecting process of event message, makes it convenient to organize and manage the event message database, and adjusts indeterminacy, and reduces the disturbance of debugging to program execution.
Testing and debugging programs are more involved in distributed systems than in uniprocessor systems because of the presence of the communication medium and the inherent concurrency. Past research has established that...
详细信息
Testing and debugging programs are more involved in distributed systems than in uniprocessor systems because of the presence of the communication medium and the inherent concurrency. Past research has established that predicate testing is an approach that can alleviate some of the problems in this area. However, checking whether a general predicate is true in a particular distributed execution appears to be a computationally hard problem. This paper considers a class of predicates called conjunctive form predicates (CFP) that is quite useful in distributed program development, but can be tested efficiently. We develop fully-distributed algorithms to test CFP's, prove that these algorithms are correct, and analyze them for their message complexity. The analysis shows that our techniques incur a fairly low overhead on the distributed system.
Splitting software into distributed compartments is an important software security technique that limits the effect of vulnerabilities. Unfortunately the resulting systems are difficult to analyze or debug interactive...
详细信息
ISBN:
(纸本)9781728174457
Splitting software into distributed compartments is an important software security technique that limits the effect of vulnerabilities. Unfortunately the resulting systems are difficult to analyze or debug interactively when compared to the original. Not only are compartments distributed and executed in parallel, but they may also be strongly isolated by being sandboxed or run in minimal environments that lack debugging facilities. This paper is the first to study practical debugging techniques for strongly-isolated distributed compartments. We adapt ideas from other remote or distributed debugging settings to this domain, and implement and describe two radically different approaches to this problem. We evaluate these approaches both qualitatively and quantitatively, and using both toy examples and real-world open-source software. Our main finding is that out of the two approaches, using GDB remote stubs presents a good balance of performance, flexibility and usability, and we characterize this more precisely in our evaluation.
This work presents a debugging system built for the Object Request Broker (ORB) used in the construction of Solaris MC, a multicomputer OS. Even though it has been built and tested on a particular ORB, we believe simi...
详细信息
This work presents a debugging system built for the Object Request Broker (ORB) used in the construction of Solaris MC, a multicomputer OS. Even though it has been built and tested on a particular ORB, we believe similar ideas could be employed on other ORBs with similar structure and goals. The goal of this system is to provide a means to stress the ORB behavior in a controlled manner while logging the events occurred during its execution. The tool, called the Fault Injection and Event Logging Tool (FIELT) helps system programmers to find possible inconsistencies in the code by means of a post-mortem analysis of the collected trace data. The approach taken to design the event logging follows the event-driven techniques to monitorize distributed systems. Failures in the ORB are injected by software instrumentation and these injected failures are considered as special events. This allows us to reason about the correctness of the ORB in a broad sense, where its expected behavior includes to gracefully cope with failures. The number of potentially relevant events produced during the ORB execution is unmanageably high. There is, thus, a need to find a minimum subset of those events which, without losing relevant system behavior, allows us to infer its correctness (or lack of). We address this problem using a new model for ORB computations, assigning each event produced by the ORB to one of the high level objects it manages.
The issue of correctness of complex asynchronous distributed algorithms implemented on loosely coupled parallel processor systemsis difficult to address given the lack of effective debugging tools. In such systems, me...
详细信息
The issue of correctness of complex asynchronous distributed algorithms implemented on loosely coupled parallel processor systemsis difficult to address given the lack of effective debugging tools. In such systems, messages propagate asynchronously over physical connections and precise knowledge of the state of every message in the system at any instant of time is difficult to obtain. For a particular class of asynchronous distributed algorithms [1,2,5] that may be characterized by independent models that execute asynchronously on the processors and interact with one another only through explicit messages, the following reasoning applies. Information on the flow and content of messages and the activity of the processors is significant towards understanding the functional correctness of the implementation. This paper proposes a new approach, MADCAPP, to measure and analyze high-level message communication and the activity level of the processors.
Detecting strong conjunctive predicates is a fundamental problem in debugging and testing distributed programs. A strong conjunctive predicate is a logical statement to represent the desired event of the system. There...
详细信息
Detecting strong conjunctive predicates is a fundamental problem in debugging and testing distributed programs. A strong conjunctive predicate is a logical statement to represent the desired event of the system. Therefore, if the predicate is not true, an error may occur because the desired event does not happen. Recently, several reported detection algorithms reveal the problem of unbounded state queue growth since the system may generate a huge amount of execution states in a very short time. In order to solve this problem, this paper introduces the notion of removable states which can be disregarded in the sense that detection results still remain correct. A fully distributed algorithm is developed in this paper to perform the detection in an online manner. Based on the notion of removable states, the time complexity of the detection algorithm is improved as the number of states to be evaluated is reduced.
We show that the problem of predicate detection in distributed systems is NP-complete. In the past, efficient algorithms have been developed for special classes of predicates such as stable predicates, observer indepe...
详细信息
We show that the problem of predicate detection in distributed systems is NP-complete. In the past, efficient algorithms have been developed for special classes of predicates such as stable predicates, observer independent predicates,: and conjunctive predicates. We introduce a class of predicates, semi-linear predicates, which properly contains all of the above classes. We first discuss stable, observer independent and semi-linear classes of predicates and their relationships with each other. We also study closure properties of these classes with respect to conjunction and disjunction. Finally, we discuss algorithms for detection of predicates in these classes. We provide a non-deterministic detection algorithm for each class of predicate. We show that each class can be equivalently characterized by the degree of non-determinism present in the algorithm. Stable predicates are defined as those that can be detected by an algorithm with the most non-determinism. All other classes can be derived by appropriately constraining the non-determinism in this algorithm.
Detecting global predicates is an important task in testing and debuggingdistributed programs. In this paper, we propose an approach that effectively precludes useless events for global predicate detections, facilita...
详细信息
Detecting global predicates is an important task in testing and debuggingdistributed programs. In this paper, we propose an approach that effectively precludes useless events for global predicate detections, facilitating the process of an independent on-line checking routine. To identify more useless events than a simple causality-check method can do, our method tracks and maintains the precedence information of event intervals as a graph. To reduce the potentially expensive space and time cost as the graph expands, we propose an effective scheme to prune the graph. The performance of our method is analyzed and evaluated by simulations. The result shows that our approach outperforms conventional approaches in terms of the number of useless events found. (C) 2001 Academic Press.
暂无评论