Tree Traversal Research Articles

Synchronized tracing of primitive-based implicit volumes

Implicit volumes are known for their ability to represent smooth shapes of arbitrary topology thanks to hierarchical combinations of primitives using a structure called a blobtree. We present a new tile-based rendering pipeline well suited for modeling scenarios, i.e., no preprocessing is required when primitive parameters are updated. When using approximate signed distance fields (fields with Lipschitz bound close to 1), we rely on compact, smooth CSG operators - extended from standard bounded operators - to compute a tight augmented bounding volume for all primitives of the blobtree. The pipeline relies on a low-resolution A-buffer storing the primitives of interest of a given screen tile. The A-buffer is then used during ray processing to synchronize threads within a subfrustum. This allows coherent field evaluation within workgroups. We use a sparse bottom-up tree traversal to prune the blobtree on-the-fly which allows us to decorrelate field evaluation complexity from the full blobtree size. The ray processing itself is done using the sphere tracing algorithm. The pipeline scales well to volumes consisting of thousands of primitives.

Energy Constrained Depth First Search

AbstractDepth first search is a natural algorithmic technique for constructing a closed route that visits all vertices of a graph. The length of such a route equals, in an edge-weighted tree, twice the total weight of all edges of the tree and this is asymptotically optimal over all exploration strategies. This paper considers a variant of such search strategies where the length of each route is bounded by a positive integer B (e.g. due to limited energy resources of the searcher). The objective is to cover all the edges of a tree T using the minimum number of routes, each starting and ending at the root and each being of length at most B. To this end, we analyze the following natural greedy tree traversal process that is based on decomposing a depth first search traversal into a sequence of limited length routes. Given any arbitrary depth first search traversal R of the tree T, we cover R with routes $$R_1,\ldots ,R_l$$ R 1 , … , R l , each of length at most B such that: $$R_i$$ R i starts at the root, reaches directly the farthest point of R visited by $$R_{i-1}$$ R i - 1 , then $$R_i$$ R i continues along the path R as far as possible, and finally $$R_i$$ R i returns to the root. We call the above algorithm piecemeal-DFS and we prove that it achieves the asymptotically minimal number of routes l, regardless of the choice of R. Our analysis also shows that the total length of the traversal (and thus the traversal time) of piecemeal-DFS is asymptotically minimum over all energy-constrained exploration strategies. The fact that R can be chosen arbitrarily means that the exploration strategy can be constructed in an online fashion when the input tree T is not known in advance. Each route $$R_i$$ R i can be constructed without any knowledge of the yet unvisited part of T. Surprisingly, our results show that depth first search is efficient for energy constrained exploration of trees, even though it is known that the same does not hold for energy constrained exploration of arbitrary graphs.

Redzone stream compaction: removing k items from a list in parallel O(k) time

Stream compaction, the parallel removal of selected items from a list, is a fundamental building block in parallel algorithms. It is extensively used, both in computer graphics, for shading, collision detection, and ray tracing, as well as in general computing, such as for tree traversal and database selection. In this article, we present Redzone stream compaction, the first parallel stream compaction algorithm to remove k items from a list with n ≥ k elements in O(k) rather than O(n) time. Based on our benchmark experiments on both GPU and CPU, if k is proportionally small ( k ≪ n ), Redzone outperforms existing parallel stream compaction by orders of magnitude, while if k is close to n , it underperforms by a constant factor. Redzone removes items in-place and needs only O(1) auxiliary space. However, unlike current O(n) algorithms, it is unstable (i.e., the order of elements is not preserved) and it needs a list of the items to be removed.

Joint optimization of offloading strategy and resource allocation for multi-user in dynamic vehicular edge computing systems

