Efficient debugging in a formal verification environment

In this paper, we emphasize the importance of efficient debugging in formal verification and present capabilities that we have developed in order to aid debugging in Intel’s Formal Verification Environment. We have given the name “Counter-Example Wizard” to the bundle of capabilities that we have developed to address the needs of the verification engineer in the context of counter-example diagnosis and rectification. The novel features of the Counter-Example Wizard are the multi-value counter-example annotation, constraint-based debugging, and multiple counter-example generation mechanisms. Our experience with the verification of real-life Intel designs shows that these capabilities complement one another and can help the verification engineer diagnose and fix a reported failure. We use real-life verification cases to illustrate how our system solution can significantly reduce the time spent in the loop of model checking, specification, and design modification. Published online: 21 February 2003     

Visualization and debugging of distributed multiagent systems

Visualizing the behavior of systems with distributed data, control, and process is a notoriously difficult task. Each component in the distributed system has only a local view of the whole setup, and the onus is on the user to integrate, into a coherent whole, the large amounts of limited information they provide. In this article, we describe an architecture and an implemented system for visualizing and controlling distributed multiagent applications. The system comprises a suite of tools, with each tool providing a different perspective of the application being visualized . Each tool interrogates the components of the distributed application, collates the returned information, and presents this information to users in an appropriate manner. This in essence, shifts the burden ofinference from the user to the visualizer. Our visualizer has been evaluated on four distributed multiagent systems: a travel management application, a telecommunications network management application, a business process management demonstrator, and an electronic commerce application. Lastly, we briefly show how the suite of tools can be used together for debugging multiagent applications - a process we refer to as debugging via corroboration.     

PROVIDE: a process visualization and debugging environment

The author introduces PROVIDE, a source-level process visualization and debugging environment currently under development at the University of Illinois at Chicago. PROVIDE is a modern coding and debugging environment that is designed to allow the user to configure interaction at a desired level of abstraction. It emphasizes the use of interactive computer graphics for the illustration of program execution, with special attention to the requirements of program debugging. The major features of PROVIDE are presented, especially the concepts of deferred-binding program animation, which allows users to interactively change the depiction of program execution during the debugging task, and process history consistency maintenance, which guarantees a consistent (automatically updated) record of program execution in the face of changes to program instructions and run-time data values. The current PROVIDE prototype is implemented on Macintosh workstations networked to a VAX 11/780 running 4.2 BSD Unix     

Authentication in a heterogeneous environment

This paper considers how a mechanism might be set up to provide authentication of users and servers. The scheme proposed aims to deal with simple processors which are unmanaged, as well as managed timesharing systems. It would provide authentication tokens which can be included in the applications protocols. Much of the difficulty of the scheme is concerned with building a distributed secure database for private keys.     

Relative debugging in an integrated development environment

Relative Debugging allows a user to compare the internal state of two programs as they run, making it possible to test whether two programs perform the same function given the same input. When implemented with a command line user interface, a relative debugger looks like traditional debugging tools with the addition of commands that describe which structures should be equivalent in the two programs. In this paper, we discuss relative debugging within an integrated development environment, and show that there are significant advantages over a command line form. We describe a pluggable, modular, architecture that works with a variety of different products, including Microsoft's Visual Studio, SUN's NetBeans, and IBM's Eclipse. Copyright © 2009 John Wiley & Sons, Ltd.     

Recommendations in a heterogeneous service environment

This paper presents novel algorithms which are able to generate recommendations within a heterogeneous service environment. In this work explicitly set preferences as well as implicitly logged viewing behavior are employed to generate recommendations for Digital Video Broadcast (DVB) content. This paper also discusses the similarity between the DVB genres and YouTube categories. In addition it presents results to show the comparison between well known collaborative filtering methods. The outcome of this comparison study is used to identify the most suitable filtering method to use in the proposed environment. Finally the paper presents a novel Personal Program Guide (PPG), which is used as a tool to visualize the generated recommendations within a heterogeneous service environment. This PPG is also capable of showing the linear DVB content and the non-linear YouTube videos in a single view.     

A user interface specification for a program debugging and measuring environment

A high level of complexity is involved in program dynamics. A number of tools have been developed to assist the programmer in mastering this complexity in the various phases of software development. However, these tools are specifically oriented towards the monitoring of particular aspects of program behaviour. This paper presents the results of a systematic attempt at defining the user interface to an environment for program debugging, program performance evaluation and program structure analysis. This environment can be used to implement many common debugging techniques, and to evaluate important program performance indexes and program structure statistics. It supports both sequential and concurrent block-oriented high-level languages.     

