Optimal Data Structure Research Articles

Kalman Filter Tracking on Parallel Architectures

Power density constraints are limiting the performance improvements of modern CPUs. To address this we have seen the introduction of lower-power, multi-core processors such as GPGPU, ARM and Intel MIC. To stay within the power density limits but still obtain Moore's Law performance/price gains, it will be necessary to parallelize algorithms to exploit larger numbers of lightweight cores and specialized functions like large vector units. Track finding and fitting is one of the most computationally challenging problems for event reconstruction in particle physics. At the High-Luminosity Large Hadron Collider (HL-LHC), for example, this will be by far the dominant problem. The need for greater parallelism has driven investigations of very different track finding techniques such as Cellular Automata or Hough Transforms. The most common track finding techniques in use today, however, are those based on the Kalman Filter. Significant experience has been accumulated with these techniques on real tracking detector systems, both in the trigger and offline. They are known to provide high physics performance, are robust, and are in use today at the LHC. We report on porting these algorithms to new parallel architectures. Our previous investigations showed that, using optimized data structures, track fitting with a Kalman Filter can achieve large speedups both with Intel Xeon and Xeon Phi. Additionally, we have previously shown first attempts at track building with some speedup. We report here our progress towards an end-to-end track reconstruction algorithm fully exploiting vectorization and parallelization techniques in a simplified experimental environment.

Kalman Filter Tracking on Parallel Architectures

Power density constraints are limiting the performance improvements of modern CPUs. To address this we have seen the introduction of lower-power, multi-core processors, but the future will be even more exciting. In order to stay within the power density limits but still obtain Moore's Law performance/price gains, it will be necessary to parallelize algorithms to exploit larger numbers of lightweight cores and specialized functions like large vector units. Example technologies today include Intel's Xeon Phi and GPGPUs.Track finding and fitting is one of the most computationally challenging problems for event reconstruction in particle physics. At the High Luminosity LHC, for example, this will be by far the dominant problem. The need for greater parallelism has driven investigations of very different track finding techniques including Cellular Automata or returning to Hough Transform. The most common track finding techniques in use today are however those based on the Kalman Filter [2]. Significant experience has been accumulated with these techniques on real tracking detector systems, both in the trigger and offline. They are known to provide high physics performance, are robust and are exactly those being used today for the design of the tracking system for HL-LHC.Our previous investigations showed that, using optimized data structures, track fitting with Kalman Filter can achieve large speedup both with Intel Xeon and Xeon Phi. We report here our further progress towards an end-to-end track reconstruction algorithm fully exploiting vectorization and parallelization techniques in a realistic simulation setup.

Ray Specialized Contraction on Bounding Volume Hierarchies

In this paper we propose a simple but effective method to modify a BVH based on ray distribution for improved ray tracing performance. Our method starts with an initial BVH generated by any state-of-the-art offline algorithm. Then by traversing a small set of sample rays we collect statistics at each node of the BVH. Finally, a simple but ultra-fast BVH contraction algorithm modifies the initial binary BVH to a multi-way BVH. The overall acceleration for ray-primitive testing is about 25% for incoherent diffuse rays and 30% for shadow rays, which is significant as a data structure optimization. Similar results are also presented for packet ray tracing, and for Quad-BVHs the improvement is 10% to 15%. The approach has the advantages of being simple, and compatible with almost any existing BVH and ray tracing techniques, and it require very little extra work to generate the modified tree.

Large-scale physiological waveform retrieval via locality-sensitive hashing.

We propose a fast, scalable locality-sensitive hashing method for the problem of retrieving similar physiological waveform time series. When compared to the naive k-nearest neighbor search, the method vastly speeds up the retrieval time of similar physiological waveforms without sacrificing significant accuracy. Our result shows that we can achieve 95% retrieval accuracy or better with up to an order of magnitude of speed-up. The extra time required in advance to create the optimal data structure is recovered when query quantity equals 15% of the repository, while the method incurs a trivial additional memory cost. We demonstrate the effectiveness of this method on an arterial blood pressure time series dataset extracted from the ICU physiological waveform repository of the MIMIC-II database.

Optimal Data Structures for Farthest-Point Queries in Cactus Networks

