Tree Traversal Research Articles

Work-efficient parallel skyline computation for the GPU

The skyline operator returns records in a dataset that provide optimal trade-offs of multiple dimensions. State-of-the-art skyline computation involves complex tree traversals, data-ordering, and conditional branching to minimize the number of point-to-point comparisons. Meanwhile, GPGPU computing offers the potential for parallelizing skyline computation across thousands of cores. However, attempts to port skyline algorithms to the GPU have prioritized throughput and failed to outperform sequential algorithms. In this paper, we introduce a new skyline algorithm, designed for the GPU, that uses a global, static partitioning scheme. With the partitioning, we can permit controlled branching to exploit transitive relationships and avoid most point-to-point comparisons. The result is a non-traditional GPU algorithm, SkyAlign, that prioritizes work-efficiency and respectable throughput, rather than maximal throughput, to achieve orders of magnitude faster performance.

Classifying tree structures using elastic matching of sequence encodings

Structures of tree topology are frequently encountered in nature and in a range of scientific domains. In this paper, a multi-step framework is presented to classify tree topologies introducing the idea of elastic matching of their sequence encodings. Initially, representative sequences of the branching topologies are obtained using node labeling and tree traversal schemes. The similarity between tree topologies is then quantified by applying elastic matching techniques. The resulting sequence alignment reveals corresponding node groups providing a better understanding of matching tree topologies. The new similarity approach is explored using various classification algorithms and is applied to a medical dataset outperforming state-of-the-art techniques by at least 6.6% and 3.5% in terms of absolute specificity and accuracy correspondingly.

The Effective Pathfinding Algorithm for Gaming Maps Using Systemized Iterative Deepening A

A * algorithm is the de facto standard used for a pathfinding search. IDA* is a space-efficient version of A * , but it suffers from CPU cycles in the search space (the price for using no storage), repeatedly visiting nodes from left to- right traversal of the search tree. To overcome these concerns, recently fringe search algorithm is launched. At some extent, fringe search algorithm performs iterations same as A * and IDA * , but still the fringe search algorithm has some drawbacks, visiting nodes that are irrelevant for the current iteration. In this paper, Systemized Iterative Deepening A * (SIDA * ) introduced to eliminate in-efficiencies such as, search space, visiting irrelevant nodes. It also detects dead ends and reachs the destination node faster than the existing pathfinding algorithms. We considered on-track strategy for accidental obstacles, in addition we include curvature information to avoid off road in static curves. Finally our experiment results performed on grid based pathfinding application between SIDA * and A * . We executed on two different platforms with and without obstacles (walls), in both different platforms SIDA * achieve 15-35% (i.e., time, length, weight, operation) faster than A * search algorithm. Evaluation results of proposed framework, On-track strategy shows effective for avoiding obstacles on static curves.

Fast Sparse Selected Inversion

We propose a fast structured selected inversion method for extracting the diagonal blocks of the inverse of a sparse symmetric matrix $A$, using the multifrontal method and rank structures. When $A$ arises from the discretization of some PDEs and has a low-rank property (the intermediate dense matrices in the factorization have small off-diagonal numerical ranks), structured approximations of the diagonal blocks and certain off-diagonal blocks of $A^{-1}$ (that are needed to find the diagonal blocks of $A^{-1}$) can be quickly computed. A structured multifrontal LDL factorization is first computed for $A$ with a forward traversal of an assembly tree, which yields a sequence of local data-sparse factors. The factors are used in a backward traversal of the tree for the structured inversion. The intermediate operations in the inversion are performed in hierarchically semiseparable or low-rank forms. With the assumptions of data sparsity and appropriate rank conditions, the theoretical structured inversion co...

A Parallel Sparse Direct Solver via Hierarchical DAG Scheduling