Independent checkpointing in a heterogeneous grid environment

The EU-funded XtreemOS project implements an open-source grid operating system based on Linux. In order to provide fault tolerance and migration for grid applications, it integrates a distributed grid-checkpointing service called XtreemGCP. This service is designed to support various checkpointing protocols and different checkpointer packages (e.g. BLCR, LinuxSSI, OpenVZ, etc.) in a transparent manner through a uniform checkpointer interface. In this paper, we present the integration of a backward error recovery protocol based on independent checkpointing into the XtreemGCP service. The solution we propose is not checkpointer bound and thus can be transparently used on top of any checkpointer package.To evaluate the prototype we run it within a heterogeneous environment composed of single-PC nodes and a Single System Image (SSI) cluster. The experimental results demonstrate the capability of the XtreemGCP service to integrate different checkpointing protocols and independently checkpoint a distributed application within a heterogeneous grid environment. Moreover, the performance evaluation also shows that our solution outperforms the existing coordinated checkpointing protocol in terms of scalability.     

A debugging environment for lazy functional languages

This paper describes a new approach for debugging lazy functional languages. It rests on the fact that a functional program is the transformation of an expression; one debugs a program by investigating the syntactic form of the expression and by stopping the reduction process at given points. We show what problems are involved and our approach to solving them in a prototype implementation.     

Symbolic debugging through incremental compilation in an integrated environment

It is demonstrated that fine-grained incremental compilation is a relevant technique when implementing powerful debuggers an incremental programming environments. A debugger and an incremental compiler for pascal has been implemented in the DICE system (Distributed Incremental Compiling environment). Incremental compilation is at the statement level which makes it useful for the debugger which also operates at the statement level. The quality of code produced by the incremental compiler approaches that required for production use. The algorithms involved an incremental compilation are not very complicated, but they require information that is easily available only in an integrated system, like DICE, where editor, compiler, linker, debugger and program data-base are well integrated into a single system. The extra information that has to be kept around, like the cross-reference database, can be used for multiple purposes, which makes total system economics favorable.     

Improving scheduling of tasks in a heterogeneous environment

Optimal scheduling of parallel tasks with some precedence relationship, onto a parallel machine is known to be NP-complete. The complexity of the problem increases when task scheduling is to be done in a heterogeneous environment, where the processors in the network may not be identical and take different amounts of time to execute the same task. We introduce a task duplication-based scheduling algorithm for network of heterogeneous systems (TANH), with complexity O(V/sup 2/), which provides optimal results for applications represented by directed acyclic graphs (DAGs), provided a simple set of conditions on task computation and network communication time could be satisfied. The performance of the algorithm is illustrated by comparing the scheduling time with an existing "best imaginary level scheduling (BIL)" scheme for heterogeneous systems. The scalability for a higher or lower number of processors, as per their availability is also discussed. We have shown to provide substantial improvement over existing work on the task duplication-based scheduling algorithm (TDS).     

Integrity maintenance in a heterogeneous engineering database environment

Integrity maintenance is essential in integrated engineering information systems because the behaviour of the whole system becomes unpredictable unless the integrity of the shared data is properly maintained. However, validation of integrity is often very expensive because it requires lots of cross references of entity instances of the same type or different types, which should be retrieved from database systems in a shared database environment. One of the goals of this work is to minimize the number of database accesses in validating a set of integrity constraints. A heterogeneous database environment is built using EXPRESS as a global schema language. EXPRESS is an international standard information modelling language which was developed for STEP (STandard for the Exchange of Product data). Based on a set of database interface functions, evaluation sequences are determined by analysing the data dependencies among database accesses required for integrity validation.     

Protocol performance measurements in a heterogeneous network environment

Reported are comparisons of TCP-, XTP¹- and UDP throughout measurements over an ATM inhouse network, the STM based part of the BERKOM^{, 2} B-ISDN and a CSMA/CD LAN. The impact of concurrent processes on the throughput performance was observed. XTP has been found to perform as well as and in some situations better than TCP/IP. Both XTP and TCP achieved about 8 Mb/s over Ethernet (ftp ˜ 8.7 Mb/s) and more than 17 Mb/s over a 140 Mb/s STM-channel of the BERKOM B-ISDN network (ftp up to 16 Mb/s). TCP/IP throughput performance on the basis of the latest Fore ATM system release available (SBA200 series) revealed a substantial increase in performance compared to previous releases of the Fore ATM network adapter. Experiments have shown that average throughput rates of up to 59 Mb/s are achievable with a SPARCstation 10 based ATM endsystem.     