Consider the continuum of points on the edges of a network, i.e., a connected, undirected graph with positive edge weights. We measure the distance between these points in terms of the weighted shortest path distance, called the network distance. Within this metric space, we study farthest points and farthest distances. We introduce optimal data structures supporting queries for the farthest distance and the farthest points on trees, cycles, uni-cyclic networks, and cactus networks.

Space-Efficient Substring Occurrence Estimation

In this paper we study the problem of estimating the number of occurrences of substrings in textual data: A text $$T$$T on some alphabet $$\varSigma =[\sigma ]$$Σ=[?] of length $$n$$n is preprocessed and an index $${\mathcal {I}}$$I is built. The index is used in lieu of the text to answer queries of the form $$\mathsf{Count}\approx (P)$$Count?(P), returning an approximated number of the occurrences of an arbitrary pattern $$P$$P as a substring of $$T$$T. The problem has its main application in selectivity estimation related to the LIKE predicate in textual databases. Our focus is on obtaining an algorithmic solution with guaranteed error rates and small footprint. To achieve that, we first enrich previous work in the area of compressed text-indexing providing an optimal data structure that, for a given additive error $$\ell \ge 1$$l?1, requires $$\varTheta \left( \frac{n}{\ell }\log \sigma \right) $$?nllog? bits. We also approach the issue of guaranteeing exact answers for sufficiently frequent patterns, providing a data structure whose size scales with the amount of such patterns. Our theoretical findings are supported by experiments showing the practical impact of our data structures.

Sampling from Discrete Distributions and Computing Fréchet Distances

In the first part of this dissertation, we study the fundamental problem of sampling from a discrete probability distribution. Specifically, given non-negative numbers p1, . . . , pn the task is to draw i with probability proportional to pi. We extend the classic solution to this problem, Walker’s alias method, in various directions: 1. We improve upon its space requirements by presenting optimal succinct sampling data structures. 2. We present improved trade-offs between preprocessing and query time for sorted inputs, and generalize this from proportional sampling to sampling subsets. 3. For Bernoulli, geometric, and binomial random variates we present optimal sampling algorithms on a bounded precision machine. 4. As an application, we speed up sampling of internal diffusion limited aggregation. The second part of this dissertation belongs to the area of computational geometry and deals with algorithms for the Frechet distance, which is a popular measure of similarity of two curves and can be computed in quadratic time (ignoring logarithmic factors). We provide the first conditional lower bound for this problem: No polynomial factor improvement over the quadratic running time is possible unless the Strong Exponential Time Hypothesis fails. Our various extensions of this main result include conditional lower bounds under realistic input assumptions, which do not match the known algorithms. We close this gap by presenting an improved approximation algorithm for the Frechet distance.

Efficient range searching for categorical and plain data

In the orthogonal range-searching problem, we store a set of input points S in a data structure; the answer to a query Q is a piece of information about points in Q ∩ S , for example, the list of all points in Q ∩ S or the number of points in Q . In the colored (or categorical) range-searching problem, the set of input points is partitioned into categories; the answer to a query is a piece of information about categories of points in a query range. In this article, we describe several new results for one- and two-dimensional range-searching problems. We obtain an optimal adaptive data structure for counting the number of objects in a three-sided range and for counting categories of objects in a one-dimensional range. We also obtain new results on color range reporting in two dimensions, approximate color counting in one dimension, and some other related problems.

Data Structure Optimization for Power- Efficient IP Lookup Architectures

Power consumption has become a limiting factor in designing next generation network routers. Recent observation shows that IP lookup engines dominate the power consumption of core routers. Previous work on reducing power consumption of routers mainly focused on network- and system-level optimizations. This paper represents the first thorough study on the data structure optimization for lowering the power consumption in static random access memory (SRAM)-based IP lookup engines. Three different SRAM-based IP lookup architectures are discussed: nonpipelined, simple pipelined, and memory-balanced pipelined architectures. For each architecture, we formulate the problem of power minimization by revisiting the time-space tradeoff in multibit tries. Two distinct multibit trie algorithms are investigated: the expanded trie and the tree bitmap trie, which are widely used in SRAM-based IP lookup solutions. A theoretical framework is proposed to determine the optimal strides for building a multibit trie so that the worst-case power consumption of the IP lookup architecture is minimized. Experiments using real-life routing tables including both IPv4 and IPv6 data sets demonstrate that careful selection of strides in building the multibit tries can reduce the power consumption dramatically. We believe our methodology can be applied to other variants of multibit tries and can help in designing more power-efficient SRAM-based IP lookup architectures.

