Results 1 - 10
of
11
Testing using Log File Analysis: Tools, Methods, and Issues
- In Proceedings of the 1998 International Conference on Automated Software Engineering (ASE'98
, 1998
"... Large software systems often keep log files of events. Such log files can be analyzed to check whether a run of a program reveals faults in the system. We discuss how such log files can be used in software testing. We present a framework for automatically analyzing log files, and describe a language ..."
Abstract
-
Cited by 25 (2 self)
- Add to MetaCart
Large software systems often keep log files of events. Such log files can be analyzed to check whether a run of a program reveals faults in the system. We discuss how such log files can be used in software testing. We present a framework for automatically analyzing log files, and describe a language for specifying analyzer programs and an implementation of that language. The language permits compositional, compact specifications of software, which act as test oracles; we discuss the use and efficacy of these oracles for unit- and system-level testing in various settings. We explore methodological issues such as efficiency and logging policies, and the scope and limitations of the framework. We conclude that testing using log file analysis constitutes a useful methodology for software verification, somewhere between current testing practice and formal verification methodologies. 1. Introduction It is clear that many aspects of the desired behaviour of software can be given formal speci...
Monitoring Software Requirements Using Instrumented Code
- In HICSS ’02: Proceedings of the 35th Annual Hawaii International Conference on System Sciences (HICSS’02)-Volume 9. IEEE Computer Society
, 2002
"... Ideally, software is derived from requirements whose properties have been established as good. However, it is difficult to define and analyze requirements. Moreover, derivation of software from requirements is error prone. Finally, the installation and use of compiled software can introduce errors. ..."
Abstract
-
Cited by 18 (0 self)
- Add to MetaCart
Ideally, software is derived from requirements whose properties have been established as good. However, it is difficult to define and analyze requirements. Moreover, derivation of software from requirements is error prone. Finally, the installation and use of compiled software can introduce errors. Thus, it can be difficult to provide assurances about the state of a software's execution.
Broad-Spectrum Studies of Log File Analysis
- Proceedings of the 22nd International Conference on Software Engineering (ICSE 2000
, 2000
"... This paper reports on research into applying the technique of log file analysis for checking test results to a broad range of testing and other tasks. The studies undertaken included applying log file analysis to both unit- and system-level testing and to requirements of both safety-critical and non ..."
Abstract
-
Cited by 9 (2 self)
- Add to MetaCart
This paper reports on research into applying the technique of log file analysis for checking test results to a broad range of testing and other tasks. The studies undertaken included applying log file analysis to both unit- and system-level testing and to requirements of both safety-critical and non-critical systems, and the use of log file analysis in combination with other testing methods. The paper also reports on the technique of using log file analyzers to simulate the software under test, both in order to validate the analyzers and to clarify requirements. It also discusses practical issues to do with the completeness of the approach, and includes comparisons to other recently-published approaches to log file analysis. Keywords Testing, specification, safety verification, lightweight formal methods, test oracles 1 INTRODUCTION Testing is an important and costly component of any software development project, and the efficient, reliable validation of test results is an importan...
Theory and Practice of Log File Analysis
, 1998
"... : Large software systems often keep log files of events. Such log files can be analyzed to check whether a run of a program reveals faults in the system. We discuss how such log files can be used in software testing. We present a formal framework for analyzing log files, and describe a language for ..."
Abstract
-
Cited by 4 (2 self)
- Add to MetaCart
: Large software systems often keep log files of events. Such log files can be analyzed to check whether a run of a program reveals faults in the system. We discuss how such log files can be used in software testing. We present a formal framework for analyzing log files, and describe a language for specifying analyzer programs and an implementation of that language. The automated analyzers act as test oracles; we discuss the use and efficacy of these oracles for unit- and system-level testing in various settings. We explore methodological issues such as efficiency and logging policies, and the scope and limitations of the framework. We conclude that testing using log file analysis constitutes a useful methodology for software verification, whose level of rigour and ease of use is somewhere between that of current testing practice and that of formal verification methodologies. 1 Introduction Large programs or software systems often keep what are called "log files" -- continuous repor...
Self-Organizing Hierarchical Cluster Timestamps
- EuroPar'01 Parallel Processing, volume LNCS 2150 of Lecture Notes in Computer Science
, 2001
"... Distributed-system observation tools require an efficient data structure to store and query the partial-order of execution. Such data structures typically use vector timestamps to efficiently answer precedence queries. Many current vector-timestamp algorithms either have a poor time/space complex ..."
Abstract
-
Cited by 2 (2 self)
- Add to MetaCart
Distributed-system observation tools require an efficient data structure to store and query the partial-order of execution. Such data structures typically use vector timestamps to efficiently answer precedence queries. Many current vector-timestamp algorithms either have a poor time/space complexity tradeoff or are static. This limits the scalability of such observation tools. One algorithm, centralized hierarchical cluster timestamps, has potentially a good time/space tradeoff provided that the clusters accurately capture communication locality.
Fast convex closure for efficient predicate detection
- In Proceedings of Euro-Par 2005 Parallel Processing: 11th International Euro-Par Conference
, 2005
"... Abstract. The behaviour of parallel and distributed programs can be modeled as the occurrence of events and their interrelationship. Event data collected according to the event model is stored within a partial-order data structure, where it can be reasoned about, enabling debugging, program steering ..."
Abstract
-
Cited by 2 (1 self)
- Add to MetaCart
Abstract. The behaviour of parallel and distributed programs can be modeled as the occurrence of events and their interrelationship. Event data collected according to the event model is stored within a partial-order data structure, where it can be reasoned about, enabling debugging, program steering, and autonomic feedback control of the application. Reasoning over event data, a critical requirement for autonomic computing, is typically in the form of predicate detection, a search mechanism able to detect and locate arbitrary predicates within the event data. To enable hierarchical predicate detection, compound events are formed by computing the convex closure of the matching primitive events. In particular, the Xie and Taylor convex-closure algorithm forms the basis for such an approach to predicate detection. Unfortunately, their algorithm can be quite slow, especially for hierarchical compound events. In this paper, we study the cause of the problems in the Xie and Taylor algorithm. We then develop an efficient extension to their algorithm, based on a simple caching scheme. We prove our algorithm correct. We also provide experimental results that demonstrate that our approach reduces the execution time of the Xie and Taylor algorithm by up to 98 percent.
Timestamping Messages in Synchronous Computations
- In Proceedings of the 22nd International Conference on Distributed Computing Systems, pages 552 – 559. IEEE Computer
, 2002
"... computations is a fundamental problem with applications in distributed monitoring systems and faulttolerance. Fidge and Mattern's vector clocks capture the order relationship with vectors of size N in a system with N processes. Since many distributed applications use synchronous messages, it is nat ..."
Abstract
-
Cited by 2 (0 self)
- Add to MetaCart
computations is a fundamental problem with applications in distributed monitoring systems and faulttolerance. Fidge and Mattern's vector clocks capture the order relationship with vectors of size N in a system with N processes. Since many distributed applications use synchronous messages, it is natural to ask if the overhead can be reduced for these applications. In this paper, we present a new method of timestamping messages and events in synchronous computations that capture the order relationship with vectors of size less than or equal to the size of the vertex cover of the communication topology of the system. Our method is fundamentally different from that of Fidge and Mattern's technique. The timestamps in our method do not use one component per process but still guarantee that the order relationship is captured accurately. Our algorithm is online and only requires piggybacking of timestamps on program messages. It is applicable to all programs that either use programming languages which use synchronous communication such as CSP, or use synchronous remote procedure calls.
Clustering Strategies for Cluster Timestamps
- Proceedings of the 2004 International Conference on Parallel Processing
, 2004
"... Distributed-system observation tools require an efficient data structure to store and query the partial-order of execution. Such data structures typically use vector timestamps to efficiently answer precedence queries. Many current vector-timestamp algorithms either have a poor time/space complexity ..."
Abstract
-
Cited by 1 (1 self)
- Add to MetaCart
Distributed-system observation tools require an efficient data structure to store and query the partial-order of execution. Such data structures typically use vector timestamps to efficiently answer precedence queries. Many current vector-timestamp algorithms either have a poor time/space complexity tradeoff or are static. This limits the scalability of such observation tools. The self-organizing hierarchical cluster timestamp, introduced by Ward and Taylor, potentially has a good time/space tradeoff provided that the clusters accurately capture communication locality. However, the problem of accurately capturing communication locality has not been adequately addressed. In particular, the only clustering algorithm for which results have been presented is the merge-onfirst -communication approach. That strategy has limited applicability, as it is very sensitive to the order of event processing and to the maximum cluster size permitted.
Issues in Scalable . . .
, 2001
"... Distributed-system management concerns the observation of a distributed computation and then using the information gained by that observation to control the computation. This necessitates collecting the information required to determine the partial order of execution, and then reasoning about that p ..."
Abstract
- Add to MetaCart
Distributed-system management concerns the observation of a distributed computation and then using the information gained by that observation to control the computation. This necessitates collecting the information required to determine the partial order of execution, and then reasoning about that partial order. This in turn requires a partial-order data structure and, if the reasoning is being performed by a human, a system for visualizing that partial order. Both creating such a data structure and visualizing it are hard problems. Current partial-order data structure techniques suffer various shortcomings. Potentially scalable mechanisms, such as Ore timestamps, are static. Dynamic algorithms, on the other hard, either require a significant search operation to answer basic questions, or they require a vector of size equal to the width of the partial order for each element stored in the order. Scalable visualization of a partial order is hard for the same reasons that drawing any large graph is hard. Any visualization that will be meaningful to a user requires appropriate abstractions on the data structure, while preserving the core meaning of the data structure. Such abstraction is difficult. This report formalizes these problems and identifies the specific difficulties that must be solved to enable scalable