A graphical development and debugging environment for parallel programs

To provide high-level graphical support for PVM (Parallel Virtual Machine) based program development, a complex programming environment (GRADE) is being developed. GRADE currently provides tools to construct, execute, debug, monitor and visualize message-passing parallel programs. It offers a high-level graphical programming abstraction mechanism to construct parallel applications by introducing a new graphical language called GRAPNEL. GRADE also provides the programmer with the same graphical user interface during the program design and debugging stages. A distributed debugging engine (DDBG) assists the user in debugging GRAPNEL programs on distributed memory computer architectures. Tape/PVM and PROVE support the performance monitoring and visualization of parallel programs developed in the GRADE environment.     

Modeling optimal release policy under fuzzy paradigm in imperfect debugging environment

ContextIn this study, a software optimal release time with cost-reliability criteria has been discussed in an imperfect debugging environment.ObjectiveThe motive of this study is to model uncertainty involved in estimated parameters of the software reliability growth model (SRGM).MethodInitially the reliability parameters of SRGM are estimated using least square estimation (LSE). Considering the uncertainty involved in the estimated parameters due to human behavior being subjective in nature and the dynamism of the testing environment, the concept of fuzzy set theory is applicable in developing SRGM. Finally, using arithmetic operations on fuzzy numbers, the reliability and total software cost are calculated.ResultsVarious reliability measures have been computed at different levels of uncertainties, and a comparison has been made with the existing results reported in the literature.ConclusionIt is evident from the results that a better prediction of reliability measures, namely, software reliability and total software cost can be made under the fuzzy paradigm.     

A remote computation facility for a heterogeneous environment

The authors describe THERE (the heterogeneous environment for remote execution), a general-purpose facility designed to simplify the adaptation of nonnetworked, nonheterogeneous applications to a distributed heterogeneous environment. Existing applications made accessible with THERE become heterogeneous network services, and users of those services become heterogeneous network clients. They discuss the problems of remote computation, provide an overview of THERE, and describe the building of THERE applications. They present TPL, THERE programming language, which is tailored toward building execution environments for application programs (on the server sided), defining client interfaces to remote services (on the client side), and providing system-independent communication between client and server interfaces     

Coexistence of a cross-diffusive dengue fever model in a heterogeneous environment

A spatio-temporal SIS-SI dengue model with cross-diffusion is formulated as the movements of human and mosquitoes have been intricately linked with the spread of dengue fever. To highlight the impacts of cross-diffusion on the dynamical processes, we focus on the nonnegative steady-state solutions of the dengue model, that is, the coexistence of the corresponding strongly-coupled elliptic system. By means of the relevant eigenvalue problem, we investigate some properties of the basic reproduction number to the model, and further present the existence of coexistence solutions. Our results imply that the virus carried in human and that in mosquitoes can coexist if the basic reproduction number is greater than one and the extent of cross-diffusion is small enough. The final numerical simulations and epidemiological explanations make our analytical findings easier to understand.     

Object‐oriented design patterns for debugging heterogeneous languages and virtual machines

Debugging multi‐language software systems requires examining and executing these systems at multiple levels of abstraction. Embedded systems, for example, often comprise a mix of assembly language device drivers and C language control code. Embedded systems increasingly utilize Java to support dynamic loading and run‐time reconfiguration. The RTEEM (Research version of the Tcl Environment for Extensible Modeling) debugger employs three design patterns in solving the problems of multi‐language embedded system debugging. The Reflective virtual machine (VM) pattern models a language‐neutral virtual machine abstraction, with language‐specific interfaces extending this abstraction. Reflection allows a debugger to inspect and control a target VM. The Chain of Responsibility is a classic pattern used to arrange language‐specific debugger command interpreters in a delegation chain. All interpreters share a single command syntax, but each interpreter adapts commands to its language abstraction by interacting with its language‐specific VM view. Composite is another classic pattern, used to combine objects into tree structures. RTEEM employs it to aggregate VM debugger chains into a hierarchy that supports uniform command syntax for debugging threads, processes, multiprocessor systems, and compositions of these entities. This paper illustrates how combining two classic design patterns with the VM abstraction as a pattern results in an architecture that is powerful and flexible in adapting to the debugging needs of heterogeneous, distributed embedded systems. Copyright © 2004 John Wiley & Sons, Ltd.