New approach to analysis of voltammetric ligand titration data improves understanding of metal speciation in natural waters

In this study, previously published multiple analytical window datasets of competitive ligand exchange—adsorptive cathodic stripping voltammetry titrations for dissolved copper with salicylaldoxime as the competing ligand were reanalyzed. A new numerical method was applied, the Sander‐Wells (S‐W) method, which is able to simultaneously analyze multiple analytical window titrations as a unified dataset and calculate parameters for one to three ligand classes in the samples. The two datasets used were from separate sampling events at Dumbarton Bridge, San Francisco Bay. The aim of this study was to see if discrete ligand classes can be resolved from these data, and how these compare with results obtained by applying commonly used manual calculations of individual analytical window titrations separately: Scatchard and van den Berg/Ružic linearizations, and the Gerringa non‐linear regression. The united multiple analytical window dataset could only be analyzed simultaneously by the S‐W method, and two or three discrete ligand classes were resolved for each sample. Applying the four different data analysis methods independently to each of the five analytical windows resulted in solutions spanning a continuum of conditional stability constants and ligand concentrations. It was shown that the sensitivity S, as well as data structure and iterative optimization, are the major reasons for different results. This study demonstrates the utility of simultaneous analysis of multiple analytical window titration curves to better determine the distribution of trace metal species in aqueous systems and the advantages of adopting such a ‘unified data set’ approach over fitting individual titration curves.

Named data networking on a router

Named data networking (NDN) is a new networking paradigm using named data instead of named hosts for communication. Implementation of scalable NDN packet forwarding remains a challenge because NDN requires fast variable-length hierarchical name-based lookup, per-packet data plane state update, and large-scale forwarding tables. We have designed and implemented an NDN data plane with a software forwarding engine on an Intel Xeon-based line card in a Cisco ASR9000 router. In order to achieve high-speed forwarding, our design features (1) name lookup via hash tables with fast collision-resistant hash computation, (2) an efficient and secure FIB lookup algorithm that provides good average and bounded worst-case FIB lookup time, (3) PIT partitioning that enables linear multi-core speedup, and (4) an optimized data structure and software prefetching to maximize data cache utilization. In this demonstration, we showcase our NDN router implementation on the ASR9000 and demonstrate that it can forward real NDN traffic at 20Gbps or higher.

Computing the conjugate of convex piecewise linear-quadratic bivariate functions

We present a new algorithm to compute the Legendre–Fenchel conjugate of convex piecewise linear-quadratic (PLQ) bivariate functions. The algorithm stores a function using a (primal) planar arrangement. It then computes the (dual) arrangement associated with the conjugate by looping through vertices, edges, and faces in the primal arrangement and building associated dual vertices, edges, and faces. Using optimal computational geometry data structures, the algorithm has a linear time worst-case complexity. We present the algorithm, and illustrate it with numerical examples. We proceed to build a toolbox for convex bivariate PLQ functions by implementing the addition, and scalar multiplication operations. Finally, we compose these operators to compute classical convex analysis operators such as the Moreau envelope, and the proximal average.

Optimizing data structures in high-level programs

High level data structures are a cornerstone of modern programming and at the same time stand in the way of compiler optimizations. In order to reason about user- or library-defined data structures compilers need to be extensible. Common mechanisms to extend compilers fall into two categories. Frontend macros, staging or partial evaluation systems can be used to programmatically remove abstraction and specialize programs before they enter the compiler. Alternatively, some compilers allow extending the internal workings by adding new transformation passes at different points in the compile chain or adding new intermediate representation (IR) types. None of these mechanisms alone is sufficient to handle the challenges posed by high level data structures. This paper shows a novel way to combine them to yield benefits that are greater than the sum of the parts. Instead of using staging merely as a front end, we implement internal compiler passes using staging as well. These internal passes delegate back to program execution to construct the transformed IR. Staging is known to simplify program generation, and in the same way it can simplify program transformation. Defining a transformation as a staged IR interpreter is simpler than implementing a low-level IR to IR transformer. With custom IR nodes, many optimizations that are expressed as rewritings from IR nodes to staged program fragments can be combined into a single pass, mitigating phase ordering problems. Speculative rewriting can preserve optimistic assumptions around loops. We demonstrate several powerful program optimizations using this architecture that are particularly geared towards data structures: a novel loop fusion and deforestation algorithm, array of struct to struct of array conversion, object flattening and code generation for heterogeneous parallel devices. We validate our approach using several non trivial case studies that exhibit order of magnitude speedups in experiments.