Internet of Vehicles (IoV) relies heavily on its computing capability to facilitate various vehicular applications. Since the cloud computing or mobile edge computing (MEC) only cannot satisfy the latency requirement due to the limitation of the resource coverage, the cloud–edge-end cooperative computing has become an emerging paradigm. A comprehensive IoV architecture is considered and a joint optimization problem is formulated to minimize the system function value. To optimize the resource allocation and the task offloading strategy, the simulated spring system algorithm (SSSA) is designed where the initial problem is decoupled into two sub-problems with priority. The first one is to allocate computing resources based on KKT conditions, thus the individual optimal solution is achieved. The second one is solved based on the idea of simulated spring system such that the task offloading strategy is obtained. Two sub-problems iterate mutually to update each other until finishing the binary tree traversal. Thus, the proposed solution adapts to various conditions and the computational complexity is also reduced compared with traditional methods. Simulation verifies that the proposed algorithm reduces the maximum system function value by about 31% compared with the benchmark methods and performs efficiently in various road conditions.

Efficient and Secure Color Image Encryption System with Enhanced Speed and Robustness Based on Binary Tree

Recently, there has been a growing demand for image encryption techniques that offer robust protection and minimize processing time. The proposed paper proposes an efficient color image encryption system that excels in speed and security. The encryption system comprises three fundamental phases. The initial phase generates a unique encryption key by combining user-defined input with the original image and applying various operations and hash functions. In the confusion phase, the image is divided into blocks, forming a Binary Tree (BT) using primary color blocks, ensuring that the root and leaves belong to different colors. The confused matrix is derived through an inorder traversal that ensures non-adjacency of pixels of the same color, introducing an added layer of security. Finally, each pixel is scrambled by applying BT to its binary form to add more security and complexity. A DNA sequence is generated, and operations are executed based on two different chaotic maps, enhancing unpredictability and attack resistance. Extensive testing has validated the effectiveness of the proposed system, revealing a remarkable 28–45% reduction in processing time compared to recent techniques. Moreover, the system successfully withstands various attacks, as demonstrated through rigorous evaluations, including high-performance, visual perception, and cryptosystem strength evaluations. These results underscore the practical applicability and robust security offered by our efficient color image encryption solution, which provides a practical solution for applications prioritizing efficiency.

Orchard: Heterogeneous Parallelism and Fine-grained Fusion for Complex Tree Traversals

Many applications are designed to perform traversals on tree-like data structures. Fusing and parallelizing these traversals enhance the performance of applications. Fusing multiple traversals improves the locality of the application. The runtime of an application can be significantly reduced by extracting parallelism and utilizing multi-threading. Prior frameworks have tried to fuse and parallelize tree traversals using coarse-grained approaches, leading to missed fine-grained opportunities for improving performance. Other frameworks have successfully supported fine-grained fusion on heterogeneous tree types but fall short regarding parallelization. We introduce a new framework Orchard built on top of Grafter . Orchard ’s novelty lies in allowing the programmer to transform tree traversal applications by automatically applying fine-grained fusion and extracting heterogeneous parallelism. Orchard allows the programmer to write general tree traversal applications in a simple and elegant embedded Domain-Specific Language (eDSL). We show that the combination of fine-grained fusion and heterogeneous parallelism performs better than each alone when the conditions are met.

Physics-constrained robust learning of open-form partial differential equations from limited and noisy data

Unveiling the underlying governing equations of nonlinear dynamic systems remains a significant challenge. Insufficient prior knowledge hinders the determination of an accurate candidate library, while noisy observations lead to imprecise evaluations, which in turn result in redundant function terms or erroneous equations. This study proposes a framework to robustly uncover open-form partial differential equations (PDEs) from limited and noisy data. The framework operates through two alternating update processes: discovering and embedding. The discovering phase employs symbolic representation and a novel reinforcement learning (RL)-guided hybrid PDE generator to efficiently produce diverse open-form PDEs with tree structures. A neural network-based predictive model fits the system response and serves as the reward evaluator for the generated PDEs. PDEs with higher rewards are utilized to iteratively optimize the generator via the RL strategy and the best-performing PDE is selected by a parameter-free stability metric. The embedding phase integrates the initially identified PDE from the discovering process as a physical constraint into the predictive model for robust training. The traversal of PDE trees automates the construction of the computational graph and the embedding process without human intervention. Numerical experiments demonstrate our framework's capability to uncover governing equations from nonlinear dynamic systems with limited and highly noisy data and outperform other physics-informed neural network-based discovery methods. This work opens new potential for exploring real-world systems with limited understanding.

