Showing papers on "Debugging published in 2005"
Book•
1 Oct 2005
TL;DR: The new edition of this award-winning productivity-booster is for any developer who has ever been frustrated by elusive bugs, andBrand new chapters demonstrate cutting-edge debugging techniques and tools, enabling readers to put the latest time-saving developments to work for them.
Abstract: This book is proof that debugging has graduated from a black art to a systematic discipline It demystifies one of the toughest aspects of software programming, showing clearly how to discover what caused software failures, and fix them with minimal muss and fuss The fully updated second edition includes 100+ pages of new material, including new chapters on Verifying Code, Predicting Erors, and Preventing Errors Cutting-edge tools such as FindBUGS and AGITAR are explained, techniques from integrated environments like Jazznet are highlighted, and all-new demos with ESC/Java and Spec#, Eclipse and Mozilla are included This complete and pragmatic overview of debugging is authored by Andreas Zeller, the talented researcher who developed the GNU Data Display Debugger(DDD), a tool that over 250,000 professionals use to visualize the data structures of programs while they are running Unlike other books on debugging, Zeller's text is product agnostic, appropriate for all programming languages and skill levels The book explains best practices ranging from systematically tracking error reports, to observing symptoms, reproducing errors, and correcting defects It covers a wide range of tools and techniques from hands-on observation to fully automated diagnoses, and also explores the author's innovative techniques for isolating minimal input to reproduce an error and for tracking cause and effect through a program It even includes instructions on how to create automated debugging tools The text includes exercises and extensive references for further study, and a companion website with source code for all examples and additional debugging resources is available *The new edition of this award-winning productivity-booster is for any developer who has ever been frustrated by elusive bugs *Brand new chapters demonstrate cutting-edge debugging techniques and tools, enabling readers to put the latest time-saving developments to work for them *Learn by doing New exercises and detailed examples focus on emerging tools, languages and environments, including AGITAR, FindBUGS, Python and Eclipse
510 citations
Journal Article•
TL;DR: Sympathy as mentioned in this paper is a tool for detecting and debugging failures in sensor networks and includes an algorithm that root-causes failures and localizes their sources in order to reduce overall failure notifications and point the user to a small number of probable causes.
Abstract: Being embedded in the physical world, sensor networks present a wide range of bugs and misbehavior qualitatively different from those in most distributed systems. Unfortunately, due to resource constraints, programmers must investigate these bugs with only limited visibility into the application. This paper presents the design and evaluation of Sympathy, a tool for detecting and debugging failures in sensor networks. Sympathy has selected metrics that enable efficient failure detection, and includes an algorithm that root-causes failures and localizes their sources in order to reduce overall failure notifications and point the user to a small number of probable causes. We describe Sympathy and evaluate its performance through fault injection and by debugging an active application, ESS, in simulation and deployment. We show that for a broad class of data gathering applications, it is possible to detect and diagnose failures by collecting and analyzing a minimal set of metrics at a centralized sink. We have found that there is a tradeoff between notification latency and detection accuracy; that additional metrics traffic does not always improve notification latency; and that Sympathy’s process of failure localization reduces primary failure notifications by at least 50% in most cases.
427 citations
Proceedings Article•
10 Apr 2005TL;DR: Substituted phenol/epichlorohydrin/amine adducts as multipurpose, low concentration additives for hydrocarbon fuels, lubricating oils and mixtures thereof.
Abstract: Operating systems are difficult to debug with traditional cyclic debugging. They are non-deterministic; they run for long periods of time; they interact directly with hard-ware devices; and their state is easily perturbed by the act of debugging. This paper describes a time-traveling virtual machine that overcomes many of the difficulties associated with debugging operating systems. Time travel enables a programmer to navigate backward and forward arbitrarily through the execution history of a particular run and to replay arbitrary segments of the past execution. We integrate time travel into a general-purpose debugger to enable a programmer to debug an OS in reverse, implementing commands such as reverse breakpoint, reverse watchpoint, and reverse single step. The space and time overheads needed to support time travel are reasonable for debugging, and movements in time are fast enough to support interactive debugging. We demonstrate the value of our time-traveling virtual machine by using it to understand and fix several OS bugs that are difficult to find with standard debugging tools. Reverse debugging is especially helpful in finding bugs that are fragile due to non-determinism, bugs in device drivers, bugs that require long runs to trigger, bugs that corrupt the stack, and bugs that are detected after the relevant stack frame is popped.
394 citations
1 Jan 2005
TL;DR: The combination of revision history mining and dynamic analysis techniques leveraged in DynaMine proves effective for both discovering new application-specific patterns and for finding errors when applied to very large applications with many man-years of development and debugging effort behind them.
Abstract: A great deal of attention has lately been given to addressing software bugs such as errors in operating system drivers or security bugs. However, there are many other lesser known errors specific to individual applications or APIs and these violations of application-specific coding rules are responsible for a multitude of errors. In this paper we propose DynaMine, a tool that analyzes source code check-ins to find highly correlated method calls as well as common bug fixes in order to automatically discover application-specific coding patterns. Potential patterns discovered through mining are passed to a dynamic analysis tool for validation; finally, the results of dynamic analysis are presented to the user.The combination of revision history mining and dynamic analysis techniques leveraged in DynaMine proves effective for both discovering new application-specific patterns and for finding errors when applied to very large applications with many man-years of development and debugging effort behind them. We have analyzed Eclipse and jEdit, two widely-used, mature, highly extensible applications consisting of more than 3,600,000 lines of code combined. By mining revision histories, we have discovered 56 previously unknown, highly application-specific patterns. Out of these, 21 were dynamically confirmed as very likely valid patterns and a total of 263 pattern violations were found.
378 citations
TL;DR: This work proposes a novel Boolean satisfiability-based method for multiple-fault diagnosis and multiple-design-error diagnosis in combinational and sequential circuits and suggests that satisfiability captures significant characteristics of the problem of diagnosis.
Abstract: Recent advances in Boolean satisfiability have made it an attractive engine for solving many digital very-large-scale-integration design problems. Although useful in many stages of the design cycle, fault diagnosis and logic debugging have not been addressed within a satisfiability-based framework. This work proposes a novel Boolean satisfiability-based method for multiple-fault diagnosis and multiple-design-error diagnosis in combinational and sequential circuits. A number of heuristics are presented that keep the method memory and run-time efficient. An extensive suite of experiments on large circuits corrupted with different types of faults and errors confirm its robustness and practicality. They also suggest that satisfiability captures significant characteristics of the problem of diagnosis and encourage novel research in satisfiability-based diagnosis as a complementary process to design verification.
292 citations
TL;DR: A number of debugging cues generated from the authors' reasoner, Pellet, are integrated in their hypertextual ontology development environment, Swoop, and it is demonstrated that these debugging cues significantly improve the OWL debugging experience, and point the way to more general improvements in the presentation of an ontology to users.
275 citations
27 Jun 2005
TL;DR: It is discovered that many students with a good understanding of programming do not acquire the skills to debug programs effectively, and this is a major impediment to their producing working code of any complexity.
Abstract: The process by which students learn to program is a major issue in computer science educational research. Programming is a fundamental part of the computer science curriculum, but one which is often problematic. It seems to be difficult to find an effective method of teaching that is suitable for all students. In this research we tried to gain insights into ways of improving our teaching by a careful examination of students' mistakes. The compiler errors that were generated by their programs together with the pattern that was observed in their debugging activities formed the basis of this research. We discovered that many students with a good understanding of programming do not acquire the skills to debug programs effectively, and this is a major impediment to their producing working code of any complexity. Skill at debugging seems to increase a programmer's confidence and we suggest that more emphasis be placed on debugging skills in the teaching of programming.
214 citations
4 Apr 2005
TL;DR: CodeSurfer/x86 is a prototype system for analyzing x86 executables that uses a static-analysis algorithm called value-set analysis (VSA) to recover intermediate representations that are similar to those that a compiler creates for a program written in a high-level language.
Abstract: CodeSurfer/x86 is a prototype system for analyzing x86 executables. It uses a static-analysis algorithm called value-set analysis (VSA) to recover intermediate representations that are similar to those that a compiler creates for a program written in a high-level language. A major challenge in building an analysis tool for executables is in providing useful information about operations involving memory. This is difficult when symbol-table and debugging information is absent or untrusted. CodeSurfer/x86 overcomes these challenges to provide an analyst with a powerful and flexible platform for investigating the properties and behaviors of potentially malicious code (such as COTS components, plugins, mobile code, worms, Trojans, and virus-infected code) using (i) CodeSurfer/x86's GUI, (ii) CodeSurfer/x86's scripting language, which provides access to all of the intermediate representations that CodeSurfer/x86 builds for the executable, and (iii) GrammaTech's Path Inspector, which is a tool that uses a sophisticated pattern-matching engine to answer questions about the flow of execution in a program.
179 citations
19 Sep 2005
TL;DR: A dynamic slicing framework is developed that uses dynamic instrumentation to efficiently collect dynamic slices and reduced ordered Binary Decision Diagrams to compactly store them and shows that full slices and relevant slices can considerably reduce the subset of program statements that need to be examined to locate faulty statements.
Abstract: Dynamic slicing algorithms have been considered to aid in debugging for many years. However, as far as we know, no detailed studies on evaluating the benefits of using dynamic slicing for detecting faulty statements in programs have been carried out. We have developed a dynamic slicing framework that uses dynamic instrumentation to efficiently collect dynamic slices and reduced ordered Binary Decision Diagrams (roBDDs) to compactly store them. We have used the above framework to implement three variants of dynamic slicing algorithms including: data slicing, full slicing, and relevant slicing algorithms. We have carried out detailed experiments to evaluate these algorithms. Our results show that full slices and relevant slices can considerably reduce the subset of program statements that need to be examined to locate faulty statements. We expect that the observations presented here will enable development of new slicing based algorithms for automated debugging.
171 citations
19 Sep 2005
TL;DR: Some of the practical issues needed to overcome in such environments, including low-overhead system-call interception, techniques for segregating resource usage between Jockey and the target process, and an interface for fine-grain control of Jockey's behavior are discussed.
Abstract: Jockey is an execution record/replay tool for debugging Linux programs. It records invocations of system calls and CPU instructions with timing-dependent effects and later replays them deterministically. It supports process checkpointing to diagnose long-running programs efficiently. Jockey is implemented as a shared-object file that runs as a part of the target process. While this design is the key for achieving Jockey's goal of safety and ease of use, it also poses challenges. This paper discusses some of the practical issues we needed to overcome in such environments, including low-overhead system-call interception, techniques for segregating resource usage between Jockey and the target process, and an interface for fine-grain control of Jockey's behavior.
170 citations
2 Sep 2005
TL;DR: A novel method to classify the structured traces of program executions using software behavior graphs usingSoftware behavior graphs is developed, built on an integration of closed graph mining and SVM classification.
Abstract: Analyzing the executions of a buggy software program is essentially a data mining process. Although many interesting methods have been developed to trace crashing bugs (such as memory violation and core dumps), it is still difficult to analyze noncrashing bugs (such as logical errors). In this paper, we develop a novel method to classify the structured traces of program executions using software behavior graphs. By analyzing the correct and incorrect executions, we have made good progress at the isolation of program regions that may lead to the faulty executions. The classification framework is built on an integration of closed graph mining and SVM classification. More interestingly, suspicious regions are identified through the capture of the classification accuracy change, which is measured incrementally during program execution. Our performance study and case-based experiments show that our approach is both effective and effi-
29 May 2005
TL;DR: This paper identifies minimal sets of axioms which need to be removed or ignored to turn an ontology coherent and shows how pinpointing can be used for debugging of web ontologies in two typical cases.
Abstract: Ontologies are the backbone of the Semantic Web as they allow one to share vocabulary in a semantically sound way. For ontologies, specified in OWL or a related web ontology language, Description Logic reasoner can often detect logical contradictions. Unfortunately, there are two drawbacks: they lack in support for debugging incoherence in ontologies, and they can only be applied to reasonably expressive ontologies (containing at least some sort of negation).
In this paper, we attempt to close these gaps using a technique called pinpointing. In pinpointing we identify minimal sets of axioms which need to be removed or ignored to turn an ontology coherent. We then show how pinpointing can be used for debugging of web ontologies in two typical cases. More unusual is the application of pinpointing in the semantic clarification of underspecified web ontologies which we experimentally evaluate on a number of well-known web-ontologies. Our findings are encouraging: even though semantic ambiguity remains an issue, we show that pinpointing can be useful for debugging, and that it can significantly improve the quality of our semantic enrichment in a fully automatic way.
15 May 2005
TL;DR: It is described how automated tools can detect such errors and IMC's unique technology automatically detects several kinds of MPI errors such as various types of mismatches, race conditions, deadlocks and potential deadlocks, and resource misuse.
Abstract: The trend towards many-core multi-processor systems and clusters will make systems with tens and hundreds of processors more widely available. Current manual debugging techniques do not scale well to such large systems. Advanced automated debugging tools are needed for standard programming models based on commodity computing, such as threads and MPI. We surveyed MPI users to identify the kinds of MPI errors that they encounter, and classify the errors into several types. We describe how automated tools can detect such errors and present the Intel® Message Checker (IMC) technology being developed at the Intel Advanced Computing Center. IMC's unique technology automatically detects several kinds of MPI errors such as various types of mismatches, race conditions, deadlocks and potential deadlocks, and resource misuse. Finally, we review the usability and uniqueness of IMC and discuss our future plans.
6 Nov 2005
TL;DR: This paper defines general concepts for the diagnosis of ontologies and provides correct and complete algorithms for the computation of minimal diagnoses of knowledge bases.
Abstract: The effective debugging of ontologies is an important prerequisite for their successful application and impact on the semantic web. The heart of this debugging process is the diagnosis of faulty knowledge bases. In this paper we define general concepts for the diagnosis of ontologies. Based on these concepts, we provide correct and complete algorithms for the computation of minimal diagnoses of knowledge bases. These concepts and algorithms are broadly applicable since they are independent of a particular variant of an underlying logic (with monotonic semantics) and independent of a particular reasoning system. The practical feasibility of our method is shown by extensive test evaluations.
Patent•
31 Mar 2005
TL;DR: Behavior abstraction as discussed by the authors is a technique where a predetermined behavioral sequence is automatically recognized by the simulator in a concurrent stream of system events, where the events considered in a behavioral sequence are subject to configuration-based filtering and clustering.
Abstract: A behavioral abstraction is, in an abstract sense, a generalization of an event cluster. Behavioral abstraction is a technique where a predetermined behavioral sequence is automatically recognized by the simulator in a concurrent stream of system events. A behavioral sequence is at its most basic level a partial order of events. However, the events considered in a behavioral sequence are subject to configuration-based filtering and clustering. This allows a designer to create a model for a particular behavior and then set up a tool to find instances of the particular behavior in an execution trace. Behavior models are representations of partially ordered event sequences and can include events from several components.
31 May 2005
TL;DR: Unlike prior debugging techniques, the proposed one exploits the hierarchical nature of modern designs to improve the performance and quality of debugging and formulates the problem in terms of Quantified Boolean Formula Satisfiability to obtain dramatic reduction in memory requirements, which allows for debugging of large designs.
Abstract: As VLSI designs grow in complexity and size, errors become more frequent and difficult to track. Recent developments have automated most of the verification tasks but debugging still remains a resource-intensive, manually conducted procedure. This paper bridges this gap as it develops robust automated debugging methodologies that complement verification processes. Unlike prior debugging techniques, the proposed one exploits the hierarchical nature of modern designs to improve the performance and quality of debugging. It also formulates the problem in terms of Quantified Boolean Formula Satisfiability to obtain dramatic reduction in memory requirements, which allows for debugging of large designs. Extensive experiments conducted on industrial and benchmark designs confirm the efficiency and practicality of the proposed approach.
TL;DR: To provide a virtual connection between the processor core in the SoC and its corresponding probe control, MED (multicore embedded debugging) software tool is proposed, which allows a contiguous analysis flow from the system level simulation models of SoC systems through FPGA and emulation prototyping and finally it debug the silicon hardware.
Abstract: Multiple cores embedded debugging architecture for system on chip design (SOC) is presented. It presents an asymmetrical functional test problem. To analyze the problem and optimize performance in multicore operation, debug tools with interfaces are exercised for several cores. HyperJTAG (joint test action group) interface reduces the IO pin interfaces required for debugging several cores. To overcome the wiring problem in hyperJTAG, wire routing and debugging synchronization is proposed. Hyper debug action nodes at each core initiate global or local control actions that synchronously reset the cores. To provide a virtual connection between the processor core in the SoC and its corresponding probe control, MED (multicore embedded debugging) software tool is proposed. This allows a contiguous analysis flow from the system level simulation models of SoC systems through FPGA and emulation prototyping and finally it debug the silicon hardware.
15 Jun 2005
TL;DR: This paper presents a solution to the precision instrumentation problem for microcontroller code that is based upon the open, flexible simulator framework, Avrora, and preserves all timing and behavior of the instrumented program while allowing precision measurement of application-specific quantities.
Abstract: Debugging, testing, and profiling microcontroller programs are notoriously difficult. The lack of supporting software such as an operating system, a narrow interface to the hardware chip, and delicately timed sequences of code present significant challenges which can be exacerbated by the presence of additional debugging or profiling code. In this paper we present a solution to the precision instrumentation problem for microcontroller code that is based upon our open, flexible simulator framework, Avrora. Our simulator preserves all timing and behavior of the instrumented program while allowing precision measurement of application-specific quantities.
13 Dec 2005
TL;DR: A model-driven anomaly characterization approach is proposed and used to discover operating system performance bugs when supporting disk I/O-intensive online servers and shows that the corrected kernel improves system throughput by up to five-fold compared with the original kernel.
Abstract: It is challenging to identify performance problems and pinpoint their root causes in complex systems, especially when the system supports wide ranges of workloads and when performance problems only materialize under particular workload conditions. This paper proposes a model-driven anomaly characterization approach and uses it to discover operating system performance bugs when supporting disk I/O-intensive online servers. We construct a whole-system I/O throughput model as the reference of expected performance and we use statistical clustering and characterization of performance anomalies to guide debugging. Unlike previous performance debugging methods offering detailed statistics at specific execution settings, our approach focuses on comprehensive anomaly characterization over wide ranges of workload conditions and system configurations.Our approach helps us quickly identify four performance bugs in the I/O system of the recent Linux 2.6.10 kernel (one in the file system prefetching, two in the anticipatory I/O scheduler, and one in the elevator I/O scheduler). Our experiments with two Web server benchmarks, a trace-driven index searching server, and the TPC-C database benchmark show that the corrected kernel improves system throughput by up to five-fold compared with the original kernel (averaging 6%, 32%, 39%, and 16% for the four server workloads).
11 Jul 2005
TL;DR: This paper illustrates how, in a BPEL engine with aspect-weaving capabilities, a process-driven application based on the Google Web service can be dynamically adapted with new features and hot-fixed to meet unforeseen post-deployment requirements.
Abstract: Web service orchestration engines need to be more open to enable the addition of new features into service-based applications. In this paper, we illustrate how, in a BPEL engine with aspect-weaving capabilities, a process-driven application based on the Google Web service can be dynamically adapted with new features and hot-fixed to meet unforeseen post-deployment requirements. Business processes (the application skeletons) can be enriched with additional features such as debugging, execution monitoring, or an application-specific GUI. Dynamic aspects are also used on the processes themselves to tackle the problem of hot-fixes to long running processes. In this manner, composing a Web service 'on-the-fly' means weaving its choreography interface into the business process.
Proceedings Article•
1 Jun 2005
TL;DR: This paper introduces protothreads, a programming abstraction for event-driven sensor network systems that simplifies implementation of high-level functionality on top of event- driven systems, without significantly increasing the memory requirements.
Abstract: Wireless sensor networks consist of tiny devices
that usually have severe resource constraints in terms of energy, processing power and memory. In order to work efficiently within the constrained memory, many operating systems for such devices are based on an event-driven model rather than on multi-threading. While event-driven systems allow for reduced memory usage, they require programs to be developed as explicit state machines. Since implementing programs as explicit state machines is hard, developing, maintaining, and debugging programs for event-driven systems is difficult. In this paper, we introduce protothreads, a programming abstraction for event-driven sensor network systems. Protothreads simplify implementation of high-level functionality on top of event-driven systems, without significantly increasing the memory requirements. The memory requirement of a protothread is that of an unsigned integer.
16 Oct 2005
TL;DR: This work is concurrently constructing two artifacts--a Self VM entirely in Self (the Klein VM), and a specialized development environment--with strict adherence to pure object-orientation, metacircularity, heavy code reuse, reactivity, and mirror-based reflection.
Abstract: Can virtual machine developers benefit from religiously observing the principles more often embraced for exploratory programming? To find out, we are concurrently constructing two artifacts--a Self VM entirely in Self (the Klein VM), and a specialized development environment--with strict adherence to pure object-orientation, metacircularity, heavy code reuse, reactivity, and mirror-based reflection. Although neither artifact is yet complete, the environ-ment supports many remote debugging and incremental update operations, and the exported virtual machine has successfully run the whole compiler.As a result of our adherence to these principles, there have been both positive and negative consequences. We have been able to find and exploit many opportunities for parsimony. For example, the very same code creates objects in the bootstrap image, builds ob-jects in the running VM, and implements a remote debugger. On the other hand, we have been forced to expend effort to optimize the performance of the environment. Overall, this approach trades off the performance of the environment against the architectural sim-plicity and ease of development of the resulting VM artifact. As computers continue to improve in performance, we believe that this approach will increase in value.
12 Jun 2005
TL;DR: TraceBack provides debugging information for production systems by providing execution history data about program problems, and uses static, binary program analysis to inject low-overhead runtime instrumentation at control-flow block granularity.
Abstract: Faults that occur in production systems are the most important faults to fix, but most production systems lack the debugging facilities present in development environments. TraceBack provides debugging information for production systems by providing execution history data about program problems (such as crashes, hangs, and exceptions). TraceBack supports features commonly found in production environments such as multiple threads, dynamically loaded modules, multiple source languages (e.g., Java applications running with JNI modules written in C++), and distributed execution across multiple computers. TraceBack supports first fault diagnosis-discovering what went wrong the first time a fault is encountered. The user can see how the program reached the fault state without having to re-run the computation; in effect enabling a limited form of a debugger in production code.TraceBack uses static, binary program analysis to inject low-overhead runtime instrumentation at control-flow block granularity. Post-facto reconstruction of the records written by the instrumentation code produces a source-statement trace for user diagnosis. The trace shows the dynamic instruction sequence leading up to the fault state, even when the program took exceptions or terminated abruptly (e.g., kill -9).We have implemented TraceBack on a variety of architectures and operating systems, and present examples from a variety of platforms. Performance overhead is variable, from 5% for Apache running SPECweb99, to 16%-25% for the Java SPECJbb benchmark, to 60% average for SPECint2000. We show examples of TraceBack's cross-language and cross-machine abilities, and report its use in diagnosing problems in production software.
20 Sep 2005
TL;DR: A semi-automatic debugger for spreadsheet systems that is specifically targeted at end-user programmers that can be used to automatically detect and correct various kinds of errors in spreadsheets.
Abstract: We present a semi-automatic debugger for spreadsheet systems that is specifically targeted at end-user programmers. Users can report expected values for cells that yield incorrect results. The system then generates change suggestions that could correct the error. Users can interactively explore, apply, refine, or reject these change suggestions. The computation of change suggestions is based on a formal inference system that propagates expected values backwards across formulas. The system is fully integrated into Microsoft Excel and can be used to automatically detect and correct various kinds of errors in spreadsheets. Test results show that the system works accurately and reliably.
1 Jul 2005
TL;DR: A representation of all graphics state over the course of program execution as a relational database is proposed, and a query-based framework for extracting, manipulating, and visualizing data from all stages of the graphics pipeline is produced.
Abstract: We present a new, unified approach to debugging graphics software. We propose a representation of all graphics state over the course of program execution as a relational database, and produce a query-based framework for extracting, manipulating, and visualizing data from all stages of the graphics pipeline. Using an SQL-based query language, the programmer can establish functional relationships among all the data, linking OpenGL state to primitives to vertices to fragments to pixels. Based on the Chromium library, our approach requires no modification to or recompilation of the program to be debugged, and forms a superset of many existing techniques for debugging graphics software.
Patent•
22 Jun 2005
TL;DR: In this article, the application debugging switch collects multiple samples of response time over a certain period of time, which provides a good measurement for the average application response time, i.e., the response time is a combination of the network response time and the application response times.
Abstract: An application debugging switch also monitors application performance. The application debugging switch forwards the requests from a first host to a second host, and later forwards the response coming from that second host to that first host. As most of the applications work in a request—response architecture, the application debugging switch can measure the response time of the application. The switch attaches a timestamp to each request that it forwards. When the response to that request comes to the switch, the switch can determine the response time of that application. The application debugging switch collects multiple samples of response time over a certain period of time. These samples provide a good measurement for the average application response time. The response time is a combination of the network response time and the application response time. The application debugging switch holds multiple measurement classes. Each class defines different sources or destinations of traffic (IP addresses and networks) and different applications (TCP/UDP ports or content identifiers in the requests). Collecting the response time for each class separately allows zooming in to an application and user that experience bad service and detect the reason for their failure.
1 Sep 2005
TL;DR: A method for matching dynamic histories of program executions of two program versions which produces highly accurate matches which are highly effective when used in comparison checking approach to debugging optimized code.
Abstract: We develop a method for matching dynamic histories of program executions of two program versions. The matches produced can be useful in many applications including software piracy detection and several debugging scenarios. Unlike some static approaches for matching program versions, our approach does not require access to source code of the two program versions because dynamic histories can be collected by running instrumented versions of program binaries. We base our matching algorithm on comparison of rich program execution histories which include: control flow taken, values produced, addresses referenced, as well as data dependences exercised. In developing a matching algorithm we had two goals: producing an accurate match and producing it quickly. By using rich execution history, we are able to compare the program versions across many behavioral dimensions. The result is a fast and highly precise matching algorithm. Our algorithm first uses individual histories of instructions to identify multiple potential matches and then it refines the set of matches by matching the data dependence structure established by the matching instructions. To test our algorithm we attempted matching of execution histories of unoptimized and optimized program versions. Our results show that our algorithm produces highly accurate matches which are highly effective when used in comparison checking approach to debugging optimized code.
TL;DR: A key finding of this model is that the practice of alternating between pure construction and pure debugging is suboptimal, and it is desirable to concurrently construct and debug the system.
Abstract: We study the problem of optimally allocating effort between software construction and debugging. As construction proceeds, new errors are introduced into the system. The objective is to deliver a system of the highest possible quality (fewest number of errors) subject to the constraint that N system modules are constructed in a specified duration T. If errors are not corrected during construction, then further construction can produce errors at a faster rate. To curb the growth of errors, some of the effort must be taken away from construction and assigned to testing and debugging. A key finding of this model is that the practice of alternating between pure construction and pure debugging is suboptimal. Instead, it is desirable to concurrently construct and debug the system. We extend the above model to integrate decisions traditionally considered "external" such as the time to release the product to the market with those that are typically treated as "internal" such as the division of effort between construction and debugging. Results show that integrating these decisions can yield significant reduction in the overall cost. Also, when competitive forces are strong, it may be better to release a product early (with more errors) than late (with fewer errors). Thus, underestimating the cost of errors in the product may be better than overestimating the cost.
Patent•
25 Feb 2005TL;DR: In this paper, the authors present a scalable remote debugging system that can debug machines positioned behind a firewall and through the Internet, via employing an Internet Friendly Relay Service (IFRS). The IFRS can be positioned in a common reach location and provide a secure method of exchanging communication traffic over HTTP using SSL and security tokens in real time.
Abstract: Systems and methodologies for a scalable remote debugging system that can debug machines positioned behind a firewall and thru the Internet, via employing an Internet Friendly Relay Service (IFRS). The IFRS can be positioned in a common reach location and provide a secure method of exchanging communication traffic over HTTP using SSL and security tokens in real time. Web server(s) of the IFRS can further employ an authorization and/or tracking system to verify connection of a client thereto, for debugging purposes.
1 Jan 2005
TL;DR: This paper introduces a general framework for incorporating a refinement module into rule-based transfer MT systems, and proposes a largely automated method for capturing more information from human post-editors so that corrections may be performed automatically to translation grammar rules and lexical entries.
Abstract: Most current Machine Translation (MT) systems do not improve with feedback from post-editors beyond the addition of corrected translations to parallel training data (for statistical and example-base MT) or to a memory database. Rule based systems to date improve only via manual debugging. In contrast, we propose a largely automated method for capturing more information from human post-editors, so that corrections may be performed automatically to translation grammar rules and lexical entries. This paper introduces a general framework for incorporating a refinement module into rule-based transfer MT systems. This framework allows for generalizing post-editing efforts in an effective way, by identifying and correcting rules semi-automatically on order to improve coverage and overall translation quality.