A PARALLEL MONTE CARLO CODE FOR SIMULATING COLLISIONAL N -BODY SYSTEMS

We present a new parallel code for computing the dynamical evolution of collisional N-body systems with up to N~10^7 particles. Our code is based on the the Henon Monte Carlo method for solving the Fokker-Planck equation, and makes assumptions of spherical symmetry and dynamical equilibrium. The principal algorithmic developments involve optimizing data structures, and the introduction of a parallel random number generation scheme, as well as a parallel sorting algorithm, required to find nearest neighbors for interactions and to compute the gravitational potential. The new algorithms we introduce along with our choice of decomposition scheme minimize communication costs and ensure optimal distribution of data and workload among the processing units. The implementation uses the Message Passing Interface (MPI) library for communication, which makes it portable to many different supercomputing architectures. We validate the code by calculating the evolution of clusters with initial Plummer distribution functions up to core collapse with the number of stars, N, spanning three orders of magnitude, from 10^5 to 10^7. We find that our results are in good agreement with self-similar core-collapse solutions, and the core collapse times generally agree with expectations from the literature. Also, we observe good total energy conservation, within less than 0.04% throughout all simulations. We analyze the performance of the code, and demonstrate near-linear scaling of the runtime with the number of processors up to 64 processors for N=10^5, 128 for N=10^6 and 256 for N=10^7. The runtime reaches a saturation with the addition of more processors beyond these limits which is a characteristic of the parallel sorting algorithm. The resulting maximum speedups we achieve are approximately 60x, 100x, and 220x, respectively.

Performance Analysis of Iterative Solvers of Linear Equations for Hp-adaptive Finite Element Method

The paper presents performance considerations for Krylov space iterative solvers used in hp-adaptive finite element codes. The design of optimal data structures and algorithms in terms of memory requirements and computing efficiency is shown. Preliminary computational results prove the correctness of basic assumptions and indicate the direction of further research.

Approximate Shortest Paths Avoiding a Failed Vertex: Near Optimal Data Structures for Undirected Unweighted Graphs

Let G=(V,E) be an undirected unweighted graph. A path between any two vertices u,v∈V is said to be t-approximate shortest path if its length is at most t times the length of the shortest path between u and v. We address the problem of building a compact data structure which can efficiently answer the following query for any u,v,x∈V and t>1: . We present data structures for the single source as well as all-pairs versions of this problem. The query time guaranteed by our data structures is optimal up to a constant factor. Moreover, the size of each of them nearly matches the size of the corresponding data structure with no failures.

RAPSearch2: a fast and memory-efficient protein similarity search tool for next-generation sequencing data

Summary: With the wide application of next-generation sequencing (NGS) techniques, fast tools for protein similarity search that scale well to large query datasets and large databases are highly desirable. In a previous work, we developed RAPSearch, an algorithm that achieved a ~20–90-fold speedup relative to BLAST while still achieving similar levels of sensitivity for short protein fragments derived from NGS data. RAPSearch, however, requires a substantial memory footprint to identify alignment seeds, due to its use of a suffix array data structure. Here we present RAPSearch2, a new memory-efficient implementation of the RAPSearch algorithm that uses a collision-free hash table to index a similarity search database. The utilization of an optimized data structure further speeds up the similarity search—another 2–3 times. We also implemented multi-threading in RAPSearch2, and the multi-thread modes achieve significant acceleration (e.g. 3.5X for 4-thread mode). RAPSearch2 requires up to 2G memory when running in single thread mode, or up to 3.5G memory when running in 4-thread mode.Availability and implementation: Implemented in C++, the source code is freely available for download at the RAPSearch2 website: http://omics.informatics.indiana.edu/mg/RAPSearch2/.Contact: yye@indiana.eduSupplementary information: Available at the RAPSearch2 website.