Some Algorithms of Graph Theory in Cryptology

The inventive use of concepts from Graph Theory plays a significant role in hiding the original Plain-text for resulting in a significantly safe data transfer. In this work, the tree traversal algorithms like Inorder, Preorder, Postorder, Kruskal’s algorithm for making minimal spanning tree and the modified graph labelling scheme of graceful labelling allowing repetition of exactly one vertex label for certain graphs, have been employed to create highly hidden Cipher-texts. Encryption and decryption algorithms for all these methods are being presented in this work.

An Example of Parallel Merkle Tree Traversal: Post-Quantum Leighton-Micali Signature on the GPU

The hash-based signature (HBS) is the most conservative and time-consuming among many post-quantum cryptography (PQC) algorithms. Two HBSs, LMS and XMSS, are the only PQC algorithms standardised by the National Institute of Standards and Technology (NIST) now. Existing HBSs are designed based on serial Merkle tree traversal, which is not conducive to taking full advantage of the computing power of parallel architectures such as CPUs and GPUs. We propose a parallel Merkle tree traversal (PMTT), which is tested by implementing LMS on the GPU. This is the first work accelerating LMS on the GPU, which performs well even with over 10,000 cores. Considering different scenarios of algorithmic parallelism and data parallelism, we implement corresponding variants for PMTT. The design of PMTT for algorithmic parallelism mainly considers the execution efficiency of a single task, while that for data parallelism starts with the full utilisation of GPU performance. In addition, we are the first to design a CPU-GPU collaborative processing solution for traversal algorithms to reduce the communication overhead between CPU and GPU. For algorithmic parallelism, our implementation is still 4.48 × faster than the ideal time of the state-of-the-art traversal algorithm. For data parallelism, when the number of cores increases from 1 to 8192, the parallel efficiency is 78.39%. In comparison, our LMS implementation outperforms most existing LMS and XMSS implementations.

An Algorithm for Finding Optimal k-Core in Attribute Networks

As a structural indicator of dense subgraphs, k-core has been widely used in community search due to its concise and efficient calculation. Many community search algorithms have been expanded on the basis of k-core. However, relevant algorithms often set k values based on empirical analysis of datasets or require users to input manually. Once users are not familiar with the graph network structure, they may miss the optimal solution due to an improper k setting. Especially in attribute social networks, characterizing communities with only k-cores may lead to a lack of semantic interpretability of communities. Consequently, this article proposes a method for identifying the optimal k-core with the greatest attribute score in the attribute social network as the target community. The difficulty of the problem is that the query needs to integrate both structural and textual indicators of the community while fully considering the diversity of attribute scoring functions. To effectively reduce computational costs, we incorporate the topological characteristics of the k-core and the attribute characteristics of entities to construct a hierarchical forest. It is worth noting that we name tree nodes in a way similar to pre-order traversal and can maintain the order of all tree nodes during the forest creation process. In such an attribute forest, it is possible to quickly locate the initial solution containing all query vertices and reuse intermediate results during the process of expanding queries. We conducted effectiveness and performance experiments on multiple real datasets. As the results show, attribute scoring functions are not monotonic, and the algorithm proposed in this paper can avoid scores falling into local optima. With the help of the attribute k-core forest, the actual query time of the Advanced algorithm has improved by two orders of magnitude compared to the BaseLine algorithm. In addition, the average F1 score of our target community has increased by 2.04 times and 26.57% compared to ACQ and SFEG, respectively.

