In software visualization and algorithm animation it is important that advances in system technologies are accompanied by corresponding advances in animation presentations. In this paper we describe methods for animating tree manipulation algorithms, one of the most challenging algorithm animation domains. In particular, we animate operations on pairing heap data structures which are used to implement priority queues. Our animations use tree layout heuristics and and smooth transitions for illustrating intermediate algorithm states to promote viewer understanding. This paper describes the visual techniques and methodologies used to display the pairing heap operations. The paper also details the implementation requirements and how our particular support platform, the XTango system, facilitates meeting these requirements. 1 Introduction Algorithm animations[Bro88b] visually depict how algorithms function to promote understanding of the algorithm's methodologies. Usually, the animation...

Data to be processed has dramatically increased during the last years. Nowadays, external memory (mostly hard disks) has to be used to store this massive data. Algorithms and data structures that work on external memory have different properties and specialties that distinguish them from algorithms and data structures, developed for the RAM model. In this thesis, we first explain the functionality of external memory, which is realized by disk drives. We then introduce the most important theoretical I/O models. In the main part, we present the C++ class library LEDA-SM. Library LEDA-SM is an extension of the LEDA library towards external memory computation and consists of a collection of algorithms and data structures that are designed to work efficiently in external memory. In the last two chapters, we present new external memory data structures for external memory priority queues and new external memory construction algorithms for suffix arrays. These new proposals are theoretically analyzed and experimentally tested. All proposals are implemented using the LEDA-SM library. Their efficiency is evaluated by performing a large number of experiments.

this paper we study the performance of the very first tournament based complete binary tree. We focus on discrete-event simulation and our results show that this unknown predecessor of heaps can be a more efficient alternative to the fastest pending event set implementations reported in the literature. We also extend the idea of binary tournaments to a (2; L)-tournament structure which exhibits the property of delaying the processing of events with larger timestamps whilst it keeps similar theoretical performance bounds to the native (2; 1)-structure or CBT. This property can be certainly useful in systems where many pending events are expected to be deleted or rescheduled during the simulation. 2 Tournament trees

The bulk-synchronous parallel (BSP) model of computing has been proposed to enable the development of portable software which achieves scalable performance across diverse parallel architectures. A number of applications of computing science have been demonstrated to be efficiently supported by the BSP model in practice.

We propose an acceleration scheme for real-time many-body dynamic collision detection. We kinetize the sweep and prune method for many-body collision pruning, extending its application to dynamic collision detection via kinetic data structures. In doing so, we modify the method from sample-rate driven to event-driven, with no more events than the original method processed, also removing the per-frame overhead, allowing our method to scale well in terms of frame-rates. Unlike many schemes for many-body collision pruning, ours performs well in both sparse and dense environments, with few or many collisions. Categories and Subject Descriptors (according to ACM CCS): I.3.6 [Computer Graphics]: Methodology and Techniques—Graphics data structures and data types; I.3.7 [Computer Graphics]: Three-Dimensional Graphics and Realism—Virtual reality

We present an improvement of the multi-level bucket shortest path algorithm of Denardo and Fox [9] and justify this improvement, both theoretically and experimentally. We prove that if the input arc lengths come from a natural probability distribution, the new algorithm runs in linear average time while the original algorithm does not. We also describe an implementation of the new algorithm. Our experimental data suggests that the new algorithm is preferable to the original one in practice. Furthermore, for integral arc lengths that fit into a word of today's computers, the performance is close to that of breadth-first search, suggesting limitations on further practical improvements.

The Fibonacci heap was devised to provide an especially efficient implementation of Dijkstra’s shortest path algorithm. Although asyptotically efficient, it is not as fast in practice as other heap implementations. Expanding on ideas of Høyer, we describe three heap implementations (two versions of thin heaps and one of thick heaps) that have the same amortized efficiency as Fibonacci heaps but need less space and promise better practical performance. As part of our development, we fill in a gap in Høyer’s analysis.

Pairing heaps were introduced as a self-adjusting alternative to Fibonacci heaps. They provably enjoy log n amortized costs for the standard heap operations. Although it has not been verified that pairing heaps perform the decrease key operation in constant amortized time, this has been conjectured and extensive experimental evidence supports this conjecture. Moreover, pairing heaps have been observed to be superior to Fibonacci heaps in practice. However, as demonstrated in this paper, pairing heaps do not accommodate decrease key operations in constant amortized time. 1 Introduction Pairing heaps were introduced [1] as a self-adjusting alternative to Fibonacci heaps [2]. They are easy to code and provably enjoy log n amortized costs for the standard heap operations. Although it had not been verified that pairing heaps perform the decrease key operation in constant amortized time (the raison d'etre of Fibonacci heaps), this has been conjectured [1] and extensive experimental eviden...

In this note, we report on some work in progress on using rewriting logics for discrete event simulation. The idea is to combine the proofs in the logic with the observations in the simulations to gain a better understanding of the interaction intricacies that seem to occur in complex simulations. In particular, we use communication protocols as our application domain, since they have all the interaction and unpredictability that makes formal specifications difficult. 1 Problem: Formal Methods in Simulation The historical barriers to the use of formal methods in designing and developing communication protocols derive from their different attitudes: verification models have been used for many years for proofs of behavior (a verification model cannot tell you when the model is wrong), but simulation models are used for observations of behavior (a simulation model cannot tell you when the model is right). These are almost always different models, since they must concentrate on different ...

We study the impact of using different priority queues in the performance of Dijkstra’s SSSP algorithm. We consider only general priority queues that can handle any type of keys (integer, floating point, etc.); the only exception is that we use as a benchmark the DIMACS Challenge SSSP code [1] which can handle only integer values for distances. Our experiments were focussed on the following: 1. We study the performance of two variants of Dijkstra’s algorithm: the well-known version that uses a priority queue that supports the Decrease-Key operation, and another that uses a basic priority queue that supports only Insert and Delete-Min. For the latter type of priority queue we include several for which high-performance code is available such as bottom-up binary heap, aligned 4-ary heap, and sequence heap [33]. 2. We study the performance of Dijkstra’s algorithm designed for flat memory relative to versions that try to be cache-efficient. For this, in main part, we study the difference in performance of Dijkstra’s algorithm relative to the cache-efficiency of the priority queue used, both in-core and out-of-core. We also study the performance of an implementation