Quality assessment of coupled civil engineering applications

The software scenery in civil engineering is characterized by a large number of more or less specialized software applications for different tasks. To solve the tasks efficiently, each software application has its own appropriate and optimized data structure. The variety of software tools used to support the design process leads to an exchange of data and information between the involved engineers and their software applications. An exchange of data and information can be achieved by schema mapping and has been an active subject of research during the last decade. However, due to the incompatible data schemas, loss of data and information may occur and therefore needs to be quantified. Current evaluation processes mainly operate on the data and work a posteriori. The changes of data and information resulting from inadequate data mappings between data schemas of software applications to be coupled are identified either by visual inspection or via file comparison and are classified according to certain criteria. Then, the changes have to be qualitatively evaluated by the user. In this paper, a generic a priori approach to assess coupling quality is introduced. Software coupling in computer science refers to the ability to enable software applications to work together, and thus to achieve a common objective. This can be achieved by a data exchange and means the transfer of needed data between the coupled software. The quality of the coupling depends on the quantity and the accuracy of data to be transferred. The formalism to assess coupling quality is described mathematically including set theory and graph theory. This approach operates on the involved schemas, is not limited to a common data exchange format, and takes into account various mapping patterns. Moreover, the coupling quality is evaluated in the formalization process, which results in a global quality value. This quality value can then be used directly by the user to assess the data exchange. A synthetic scenario from civil engineering is used to illustrate the formalization process. Finally, the applicability of the proposed approach to assess coupling quality is shown within a real world case study.

Optimizing to Memory Application in Embedded Multimedia Device

The modern embedded multimedia electronic devices rely on dynamically-allocated data structures to store and process their data, as a result, the demand of its memory capacity and dynamic are increasing unceasingly. In order to better solve the memory application optimization in embedded device, this paper represents multimedia application’s dynamic data structures optimization flow and improved or modified NSGA-II multi-objective evolutionary algorithm (MNSGA-II), and uses three objective functions: embedded device’s memory accesses, memory use and energy consumption. The MNSGA-II algorithm adopts repeat crowded distance sorting tactics to improve NSGA-II based on keeping the advantage of the original NSGA-II for multi-objective optimization problem. The experiment results show that MNSGA-II has better performance of the convergence and the diversity of solutions than original NSGA-II, and the optimal dynamic data structure implementation is successful by performing our method for one real embedded multimedia device’s memory application.

Taming the elephants: New TCP slow start

Standard slow start does not work well under large bandwidth-delay product (BDP) networks. We find two reasons for this problem in three popular existing operating systems: Linux, FreeBSD and Windows XP. The first reason is that heavy packet losses occur because of the exponential increase of the congestion window during standard slow start. Recovering from heavy packet losses puts extremely high loads on end systems, rendering the end systems completely unresponsive for a long period of time, and results in a long blackout period without transmission. This problem commonly occurs with all three operating systems. The second reason is that some proprietary protocol optimizations applied to slow start happen to slow down the loss recovery followed by slow start. Although improving the system bottleneck by optimizing data structures is valuable especially for addressing the processing overload with heavy packet losses, it is not effective for the prolonged loss recovery caused by proprietary optimizations. In addition, a large number of packet losses are not desirable since they waste network bandwidth and lead TCP into frequent timeouts and loss synchronization which results in under-utilization of the network. We propose a new slow start algorithm, called Hybrid Start (HyStart), that finds a “safe” exit point for slow start at which it can terminate and safely advance to the congestion avoidance phase without causing heavy packet loss. HyStart uses ACK trains and RTT delay samples to detect whether (1) the forward path is congested or (2) the current size of the congestion window has reached the available capacity of the forward path. HyStart is a plugin to TCP senders and requires no change on TCP receivers. We implement HyStart for TCP-NewReno and TCP-SACK in Linux and compare its performance with five different slow start schemes on the TCP receivers of the three different operating systems on the Internet and also in lab testbeds. Our results indicate that HyStart works consistently well under diverse network environments, including asymmetric links, wireless networks, and high and low BDP networks. Especially with different operating system receivers (Windows XP and FreeBSD), HyStart improves the start-up throughput of TCP significantly by more than 2 to 3 times and is the default slow start algorithm of CUBIC since Linux 2.6.29.