Exploiting Flat Namespace to Improve File System Metadata Performance on Ultra-Fast, Byte-Addressable NVMs

The conventional file system provides a hierarchical namespace by structuring it as a directory tree. Tree-based namespace structure leads to inefficient file path walk and expensive namespace tree traversal, underutilizing ultra-low access latency and superior sequential performance provided by non-volatile memories (NVMs). This article proposes FlatFS+, an NVM file system that features a flat namespace architecture while providing a compatible hierarchical namespace view. FlatFS+ incorporates three novel techniques: the direct file path walk model, range-optimized B r tree, and compressed index key design with scan and write dual optimization, to fully exploit flat namespace to improve file system metadata performance on ultra-fast, byte-addressable NVMs. Evaluation results demonstrate that FlatFS+ achieves significant performance improvements for metadata-intensive benchmarks and real-world applications compared to other file systems.

Efficient phylogenetic tree inference for massive taxonomic datasets: harnessing the power of a server to analyze 1 million taxa.

Phylogenies play a crucial role in biological research. Unfortunately, the search for the optimal phylogenetic tree incurs significant computational costs, and most of the existing state-of-the-art tools cannot deal with extremely large datasets in reasonable times. In this work, we introduce the new VeryFastTree code (version 4.0), which is able to construct a tree on 1 server using single-precision arithmetic from a massive 1 million alignment dataset in only 36hours, which is 3 times and 3.2 times faster than its previous version and FastTree-2, respectively. This new version further boosts performance by parallelizing all tree traversal operations during the tree construction process, including subtree pruning and regrafting moves. Additionally, it introduces significant new features such as support for new and compressed file formats, enhanced compatibility across a broader range of operating systems, and the integration of disk computing functionality. The latter feature is particularly advantageous for users without access to high-end servers, as it allows them to manage very large datasets, albeit with an increase in computing time. Experimental results establish VeryFastTree as the fastest tool in the state-of-the-art for maximum likelihood phylogeny estimation. It is publicly available at https://github.com/citiususc/veryfasttree. In addition, VeryFastTree is included as a package in Bioconda, MacPorts, and all Debian-based Linux distributions.

Generating automated test case from sequence diagram using Pre-order Traversal

Automated test case generation is important in software testing to evaluate developed software. The testing process requires test cases that can be based on Software Requirements Specification (SRS) and Software Design Document (SDD). One of UML diagrams included in the previous documentations is sequence diagram. This research proposed a modified pre-order algorithm that can generate test cases automatically from sequence diagrams. Our manual cyclomatic complexity evaluation showed that our method produced accurate test cases based on the sequence of messages in the sequence diagram. This result justifies that the generated test cases match the relevant sequence diagram.

Sparcl: A language for partially invertible computation

Abstract Invertibility is a fundamental concept in computer science, with various manifestations in software development (serializer/deserializer, parser/printer, redo/undo, compressor/decompressor, and so on). Full invertibility necessarily requires bijectivity, but the direct approach of composing bijective functions to develop invertible programs is too restrictive to be useful. In this paper, we take a different approach by focusing on partially invertible functions—functions that become invertible if some of their arguments are fixed. The simplest example of such is addition, which becomes invertible when fixing one of the operands. More involved examples include entropy-based compression methods (e.g., Huffman coding), which carry the occurrence frequency of input symbols (in certain formats such as Huffman tree), and fixing this frequency information makes the compression methods invertible. We develop a language Sparcl for programming such functions in a natural way, where partial invertibility is the norm and bijectivity is a special case, hence gaining significant expressiveness without compromising correctness. The challenge in designing such a language is to allow ordinary programming (the “partially” part) to interact with the invertible part freely, and yet guarantee invertibility by construction. The language Sparcl is linear-typed and has a type constructor to distinguish data that are subject to invertible computation and those that are not. We present the syntax, type system, and semantics of the language and prove that Sparcl correctly guarantees invertibility for its programs. We demonstrate the expressiveness of Sparcl with examples including tree rebuilding from preorder and inorder traversals, Huffman coding, arithmetic coding, and LZ77 compression.