We present a parallel sparse direct solver for multicore architectures based on Directed Acyclic Graph (DAG) scheduling. Recently, DAG scheduling has become popular in advanced Dense Linear Algebra libraries due to its efficient asynchronous parallel execution of tasks. However, its application to sparse matrix problems is more challenging as it has to deal with an enormous number of highly irregular tasks. This typically results in substantial scheduling overhead both in time and space, which causes overall parallel performance to be suboptimal. We describe a parallel solver based on two-level task parallelism: tasks are first generated from a parallel tree traversal on the assembly tree; next, those tasks are further refined by using algorithms - by - blocks to gain fine-grained parallelism. The resulting fine-grained tasks are asynchronously executed after their dependencies are analyzed. Our approach is distinct from others in that we adopt two-level task scheduling to mirror the two-level parallelism. As a result, we reduce scheduling overhead, and increase efficiency and flexibility. The proposed parallel sparse direct solver is evaluated for the particular problems arising from the hp -Finite Element Method where conventional sparse direct solvers do not scale well.

Memory-aware tree traversals with pre-assigned tasks

We study the complexity of traversing tree-shaped workflows whose tasks require large I/O files. We target a heterogeneous architecture with two resource types, each with a different memory, such as a multicore node equipped with a dedicated accelerator (FPGA or GPU). The tasks in the workflow are colored according to their type and can be processed if all their input and output files can be stored in the corresponding memory. The amount of used memory of each type at a given execution step strongly depends upon the ordering in which the tasks are executed, and upon when communications between both memories are scheduled. The objective is to determine an efficient traversal that minimizes the maximum amount of memory of each type needed to traverse the whole tree. In this paper, we establish the complexity of this two-memory scheduling problem, and provide inapproximability results. In addition, we design several heuristics, based on both post-order and general traversals, and we evaluate them on a comprehensive set of tree graphs, including random trees as well as assembly trees arising in the context of sparse matrix factorizations.

An efficient transient analysis method for linear time-varying structures based on multi-level substructuring method

In this paper, the Newmark-beta method for linear time-varying (LTV) structures is firstly derived, then a transient analysis method for LTV structures based on multi-level substructuring method is presented. In theory the proposed method could achieve the same precision as the overall structure analysis method, the computational accuracy is not influenced by substructure partition strategy. The proposed method has higher computational efficiency than overall structure analysis method. Furthermore, the partial substructure tree traversal strategy can further improve the computational efficiency without any loss of accuracy. Some numerical examples are given to illustrate the effectiveness and feasibility of the proposed methods.

Class mutation operators for C++ object-oriented systems

Mutation testing is a fault injection testing technique around which a great variety of studies and tools for different programming languages have been developed. Nevertheless, the mutation testing research with respect to C++ is pending. This paper proposes a set of class mutation operators related to this language and its particular object-oriented (OO) features. In addition, an implementation technique to apply mutation testing based on the traversal of the abstract syntax tree (AST) is presented. Finally, an experiment is conducted to study the operator behaviour with different C++ programs, suggesting their usefulness in the creation of complete test suites. The analysis includes a Web service (WS) library, one of the domains where this technique can prove useful, considering its challenging testing phase and that C++ is still a reference language for critical distributed systems WS.

Suffix tree searcher: exploration of common substrings in large DNA sequence sets.

BackgroundLarge DNA sequence data sets require special bioinformatics tools to search and compare them. Such tools should be easy to use so that the data can be easily accessed by a wide array of researchers. In the past, the use of suffix trees for searching DNA sequences has been limited by a practical need to keep the trees in RAM. Newer algorithms solve this problem by using disk-based approaches. However, none of the fastest suffix tree algorithms have been implemented with a graphical user interface, preventing their incorporation into a feasible laboratory workflow.ResultsSuffix Tree Searcher (STS) is designed as an easy-to-use tool to index, search, and analyze very large DNA sequence datasets. The program accommodates very large numbers of very large sequences, with aggregate size reaching tens of billions of nucleotides. The program makes use of pre-sorted persistent "building blocks" to reduce the time required to construct new trees. STS is comprised of a graphical user interface written in Java, and four C modules. All components are automatically downloaded when a web link is clicked. The underlying suffix tree data structure permits extremely fast searching for specific nucleotide strings, with wild cards or mismatches allowed. Complete tree traversals for detecting common substrings are also very fast. The graphical user interface allows the user to transition seamlessly between building, traversing, and searching the dataset.ConclusionsThus, STS provides a new resource for the detection of substrings common to multiple DNA sequences or within a single sequence, for truly huge data sets. The re-searching of sequence hits, allowing wild card positions or mismatched nucleotides, together with the ability to rapidly retrieve large numbers of sequence hits from the DNA sequence files, provides the user with an efficient method of evaluating the similarity between nucleotide sequences by multiple alignment or use of Logos. The ability to re-use existing suffix tree pieces considerably shortens index generation time. The graphical user interface enables quick mastery of the analysis functions, easy access to the generated data, and seamless workflow integration.

