Tree Traversal Research Articles

An incremental Hausdorff distance calculation algorithm

The Hausdorff distance is commonly used as a similarity measure between two point sets. Using this measure, a set X is considered similar to Y iff every point in X is close to at least one point in Y . Formally, the Hausdorff distance HausDist( X, Y ) can be computed as the Max-Min distance from X to Y , i.e., find the maximum of the distance from an element in X to its nearest neighbor (NN) in Y . Although this is similar to the closest pair and farthest pair problems, computing the Hausdorff distance is a more challenging problem since its Max-Min nature involves both maximization and minimization rather than just one or the other. A traditional approach to computing HausDist( X, Y ) performs a linear scan over X and utilizes an index to help compute the NN in Y for each x in X . We present a pair of basic solutions that avoid scanning X by applying the concept of aggregate NN search to searching for the element in X that yields the Hausdorff distance. In addition, we propose a novel method which incrementally explores the indexes of the two sets X and Y simultaneously. As an example application of our techniques, we use the Hausdorff distance as a measure of similarity between two trajectories (represented as point sets). We also use this example application to compare the performance of our proposed method with the traditional approach and the basic solutions. Experimental results show that our proposed method outperforms all competitors by one order of magnitude in terms of the tree traversal cost and total response time.

Efficient camera path planning algorithm for human motion overview

AbstractCamera path planning for character motions is a fundamental and important research topic, benefiting many animation applications. Existing optimal‐based approaches are generally computationally expensive and infeasible for interactive applications. In this paper, we propose an efficient approach that can take many constraints of finding the camera path into account and can potentially enable interactive camera control. Instead of solving a highly complicated camera optimization problem in a spatiotemporal four‐dimensional space, we heuristically determine the camera path based on an efficient greedy‐based tree traversal approach. The experimental results show that the proposed approach can efficiently generate a smooth, informative, and aesthetic camera path that can reveal the significant features of character motions. Moreover, the conducted user study also shows that the generated camera paths are comparable to those of a state‐of‐the‐art approach and those made by professional animators. Copyright © 2011 John Wiley & Sons, Ltd.

Implementation of a parallel tree method on a GPU

AbstractThe kd-tree is a fundamental tool in computer science. Among other applications, the application of kd-tree search (by the tree method) to the fast evaluation of particle interactions and neighbor search is highly important, since the computational complexity of these problems is reduced from O(N2) for a brute force method to O(NlogN) for the tree method, where N is the number of particles. In this paper, we present a parallel implementation of the tree method running on a graphics processing unit (GPU). We present a detailed description of how we have implemented the tree method on a Cypress GPU. An optimization that we found important is localized particle ordering to effectively utilize cache memory. We present a number of test results and performance measurements. Our results show that the execution of the tree traversal in a force calculation on a GPU is practical and efficient.

Genus Distributions of Cubic Outerplanar Graphs

We present a quadratic-time algorithm for computing the genus distribution of any 3-regular outerplanar graph. Although recursions and some formulas for genus distributions have previously been calculated for bouquets and for various kinds of ladders and other special families of graphs, cubic outerplanar graphs now emerge as the most general family of graphs whose genus distributions are known to be computable in polynomial time. The key algorithmic features are the syntheses of the given outerplanar graph by a sequence of edge-amalgamations of some of its subgraphs, in the order corresponding to the post-order traversal of a plane tree that we call the inner tree, and the coordination of that synthesis with just-in-time root-splitting.

Minimum average congestion of enhanced and augmented hypercubes into complete binary trees

We study the embedding problem of enhanced and augmented hypercubes into complete binary trees. Using tree traversal techniques, we compute the minimum average edge congestion of enhanced and augmented hypercubes into complete binary trees.

Dynamic Simulation of Large-Scale Power Systems Using a Two-Level Computation Tree Model

A new tree structure called the two-level computation tree model is proposed for real time dynamic simulation of large-scale power systems. The features of the computation tree method are that the root node of the tree corresponds to a disconnected linear network, which is easy to be dealt with, and the tree leaf-nodes represent the partitioned subsystems. In the process of trajectory simulation, the correction factors of Newton type iteration are computed through a tree traversal procedure. One advantage of the new method is that the computation tasks for all subsystems can be carried out simultaneously using any parallel computation facilities. Case studies on the 10-generator New England test power system and on a representation of Northeast China power system verify the accuracy and validate the potential application of the proposed method in the real time contingency simulation for realistic large-scale power system.