To Combat Multiclass Imbalanced Problems by Aggregating Evolutionary Hierarchical Classifiers.

Real-world datasets are often imbalanced, posing frequent challenges to canonical machine learning algorithms that assume a balanced class distribution. Moreover, the imbalance problem becomes more complicated when the dataset is multiclass. Although many approaches have been presented for imbalanced learning (IL), research on the multiclass imbalanced problem is relatively limited and deficient. To alleviate these issues, we propose a forest of evolutionary hierarchical classifiers (FEHC) method for multiclass IL (MCIL). FEHC can be seen as a classifier fusion framework with a forest structure, and it aggregates several evolutionary hierarchical multiclassifiers (EHMCs) to reduce generalization error. Specifically, a multichromosome genetic algorithm (MCGA) is designed to simultaneously select (sub)optimal features, classifiers, and hierarchical structures when generating these EHMCs. The MCGA adopts a dynamic weighting module to learn difficult classes and promote the diversity of FEHC. We also present the "stratified underbagging" (SUB) strategy to address class imbalance and the "soft tree traversal" (STT) strategy to make FEHC converge faster and better. We thoroughly evaluate the proposed algorithm using 14 multiclass imbalanced datasets with various properties. Compared with popular and state-of-the-art approaches, FEHC obtains better performance under different evaluation metrics. Codes have been made publicly available on GitHub.https://github.com/CUHKSZ-NING/FEHCClassifier.

너비 우선 탐색 기반 비재귀 트리 탐색 알고리즘의 효율적 구현과 성능 비교

The objective of this study is to present an efficient tree traversal algorithm in terms of execution time and implementation complexity. Trees, defined as acyclic connected graphs, are widely used in various fields of computer science. Unlike traditional recursive methods or depth first search implementations, this research proposes an implementation based on breadth first search. The algorithm improves execution time using a non-recursive approach and reduces implementation complexity by using only one-dimensional arrays and loops. Additionally, the algorithm has been optimized through a preprocessing phase. To evaluate the performance of the proposed algorithm compared to existing ones, trees with random structures were generated and their execution times were measured. The results demonstrated that the proposed algorithm exhibits efficient performance.

A secured energy aware resource allocation and task scheduling based on improved cuckoo search algorithm and deep reinforcement learning for e-healthcare applications

Healthcare industries have begun using modern technologies and tools like cloud computing these days. When cloud computing and assisted technologies are used in the healthcare domain the storage cost improves along with the quality and time availability. The present work makes use of cryptography based architecture for improving the overall security aspects. However, the tasks of the user take a longer duration for the execution to complete when the needed resources are unavailable on the main server. ICSA (Improved Cuckoo Search Algorithm) with DRL (Deep Reinforcement Learning) to solve this issue. The main goal of this work is to increase overall security and reduce execution times of jobs. The objective also includes using underutilized resources. Scheduling jobs, Binary In-order Traversal Trees with weights are used. Subsequently, DRL algorithm has been used to decrease the space complexity by splitting the individual resources. There will be idle resources in a state space that are used in allocation of tasks. The scheduled tasks will then do a search on the resources based on the ICSA algorithm. The server will then distribute the resources to the action area after an optimal resource has been chosen and assigned to the job. DRL for resource allocation so that the inactive resource usage is minimized and the execution time is reduced. Finally, MTAC-IBEA (multi tenant authentication control with improved blowfish encryption algorithm) for decrypt health data. The outcomes of simulation demonstrate that the suggested method offers optimum work schedules, resource allocations, and security in e-healthcare systems.

Secure Two-Party Decision Tree Classification Based on Function Secret Sharing