First-order unification in the PVS proof assistant

This work presents formalizations of properties and algorithms for the first-order unification theory in the proof assistant PVS. In previous works a formalization of the theorem of existence of most general unifiers (mgu's) for first-order unifiable problems was presented and then, it was illustrated how the formalizations of correctness and completeness used for the proof of the theorem of existence, can be adapted in order to verify greedy unification algorithms 'a la Robinson. The distinguishing feature of these two formalizations is that they remain close to the textbook proofs which was possible through the use of the higher-order specification language and proof engine of PVS. That work consists of two elaborated PVS theories having been the one related with the theorem of existence of mgu's applied for obtaining a full formalization of the Knuth-Bendix(Huet) critical pair theorem. In addition to these two developments, this work describes a formalization of the correction and completeness of a more elaborated first-order unification algorithm. In contrast with the greedy algorithm, the current one is more efficient. It navigates in a post-order traversal the tree structure of the two terms being unified in such a way that after the difference at the first position of conflict (found in inner-most, left-most order) between the terms is eliminated through a linkage substitution (mapping a variable into a term), the search of the following position of conflict is computed through application of auxiliary functions starting from the previous position. Unlike this more efficient traversal, the greedy unification algorithm always restarts the search of conflicts from the root of the terms being unified. The new formalization gave rise to a more elaborated PVS development in which unlike a relatively straightforward application of correctness and completeness formalizations of the theorem of existence of mgu's, it was necessary the formalization of a series of structural auxiliary lemmas to deal with formalization of properties of the tree data structure used to represent terms.

Internal‐to‐internal transition method for consecutive hierarchical template matching

This study proposes a method reducing the tree traversal cost by first investigating the most probable node instead of the root node when a hierarchical template matching is consecutively applied to the object. In particular, this study gives a novel viewpoint that a consecutive hierarchical template matching could be regarded as a transition of a hierarchical finite state machine, and then it proposes a novel method considering the transitions between the internal nodes of the hierarchical template tree. The proposed method is verified by applying it to pedestrian silhouette detection.

Using educational games and simulation software in a computer science course: learning achievements and student flow experiences

This study investigates how educational games impact on students' academic performance and multimedia flow experiences in a computer science course. A curriculum consists of five basic learning units, that is, the stack, queue, sort, tree traversal, and binary search tree, was conducted for 110 university students during one semester. Two groups of students participated in learning activities: the experimental group was instructed using the gaming method; and the control group was instructed using the non-gaming method. During the study, tests, a survey, and interviews were conducted with students. The evaluation results for academic performance and multimedia flow experiences show that compared to the non-gaming method, incorporating the gaming method into the learning process can enhance students' academic performance and multimedia flow experiences. The results also indicated that there is a non-significant and positive relationship between students' academic performance and multimedia flow experiences.

Merkle tree‐based wormhole attack avoidance mechanism in low power and lossy network based networks

ABSTRACTSmart metering application has received a lot of attention from the research community lately. Usually, low power and lossy network runs on routing protocol for low power and lossy networks protocol, which constructs a directed acyclic graph structure for its normal operation. In this paper, we devise a wormhole attack scenario in such a network. Furthermore, we propose a Merkle tree‐based authentication mechanism, which runs on the notion of constructing a tree of hashed security information. We analyze the approach by formulating the wormhole attack scenario as a graph theoretic problem and show the effectiveness of the proposed Merkle tree‐based approach for authenticating communications. Furthermore, we perform simulations in network simulator 2 to observe the network performance by adopting a Merkle tree‐based approach to prevent from disrupting the links, and we observe better throughput, reduction in jitter, and end‐to‐end delay as compared with scenarios with wormhole attacks and no avoidance mechanism. In the end, we take a step toward optimizing the performance of the mechanism by proposing an effective tree traversal algorithm, which works on the notion of electing nodes as a root in a large scale network from where a Merkle tree will be originated. The mechanism with the traversal algorithm assists in managing the authentication in a huge network, which is broken down into many trees avoiding wormhole attacks in the network. Copyright © 2014 John Wiley & Sons, Ltd.

A Tree-Based Contrast Set-Mining Approach to Detecting Group Differences

Understanding differences between groups in a data set is one of the fundamental tasks in data analysis. As relevant applications accumulate, data-mining methods have been developed to specifically address the problem of group difference detection. Contrast set mining discovers group differences in the form of conjunction of feature-value pairs or items. In this paper, we incorporate absolute difference, relative difference, and statistical significance in our definition of a group difference, and develop a novel method named DIFF that uses the prefix-tree structure to compress the search space, follows a tree traversal procedure to discover the complete set of significant group differences, and employs efficient pruning strategies to expedite the search process. We conducted comprehensive experiments to compare our method with existing methods on completeness of results, pruning efficiency, and computational efficiency. The experiments demonstrate that our method guarantees completeness of results and achieves higher pruning efficiency and computational efficiency compared to STUCCO. In addition, our definition of group difference is more general than STUCCO. Our method is more effective than traditional approaches, such as classification trees, in discovering the complete set of significant group differences.

Memory Cutback for FP-Tree Approach

The pattern growth approach of association rule mining is very efficient as avoiding the candidate generation step which was utilized in Apriori algorithm. Here, revisited of the pattern growth approaches are done to improve the performance using different criteria like item search order, conditional database representation and construction approach and tree traversal ways. The header table construction is the first part in almost all the approaches having constant number of dataset items. This research is representing the reduction in overall memory requirement of pattern growth approach by reducing the search space and processor operations time at the header table generation. It is proposed to achieve the memory cutback by only considering the items that are going to be frequent and ignoring the infrequent items at early stage of scan, by considering the boundary. Experimental analysis achieves cutback in memory consumption in the proposed approach Modified FP-Growth (MFP-Growth) compare to FP-Growth and CFP-Growth.

Finite-difference lattice Boltzmann method with a block-structured adaptive-mesh-refinement technique

An adaptive-mesh-refinement (AMR) algorithm for the finite-difference lattice Boltzmann method (FDLBM) is presented in this study. The idea behind the proposed AMR is to remove the need for a tree-type data structure. Instead, pointer attributes are used to determine the neighbors of a certain block via appropriate adjustment of its children identifications. As a result, the memory and time required for tree traversal are completely eliminated, leaving us with an efficient algorithm that is easier to implement and use on parallel machines. To allow different mesh sizes at separate parts of the computational domain, the Eulerian formulation of the streaming process is invoked. As a result, there is no need for rescaling the distribution functions or using a temporal interpolation at the fine-coarse grid boundaries. The accuracy and efficiency of the proposed FDLBM AMR are extensively assessed by investigating a variety of vorticity-dominated flow fields, including Taylor-Green vortex flow, lid-driven cavity flow, thin shear layer flow, and the flow past a square cylinder.

GPU 기반의 묶음 LOD 기법을 이용한 지형 렌더링의 가속화 기법

대용량 지형 데이터는 최신 그래픽 하드웨어를 사용해도 실시간으로 표현하기가 어렵다. 일반적으로 이런 대용량 지형 데이터를 실시간에 처리하기 위해 연속 상세 단계 기법 같은 메쉬 간략화 기법이 사용된다. 하지만 기하 분할(geometry splitting)과 같이 기존의 GPU기반 사진트리를 사용하는 기법은 트리의 깊이가 깊어질수록 많은 정점을 사용하고 이를 다시 재전송하기 때문에 성능이 저하되며 텍스처를 이용해 트리를 구성하기 때문에 트리의 용량이 커지는 단점이 있다. 이런 단점을 해결하기 위해 본 논문에서는 사진트리 기반의 묶음(chunk)으로 구성된 상세 단계 선별 기법을 GPU에서 처리하는 실시간 지형 렌더링 기법을 제안한다. 제안하는 방법은 기하 분할 기법의 단점을 해결하기 위해 트리 탐색을 제한하고 테셀레이터(tessellator)에서 묶음을 생성한 후 렌더링함으로써 트리 탐색을 줄이고 묶음을 GPU에서 바로 생성할 수 있어 효율적으로 지형을 렌더링할 수 있다. It is hard to represent massive terrain data in real-time even using recent graphics hardware. In order to process massive terrain data, mesh simplification method such as continuous Level-of-Detail is commonly used. However, existing GPU-based methods using quad-tree structure such as geometry splitting, produce lots of vertices to traverse the quad-tree and retransmit those vertices back to the GPU in each tree traversal. Also they have disadvantage of increase of tree size since they construct the tree structure using texture. To solve the problem, we proposed GPU-base chunked LOD technique for real-time terrain rendering. We restrict depth of tree search and generate chunks with tessellator in GPU. By using our method, we can efficiently render the terrain by generating the chunks on GPU and reduce the computing time for tree traversal.

An Energy and Performance Efficient DVFS Scheme for Irregular Parallel Divide-and-Conquer Algorithms on the Intel SCC

The divide-and-conquer paradigm can be used to express many computationally significant problems, but an important subset of these applications is inherently load-imbalanced. Load balancing is a challenge for irregular parallel divide-and-conquer algorithms and efficiently solving these applications will be a key requirement for future many-core systems. To address the load imbalance issue, instead of attempting to dynamically balancing the workloads, this paper proposes an energy and performance efficient Dynamic Voltage and Frequency Scaling (DVFS) scheduling scheme, which takes into account the load imbalance behavior exhibited by these applications. More specifically, we examine the core of the divide-and-conquer paradigm and determine that the base-case-reached point where recursion stops is a suitable place in a divide-and-conquer paradigm to apply the proposed DVFS scheme. To evaluate the proposed scheme, we implement four representative irregular parallel divide-and-conquer algorithms, tree traversal, quicksort, finding primes, and n-queens puzzle, on the Intel Single-chip Cloud Computer (SCC) many-core machine. We demonstrate that, on average, the proposed scheme can improve performance by 41% while reducing energy consumption by 36% compared to the baseline running the whole computation with the default frequency configuration (400MHz).

Ffsck

Failures, errors, and bugs can corrupt file systems and cause data loss, despite the presence of journals and similar preventive techniques. While consistency checkers such as fsck can detect corruption and repair a damaged image, they are generally created as an afterthought, to be run only at rare intervals. Thus, checkers operate slowly, causing significant downtime for large scale storage systems. We address this dilemma by treating the checker as a key component of the overall file system, rather than a peripheral add-on. To this end, we present a modified ext3 file system, rext 3, to directly support the fast file-system checker, ffsck . Rext3 colocates and self-identifies its metadata blocks, removing the need for costly seeks and tree traversals during checking. These modifications allow ffsck to scan and repair the file system at rates approaching the full sequential bandwidth of the underlying device. In addition, we demonstrate that rext3 generally performs competitively with ext3 and exceeds it in handling random reads and large writes. Finally, we apply our principles to FreeBSD’s FFS file system and its checker, doing so in a lightweight fashion that preserves the file-system layout while still providing some of the performance gains from ffsck.

Log-concavity of the genus polynomials for a sequence of cubic Halin graphs

Log-concavity of the genus polynomials for a sequence of cubic Halin graphs