ITBI: Labeling scheme for XML data update

Labeling scheme is the basis for Extensible Markup Language ( XML) query processing. The traditional labeling schemes use numbers based on natural order, which is hard to support XML updating. A new labeling scheme, called ITBI ( Inorder Traversal Based Integer) , was proposed. ITBI created a mapping between integer and complete binary tree, and a new partial order based on inorder traversal of binary tree was defined, which just needed reordering the natural numbers to support dynamic XML. Meanwhile, based on the conceptions of previous ITBI, next ITBI, ITBI distance, the algorithm for assigning dynamic labels with the smallest size was presented, which controlled the increase in label size efficiently. The experimental results verify the validity of the proposed method.

Balancing of AVL tree using virtual node

AVL tree is the first dynamic tree in data structure which minimizes its height during insertion and deletion operations. This is because searching time is directly proportional to the height of binary search tree (BST) [1-9].When insertion operation is performed it may result into increasing the height of the tree and when deletion is performed it may result into decreasing the height. To make the BST a height balance tree (AVL tree) creators of the AVL tree proposed various rotations. This paper proposes the balancing of the AVL tree using the concept of virtual node. This virtual node is a hypothetical node which is inserted into the inorder traversal of the BST and by doing the inorder traversal (left, root, right) we make a BST. Ultimately this virtual node is deleted to get an AVL tree.

Dynamic Interpretation Method of XML Configuration Strategy for IP Mode Measurement and Control System

The interoperability among diversified ubiquitous sensor network platforms can be solved well by employing XML technology. According to the requirement that implementing accurately remote XML configuration strategy for spot equipments, a new dynamic interpretation method of XML configuration strategy is proposed. First, an XML-based IP mode measurement & control system is introduced. On the basis of realizing graphical strategy editor, the innovative ways and technologies of some key problems for dynamic interpretation method were especially discussed in this paper, including configuration strategy conversion combining preorder binary tree traversal with stack, XML strategy decomposition based on DOM tree model and dynamical update of XML configuration strategy. Finally, an application example in IP mode ethanol concentration measurement & control system is introduced. Experimental results show that the new method can greatly simplify conversion from measurement & control strategy to microinstructions, which saves system resources and improves greatly the speed of interpretation.

Space-and-Time Efficient Parallel Garbage Collector for Data-Intensive Applications

As multithreaded server applications and runtime systems prevail, garbage collection is becoming an essential feature to support high performance systems, especially those running data-intensive applications. The fundamental issue of garbage collector (GC) design is to maximize the recycled space with minimal time overhead. This paper proposes two innovative solutions: one to improve space efficiency, and the other to improve time efficiency. To achieve space efficiency, we propose the Space Tuner that utilizes the novel concept of allocation speed to reduce wasted space. Conventional static space partitioning techniques often lead to inefficient space utilization. The Space Tuner adjusts the heap partitioning dynamically such that when a collection is triggered, all space partitions are fully filled. To achieve time efficiency, we propose a novel parallelization method that reduces the compacting GC parallelization problem into a tree traversal parallelization problem. This method can be applied for both normal and large object compaction. Object compaction is hard to parallelize due to strong data dependencies such that the source object can not be moved to its target location until the object originally in the target location has been moved out. Our proposed algorithm overcomes the difficulties by dividing the heap into equal-sized blocks and parallelizing the movement of the independent blocks. It is noteworthy that these proposed algorithms are generic such that they can be utilized in different GC designs. The proposed techniques have been implemented in Apache Harmony JVM and we evaluated the proposed algorithms with SPECjbb and Dacapo benchmark suites. The experiment results demonstrate that our proposed algorithms greatly improve space utilization and the corresponding parallelization schemes are scalable, which brings time efficiency.

Maximum error modeling for fault-tolerant computation using maximum a posteriori (MAP) hypothesis

