Results 1 
6 of
6
A framework algorithm for dynamic, centralized dimensionbounded timestamps
 In Proceedings of the 2000 CAS Conference
, 2000
"... Vector timestamps can be used to characterize causality in a distributed computation. This is essential in an observation context where we wish to reason about the partial order of execution. Unfortunately, all current dynamic vectortimestamp algorithms require a vector of size equal to the number ..."
Abstract

Cited by 12 (6 self)
 Add to MetaCart
Vector timestamps can be used to characterize causality in a distributed computation. This is essential in an observation context where we wish to reason about the partial order of execution. Unfortunately, all current dynamic vectortimestamp algorithms require a vector of size equal to the number of processes in the computation. This fundamentally limits the scalability of such observation systems. In this paper we present a framework algorithm for dynamic vector timestamps whose size can be as small as the dimension of the partial order of execution. While the dimension can be as large as the number of processes, in general it is much smaller. The algorithm consists of three interleaved phases: computing the critical pairs, creating extensions that reverse those critical pairs, and assigning vectors to each event based on the extensions created. We present complete solutions for the first two phases and a partial solution for the third phase.
EventPredicate Detection in the Debugging of Distributed Applications
, 1996
"... Trends in the development of computer hardware are making the use of distributed systems increasingly attractive. The collection of eventtrace data and the construction of processtime diagrams can provide a useful visualization tool. In practical situations, however, these diagrams are too large f ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
Trends in the development of computer hardware are making the use of distributed systems increasingly attractive. The collection of eventtrace data and the construction of processtime diagrams can provide a useful visualization tool. In practical situations, however, these diagrams are too large for users to find them comprehensible. The ability to detect and locate arbitrary (complex) predicates within an event trace can help to alleviate this problem.
Automatic Support for Understanding Complex Behaviour
 In Proceedings of the International Workshop on Network and Systems Management
, 1995
"... To facilitate reasoning about the execution of massively parallel and distributed applications and systems, researchers at the University of Waterloo are developing a visualization tool that displays behaviour using processtime diagrams. One of the research goals is the development and implementati ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
To facilitate reasoning about the execution of massively parallel and distributed applications and systems, researchers at the University of Waterloo are developing a visualization tool that displays behaviour using processtime diagrams. One of the research goals is the development and implementation of abstraction facilities to handle large numbers of processes and events. A related presentation describes one abstraction technique, grouping processes into process clusters. This paper starts with the introduction of a second abstraction technique, grouping events into abstract events. Both abstraction techniques have been implemented in the current visualization tool, supporting abstract visualizations in a topdown manner. For complex systems, however, manually forming appropriate abstractions and building complete abstraction hierarchies is infeasible. This presentation therefore outlines two tools that build multilevel abstraction hierarchies automatically. The first tool combines...
An efficient computation of convex closure on abstract events
, 2005
"... I hereby declare that I am the sole author of this thesis. This is a true copy of the thesis, including any required final revisions, as accepted by my examiners. I understand that my thesis may be made electronically available to the public. ii The behaviour of distributed applications can be model ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
I hereby declare that I am the sole author of this thesis. This is a true copy of the thesis, including any required final revisions, as accepted by my examiners. I understand that my thesis may be made electronically available to the public. ii The behaviour of distributed applications can be modeled as the occurrence of events and how these events relate to each other. Event data collected according to this event model can be visualized using processtime diagrams that are constructed from a collection of traces and events. One of the main characteristics of a distributed system is the large number of events that are involved, especially in practical situations. This large number of events, and hence large processtime diagrams, make distributedsystem observation difficult for the user. However, eventpredicate detection, a search mechanism able to detect and locate arbitrary predicates within a processtime diagram or event collection, can help the user to make sense of this large amount of data. Ping Xie used the convexabstract event concept, developed by Thomas Kunz, to search for
On the Scalability of Monitoring and Debugging Distributed Computations: VectorClock Size
"... The vectorclock size necessary to characterize causality in an arbitrary distributed computation is equal to the number of processes in that computation. However, in practice the vectorclock size necessary may be much smaller. The vectorclock size is not strictly bounded by the number of processe ..."
Abstract
 Add to MetaCart
The vectorclock size necessary to characterize causality in an arbitrary distributed computation is equal to the number of processes in that computation. However, in practice the vectorclock size necessary may be much smaller. The vectorclock size is not strictly bounded by the number of processes, but rather by the dimension of the partial order induced by the computation. While the dimension theoretically can be as large as the number of processes, in practice we have found it to be much smaller. In this paper we quantify exactly how small the dimension, and hence the vectorclock size required, is over a range of typical distributed computations. We have found that typical distributed computations, with as many as 300 processes, have dimension less than 10. In order to achieve this quantification we developed several novel theorems and algorithms which we also describe. 1
2.1 PARTIALORDER DATA STRUCTURES................................... 2 2.1.1 THE FIDGE/MATTERN TIMESTAMP................................... 4
"... Partialorder data structures used in distributedsystem observation and control tools typically use vector timestamps to efficiently determine event precedence. Unfortunately, current vectortimestamp algorithms either have a poor time/space complexity tradeoff or are static. These limitations cons ..."
Abstract
 Add to MetaCart
Partialorder data structures used in distributedsystem observation and control tools typically use vector timestamps to efficiently determine event precedence. Unfortunately, current vectortimestamp algorithms either have a poor time/space complexity tradeoff or are static. These limitations constrain the scalability of such tools. In this paper we present a series of algorithms to provide solutions for this problem. First we present algorithms for cluster timestamps for fixed clusters of processes. Then we show how to create hierarchies of such timestamps. We present results for each of these algorithms. First, we present analytic results for the cost of timestamp generation, the cost of the precedencetest algorithms, and the effectiveness in reducing timestamp size. We then present quantitative results for a series of parallel and distributed computations using various combinations of these algorithms. Our results demonstrate that these cluster timestamps can reduce space consumption by more than an orderofmagnitude while still providing acceptable timebounds for computing timestamps and