Decision tree models are widely used for classification tasks in data mining. However, privacy becomes a significant concern when training data contain sensitive information from different parties. This paper proposes a novel framework for secure two-party decision tree classification that enables collaborative training and evaluation without leaking sensitive data. The critical techniques employed include homomorphic encryption, function secret sharing (FSS), and a custom secure comparison protocol. Homomorphic encryption allows computations on ciphertexts, enabling parties to evaluate an encrypted decision tree model jointly. FSS splits functions into secret shares to hide sensitive intermediate values. The comparison protocol leverages FSS to securely compare attribute values to node thresholds for tree traversal, reducing overhead through efficient cryptographic techniques. Our framework divides computation between two servers holding private data. A privacy-preserving protocol lets them jointly construct a decision tree classifier without revealing their respective inputs. The servers encrypt their data and exchange function secret shares to traverse the tree and obtain the classification result. Rigorous security proofs demonstrate that the protocol protects data confidentiality in a semihonest model. Experiments on benchmark datasets confirm that the approach achieves high accuracy with reasonable computation and communication costs. The techniques minimize accuracy loss and latency compared to prior protocols. Overall, the paper delivers an efficient, modular framework for practical two-party secure decision tree evaluation that advances the capability of privacy-preserving machine learning.

Bidirectional pruned tree-based efficient minimum cut acceleration in dense graph

The minimum cut (min-cut) problem has been extensively investigated, and the corresponding algorithms have been used in many related problems. The recently proposed acceleration strategy based on tree-cut mapping has been shown to be an effective alternative, with a slight loss in acceleration accuracy. However, the existing method requires a large number of ineffective traversal passes in the high-overhead preprocessing step, which has the potential to be significantly improved in mapping effective graphs, i.e. dense graphs. To solve the problem, we propose to use bidirectional pruned tree for tree-cut mapping, which combines pruned depth-first traversal tree and bidirectional traversal paths to enumerate as many different tree instances as possible. Thus, it can help find the min-cut of any node pair efficiently. Theoretical analysis also shows its potential. For its serial implementation in a graph with M edges, after a preprocessing step with a time complexity as low as O(M), 99.9% of sampled node pairs can obtain their exact min-cut value in various types of dense graphs with degrees greater than 8 in experiments. In addition, the same precision can be obtained in sparse graphs in case of unit capacity. Per-pair running time in a million-node graph can be several orders of magnitude faster than existing methods and as low as several microseconds, so can be used as an effective complement to existing methods.

AxOTreeS : A Tree S earch Approach to Synthesizing FPGA-based A ppro x imate O perators

Approximate computing (AxC) provides the scope for achieving disproportionate gains in a system’s power, performance, and area (PPA) metrics by leveraging an application’s inherent error-resilient behavior (BEHAV). Trading computational accuracy for performance gains makes AxC an attractive proposition for implementing computationally complex AI/ML-based applications on resource-constrained embedded systems. The growing diversity of application domains using AI/ML has also led to the increasing usage of FPGA-based embedded systems. However, implementing AxC for FPGAs has primarily been limited to the post-processing of ASIC-optimized approximate operators (AxOs). This approach usually involves selecting from a set of AxOs that have been optimized for a gate-based implementation in an ASIC. While such an approach does allow leveraging existing knowledge of ASIC-based AxO design, it limits the scope for considering the challenges and opportunities associated with FPGA’s LUT-based computation structures. Similarly, the few works considering the LUT-based computing for AxO design use generic optimization approaches that do not allow integrating problem-specific prior knowledge—empirical and/or statistical. To this end, we propose a novel tree search-based approach to AxO synthesis for FPGAs. Specifically, we present a design methodology using Monte Carlo Tree Search (MCTS)-based search tree traversal that allows the designer to integrate statistical data, such as correlation, into the AxOs optimization. With the proposed methods, we report improvements over standard MCTS algorithm-based results as well as improved hypervolume for both operator-level and application-specific DSE, compared to state-of-the-art design methodologies.