The application of current generation computing machines in safety-centric applications like implantable biomedical chips and automobile safety has immensely increased the need for reviewing the worst-case error behavior of computing devices for fault-tolerant computation. In this work, we propose an exact probabilistic error model that can compute the maximum error over all possible input space in a circuit-specific manner and can handle various types of structural dependencies in the circuit. We also provide the worst-case input vector, which has the highest probability to generate an erroneous output, for any given logic circuit. We also present a study of circuit-specific error bounds for fault-tolerant computation in heterogeneous circuits using the maximum error computed for each circuit. We model the error estimation problem as a maximum a posteriori (MAP) estimate [28,29], over the joint error probability function of the entire circuit, calculated efficiently through an intelligent search of the entire input space using probabilistic traversal of a binary Join tree using Shenoy–Shafer algorithm [20,21]. We demonstrate this model using MCNC and ISCAS benchmark circuits and validate it using an equivalent HSpice model. Both results yield the same worst-case input vectors and the highest percentage difference of our error model over HSpice is just 1.23%. We observe that the maximum error probabilities are significantly larger than the average error probabilities, and provides a much tighter error bounds for fault-tolerant computation. We also find that the error estimates depend on the specific circuit structure and the maximum error probabilities are sensitive to the individual gate failure probabilities.

An in-place search algorithm for the resource constrained scheduling problem during high-level synthesis

We propose an in-place search algorithm for computing the exact solutions to the resource constrained scheduling problem. This algorithm supports operation chaining, pipelining and multicycling in the underlying scheduling problem. Based on two lower-bound estimation mechanisms that are capable of predicting the criterion values of search nodes represented by partially scheduled data flow graphs, the proposed algorithm can effectively prune the nonpromising search space and finds the optimum usually several times faster than existing techniques. As opposed to existing search-based scheduling techniques whose space complexity is squared or exponential in the search depth, our approach requires only a constant storage space during the traversal of the search tree. The low space complexity is accomplished by using a combination-generating algorithm, which leads our approach to visit search nodes in such a way that each one is obtained by making only a small change to its sibling without keeping any parent nodes in memory. Experimental results on several well known benchmarks with varying resource constraints show the effectiveness of the proposed algorithm.

EffiCuts

Packet Classification is a key functionality provided by modern routers. Previous decision-tree algorithms, HiCuts and HyperCuts, cut the multi-dimensional rule space to separate a classifier's rules. Despite their optimizations, the algorithms incur considerable memory overhead due to two issues: (1) Many rules in a classifier overlap and the overlapping rules vary vastly in size, causing the algorithms' fine cuts for separating the small rules to replicate the large rules. (2) Because a classifier's rule-space density varies significantly, the algorithms' equi-sized cuts for separating the dense parts needlessly partition the sparse parts, resulting in many ineffectual nodes that hold only a few rules. We propose EffiCuts which employs four novel ideas: (1) Separable trees: To eliminate overlap among small and large rules, we separate all small and large rules. We define a subset of rules to be separable if all the rules are either small or large in each dimension. We build a distinct tree for each such subset where each dimension can be cut coarsely to separate the large rules, or finely to separate the small rules without incurring replication. (2) Selective tree merging: To reduce the multiple trees' extra accesses which degrade throughput, we selectively merge separable trees mixing rules that may be small or large in at most one dimension. (3) Equi-dense cuts: We employ unequal cuts which distribute a node's rules evenly among the children, avoiding ineffectual nodes at the cost of a small processing overhead in the tree traversal. (4) Node Co-location: To achieve fewer accesses per node than HiCuts and HyperCuts, we co-locate parts of a node and its children. Using ClassBench, we show that for similar throughput EffiCuts needs factors of 57 less memory than HyperCuts and of 4-8 less power than TCAM.

FTTP: A Fast Tree Traversal Protocol for Efficient Tag Identification in RFID Networks

This letter presents an efficient tag collision arbitration protocol, viz., the Fast Tree Traversal Protocol (FTTP). It estimates the number of tags using maximum likelihood estimation and adjusts the splitting factor to reduce the identification delay. We show that our protocol effectively reduces the identification delay via the performance analysis and simulation results.

Star-contours for efficient hierarchical self-collision detection

Collision detection is a problem that has often been addressed efficiently with the use of hierarchical culling data structures. In the subproblem of self-collision detection for triangle meshes, however, such hierarchical data structures lose much of their power, because triangles adjacent to each other cannot be distinguished from actually colliding ones unless individually tested. Shape regularity of surface patches, described in terms of orientation and contour conditions, was proposed long ago as a culling criterion for hierarchical self-collision detection. However, to date, algorithms based on shape regularity had to trade conservativeness for efficiency, because there was no known algorithm for efficiently performing 2D contour self-intersection tests. In this paper, we introduce a star-contour criterion that is amenable to hierarchical computations. Together with a thorough analysis of the tree traversal process in hierarchical self-collision detection, it has led us to novel hierarchical data structures and algorithms for efficient yet conservative self-collision detection. We demonstrate the application of our algorithm to several example animations, and we show that it consistently outperforms other approaches.

Random binary search tree with equal elements

We consider random binary search trees when the input consists of a multiset, i.e. a set with multiple occurrences of equal elements, and prove that the randomized insertion and deletion algorithms given by Martínez and Roura (1998) [4] produce random search trees regardless of multiplicities; even if all the elements are equal during the tree updates, a search tree will maintain its randomness. Thus, equal elements do not degenerate a random search tree and they need not to be handled in any special way. We consider also stability of a search tree with respect to its inorder traversal and prove that the algorithms used produce stable trees. This implies an implicit indexing of equal elements giving another proof that multiplicities do not pose problems when maintaining random binary search trees.

New efficient breadth-first/level traversal tree search method for the design and upgrade of sensor networks

This work studies the problem of optimally locating sensors for monitoring chemical processes, formally known as the sensor network design and upgrade problem. This problem is an integer programming problem and has been solved to global optimality only using tree search methods using depth-first strategy. In this article, we exploit certain cost properties of the different nodes in the tree to efficiently prune nonoptimal nodes using a breadth-first/level traversal tree search method to obtain the global optimum. We show that this strategy allows cutting considerably the computational time for problems that the depth-first strategy was inefficient. V C 2010 American Institute of Chemical Engineers AIChE J, 57: 1302–1309, 2011

Optimized algorithms for predictive range and KNN queries on moving objects

There have been many studies on management of moving objects recently. Most of them try to optimize the performance of predictive window queries. However, not much attention is paid to two other important query types: the predictive range query and the predictive k nearest neighbor query. In this article, we focus on these two types of queries. The novelty of our work mainly lies in the introduction of the Transformed Minkowski Sum, which can be used to determine whether a moving bounding rectangle intersects a moving circular query region. This enables us to use the traditional tree traversal algorithms to perform range and kNN searches. We theoretically show that our algorithms based on the Transformed Minkowski Sum are optimal in terms of the number of tree node accesses. We also experimentally verify the effectiveness of our technique and show that our algorithms outperform alternative approaches.

Complexity-efficient enumeration techniques for soft-input, soft-output sphere decoding

In this paper two complexity efficient soft sphere-decoder modifications are proposed for computing the max-log LLR values in iterative MIMO systems, which avoid the costly, typically needed, full enumeration and sorting (FES) procedure during the tree traversal without compromising the max-log performance. It is shown that despite the resulting increase in the number of expanded nodes, they can be more computationally efficient than the typical soft sphere decoders by avoiding the unnecessary complexity of FES.

An empirical study of cache-oblivious polygon indecomposability testing

We implement and undertake an empirical study of the cache-oblivious variant of the polygon indecomposability testing algorithm of Gao and Lauder, based on a depth-first search (DFS) traversal of the computation tree. According to Abu Salem, the cache-oblivious variant exhibits improved spatial and temporal locality over the original one, and its spatial locality is optimal. Our implementation revolves around eight different variants of the DFS-based algorithm, tailored to assess the trade-offs between computation and memory performance as originally proposed by Abu Salem. We analyse performance sensitively to manipulations of the several parameters comprising the input size. We describe how to construct suitably random families of input that solicit such variations, and how to handle redundancies in vector computations at no asymptotic increase in the work and cache complexities. We report extensively on our experimental results. In all eight variants, the DFS-based variant achieves excellent performance in terms of L1 and L2 cache misses as well as total run time, when compared to the original variant of Gao and Lauder. We also benchmark the DFS variant against the powerful computer algebra system MAGMA, in the context of bivariate polynomial irreducibility testing using polygons. For sufficiently high degree polynomials, MAGMA either runs out of memory or fails to terminate after about 4 h of execution. In contrast, the DFS-based version processes such input using a couple of seconds. Particularly, we report on absolute irreducibility testing of bivariate polynomials of total degree reaching 19,000 in about 2 s for the DFS variant, using a single processor.