Parallel Data Structures Research Articles

Parallel Minimum Cuts in O ( m log 2 n ) Work and Low Depth

We present a randomized O ( m log 2 n ) work, O (polylog n ) depth parallel algorithm for minimum cut. This algorithm matches the work bounds of a recent sequential algorithm by Gawrychowski, Mozes, and Weimann [ICALP’20], and improves on the previously best parallel algorithm by Geissmann and Gianinazzi [SPAA’18], which performs O ( m log 4 n ) work in O (polylog n ) depth. Our algorithm makes use of three components that might be of independent interest. First, we design a parallel data structure that efficiently supports batched mixed queries and updates on trees. It generalizes and improves the work bounds of a previous data structure of Geissmann and Gianinazzi and is work efficient with respect to the best sequential algorithm. Second, we design a parallel algorithm for approximate minimum cut that improves on previous results by Karger and Motwani. We use this algorithm to give a work-efficient procedure to produce a tree packing, as in Karger’s sequential algorithm for minimum cuts. Last, we design an efficient parallel algorithm for solving the minimum 2-respecting cut problem.

HexBox: Interactive Box Modeling of Hexahedral Meshes

AbstractWe introduce HexBox, an intuitive modeling method and interactive tool for creating and editing hexahedral meshes. Hexbox brings the major and widely validated surface modeling paradigm of surface box modeling into the world of hex meshing. The main idea is to allow the user to box‐model a volumetric mesh by primarily modifying its surface through a set of topological and geometric operations. We support, in particular, local and global subdivision, various instantiations of extrusion, removal, and cloning of elements, the creation of non‐conformal or conformal grids, as well as shape modifications through vertex positioning, including manual editing, automatic smoothing, or, eventually, projection on an externally‐provided target surface. At the core of the efficient implementation of the method is the coherent maintenance, at all steps, of two parallel data structures: a hexahedral mesh representing the topology and geometry of the currently modeled shape, and a directed acyclic graph that connects operation nodes to the affected mesh hexahedra. Operations are realized by exploiting recent advancements in grid‐based meshing, such as mixing of 3‐refinement, 2‐refinement, and face‐refinement, and using templated topological bridges to enforce on‐the‐fly mesh conformity across pairs of adjacent elements. A direct manipulation user interface lets users control all operations. The effectiveness of our tool, released as open source to the community, is demonstrated by modeling several complex shapes hard to realize with competing tools and techniques.

A Bin-Based Indexing for Scalable Range Join on Genomic Data.

Range-join is an operation for finding overlaps in interval-form genomic data. Range-join is widely used in various genome analysis processes such as annotation, filtering and comparison of variants in whole-genome and exome analysis pipelines. The quadratic complexity of current algorithms with sheer data volume has surged the design challenges. Existing tools have limitations on algorithm efficiency, parallelism, scalability and memory consumption. This paper proposes BIndex, a novel bin-based indexing algorithm and its distributed implementation to attain high throughput range-join processing. BIndex features near-constant search complexity while the inherently parallel data structure facilitates exploitation of parallel computing architectures. Balanced partitioning of dataset further enables scalability on distributed frameworks. The implementation on Message Passing Interface shows upto 933.5x speedup in comparison to state-of-the-art tools. Parallel nature of BIndex further enables GPU-based acceleration with 3.72x speedup than CPU implementations. The add-in modules for Apache Spark provides upto 4.65x speedup than the previously best available tool. BIndex supports wide variety of input and output formats prevalent in bioinformatics community and the algorithm is easily extendable to streaming data in recent Big Data solutions. Furthermore, the index data structure is memory-efficient and consumes upto two orders-of-magnitude lesser RAM, while having no adverse effect on speedup.

Pylspack : Parallel Algorithms and Data Structures for Sketching, Column Subset Selection, Regression, and Leverage Scores

We present parallel algorithms and data structures for three fundamental operations in Numerical Linear Algebra: (i) Gaussian and CountSketch random projections and their combination, (ii) computation of the Gram matrix, and (iii) computation of the squared row norms of the product of two matrices, with a special focus on “tall-and-skinny” matrices, which arise in many applications. We provide a detailed analysis of the ubiquitous CountSketch transform and its combination with Gaussian random projections, accounting for memory requirements, computational complexity and workload balancing. We also demonstrate how these results can be applied to column subset selection, least squares regression and leverage scores computation. These tools have been implemented in pylspack , a publicly available Python package 1 whose core is written in C++ and parallelized with OpenMP and that is compatible with standard matrix data structures of SciPy and NumPy. Extensive numerical experiments indicate that the proposed algorithms scale well and significantly outperform existing libraries for tall-and-skinny matrices.

A parallel data-structure for modular programming of triangulated computing media.

A parallel data-structure for modular programming of triangulated computing media.

Generic parallel data structures and algorithms to GPU superpixel image segmentation

We propose parallel implementation on GPU (graphics processing unit) system for some generic algorithms applied to superpixel image segmentation problem. The aim is to provide standard algorithms based on generic decentralized data structures that could be easily improved and customized on many optimization problems on parallel platforms. Note that superpixel segmentation are clustering algorithms applied to image processing. Two types of algorithms are presented and implemented on GPU based on common parallel data structures. Firstly, we present a parallel implementation of the well-known k-means algorithm with application to 3D data. It is based on a cellular grid subdivision of space that allows closest point findings in constant optimal time for bounded distributions. Secondly, we present an application of the parallel Boruvka minimum spanning forest algorithm to compute watershed segmentation. Both techniques are fully executed on GPU and share the same data structures that embed disjoint-set-trees and distributed-link-lists. We evaluate our k-means approach with regards to state-of-the-art methods, that are, the well known SLIC algorithm, and the adaptive segmentation approach SPASM. We argue that our implementation has the shortest execution time among the tested methods, with a near real time performance and quasi linear acceleration factor, while it provides more regular shape superpixel segmentation based on hexagonal tessellation. Watershed minimum spanning forest method is presented and evaluated accordingly to the same experimental framework.

Fast data series indexing for in-memory data

Data series similarity search is a core operation for several data series analysis applications across many different domains. However, the state-of-the-art techniques fail to deliver the time performance required for interactive exploration, or analysis of large data series collections. In this work, we propose MESSI, the first data series index designed for in-memory operation on modern hardware. Our index takes advantage of the modern hardware parallelization opportunities (i.e., SIMD instructions, multi-socket and multi-core architectures), in order to accelerate both index construction and similarity search processing times. Moreover, it benefits from a careful design in the setup and coordination of the parallel workers and data structures, so that it maximizes its performance for in-memory operations. MESSI supports similarity search using both the Euclidean and dynamic time warping (DTW) distances. Our experiments with synthetic and real datasets demonstrate that overall MESSI is up to 4x faster at index construction and up to 11x faster at query answering than the state-of-the-art parallel approach. MESSI is the first to answer exact similarity search queries on 100GB datasets in \(\sim \)50 ms (30–75 ms across diverse datasets), which enables real-time, interactive data exploration on very large data series collections.

OpenLB—Open source lattice Boltzmann code

We present the OpenLB package, a C++ library providing a flexible framework for lattice Boltzmann simulations. The code is publicly available and published under GNU GPLv2, which allows for adaption and implementation of additional models. The extensibility benefits from a modular code structure achieved e.g. by utilizing template meta-programming. The package covers various methodical approaches and is applicable to a wide range of transport problems (e.g. fluid, particulate and thermal flows). The built-in processing of the STL file format furthermore allows for the simple setup of simulations in complex geometries. The utilization of MPI as well as OpenMP parallelism enables the user to perform those simulations on large-scale computing clusters. It requires a minimal amount of dependencies and includes several benchmark cases and examples. The package presented here aims at providing an open access platform for both, applicants and developers, from academia as well as industry, which facilitates the extension of previous implementations and results to novel fields of application for lattice Boltzmann methods. OpenLB was tested and validated over several code reviews and publications. This paper summarizes the findings and gives a brief introduction to the underlying concepts as well as the design of the parallel data structure.

Debugging Large-scale Datalog

Logic programming languages such as Datalog have become popular as Domain Specific Languages (DSLs) for solving large-scale, real-world problems, in particular, static program analysis and network analysis. The logic specifications that model analysis problems process millions of tuples of data and contain hundreds of highly recursive rules. As a result, they are notoriously difficult to debug. While the database community has proposed several data provenance techniques that address the Declarative Debugging Challenge for Databases, in the cases of analysis problems, these state-of-the-art techniques do not scale. In this article, we introduce a novel bottom-up Datalog evaluation strategy for debugging: Our provenance evaluation strategy relies on a new provenance lattice that includes proof annotations and a new fixed-point semantics for semi-naïve evaluation. A debugging query mechanism allows arbitrary provenance queries, constructing partial proof trees of tuples with minimal height. We integrate our technique into Soufflé, a Datalog engine that synthesizes C++ code, and achieve high performance by using specialized parallel data structures. Experiments are conducted with D OOP /DaCapo, producing proof annotations for tens of millions of output tuples. We show that our method has a runtime overhead of 1.31× on average while being more flexible than existing state-of-the-art techniques.

The parallel finite element system M++ with integrated multilevel preconditioning and multilevel Monte Carlo methods

We present a parallel data structure for the discretization of partial differential equations which is based on distributed point objects and which enables the flexible, transparent, and efficient realization of conforming, nonconforming, and mixed finite elements. This concept is realized for elliptic, parabolic and hyperbolic model problems, and sample applications are provided by a tutorial complementing a lecture on scientific computing.The corresponding open-source software is based on this parallel data structure, and it supports multilevel methods on nested meshes and 2D and 3D as well as in space–time. Here, we present generic results on porous media applications including multilevel preconditioning and multilevel Monte Carlo methods for uncertainty quantification.

Specializing parallel data structures for Datalog

SummaryWe see a resurgence of Datalog in a variety of applications, including program analysis, networking, data integration, cloud computing, and security. The large‐scale and complexity of these applications need the efficient management of data in relations. Hence, Datalog implementations require new data structures for managing relations that (1) are parallel, (2) are highly specialized for Datalog evaluation, and (3) can accommodate different workloads depending on the applications concerning memory consumption and computational efficiency. In this article, we present a data structure framework for relations that is specialized for shared‐memory parallel Datalog implementations such as the soufflé Datalog compiler. The data structure framework permits a portfolio of different data structures depending on the workload. We also introduce two concrete parallel data structures for relations, designed for various workloads. Our benchmarks demonstrate a speed‐up of up to 6× by using a portfolio of data structures compared with using a B‐tree alone, showing the advantage of our data structure framework.

AllScale API

Effectively implementing scientific algorithms in distributed memory parallel applications is a difficult task for domain scientists, as evident by the large number of domain-specific languages and libraries available today attempting to facilitate the process. However, they usually provide a closed set of parallel patterns and are not open for extension without vast modifications to the underlying system. In this work, we present the AllScale API, a programming interface for developing distributed memory parallel applications with the ease of shared memory programming models. The AllScale API is closed for a modification but open for an extension, allowing new user-defined parallel patterns and data structures to be implemented based on existing core primitives and therefore fully supported in the AllScale framework. Focusing on high-level functionality directly offered to application developers, we present the design advantages of such an API design, detail some of its specifications and evaluate it using three real-world use cases. Our results show that AllScale decreases the complexity of implementing scientific applications for distributed memory while attaining comparable or higher performance compared to MPI reference implementations.

Transforming powerlist-based divide-and-conquer programs for an improved execution model

Powerlists are data structures that can be successfully used for defining parallel programs based on divide-and-conquer paradigm. These parallel recursive data structures and their algebraic theories offer both a methodology to design parallel algorithms and parallel programming abstractions to ease the development of parallel applications. The paper presents a technique for speeding up the parallel recursive programs defined based on powerlists. The improvements are achieved by applying transformation rules that introduce tuple functions and prefix operators, for which a more efficient execution model is defined. Together with the execution model, a cost model is also defined in order to allow a proper evaluation. The treated examples emphasise the fact that the transformation leads to important improvements of the programs. The speeding up is achieved by reducing the number of recursive calls, and also by enable the fusion of splitting/combining operations on different data structures. In addition, enhancing the function that has to be computed to other useful functions using a tuple, could improved the cost reduction even more.

A novel accelerated implementation of RSA using parallel processing

Past research has evidently proved that public key cryptosystems are usually slower than symmetric key cryptosystems due to the reason that they use one additional cryptographic key and different methods for encryption and decryption. RSA is one of the most common asymmetric key cryptography algorithms. Recent research has focused on speeding up RSA using various techniques. With the introduction of distributed computing, parallelization of algorithms enables them to run on multiple cores concurrently at a time. RSA consists of two resource intensive operations namely Modular Exponentiation of up to 1024-bit exponents and repeated calculation of Greatest common divisor. Thus, RSA lays the perfect base for application of Montgomery Reduction algorithm to optimize the Repeated Modular multiplication in exponentiation. In this paper we proposed a parallel scheme for RSA using a new parallel data structure known as Concurrent Indexed List of character blocks. The aim of our research was to improve the speed of RSA encryption and decryption using parallelism and also make it compatible with leading industry cryptography standards. We have simulated four different approaches namely both parallel and sequential with and without Montgomery. We have also integrated our parallel paradigm with renowned C++ Crypto library and achieved a speed-up of upto four times than sequential approach. Unlike any other previous approaches, our implementation got easily integrated with any external library and thus can be adopted by any other algorithmic scheme.

GPU-accelerated 3-D Finite Volume Particle Method

In previous works (Jahanbakhsh et al., CMAME 298 (2016): 80–107, Jahanbakhsh et al., CMAME 317 (2017): 102–127; see [1] and [2]), the authors introduced SPHEROS, a 3-D particle-based solver based on the Finite Volume Particle Method (FVPM) featuring a spherical top-hat kernel. In the present research, the authors present algorithms and optimization procedures that allowed to significantly accelerate computations by taking advantage of the computational power of Graphics Processing Units (GPUs). The new accelerated solver, GPU-SPHEROS, has been developed in CUDA and runs entirely on GPU, are presented. All the parallel algorithms and data structures have been designed specifically for the GPU many-core architecture. A roofline model has been utilized to assess the performance of the kernels and apply appropriate optimization strategies. In particular, the neighbor search algorithm, accounting for almost a third of the overall compute time, features an efficient Space-Filling Curve (SFC) as well as an optimized octree construction procedure. The memory-bound interaction vector computation, accounting for almost two thirds of the overall compute time, features fixed-size memory pre-allocation and an efficient data ordering to reduce memory transactions and cost of dynamic memory operations i.e. allocation and deallocation. As a case study, the numerical simulation results of water jet deviation by the rotating buckets in a Pelton turbine is presented and compared to available experimental data. For that case, a speedup by a factor of almost six times has been achieved on a single NVIDIA® Tesla™ P100-SXM2-16 GB GPU with GP100 Pascal architecture compared to a dual CPU node equipped with two Broadwell Intel® Xeon® E5-2690 v4 CPUs with 28 total physical cores.

Large-scale parallel computation for earthquake response spectrum analysis

PurposeAs a practical engineering method, earthquake response spectra play an important role in seismic hazard assessment and in seismic design of structures. However, the computing scale and the efficiency of commercial software restricted the solution of complex structures. There is a clear need of developing large-scale and highly efficient finite element procedures for response spectrum analysis.Design/methodology/approachIn this paper, the kernel theories for earthquake response spectra are deduced and the corresponding parallel solution flow via the modal superposition method is presented. Based on the algorithm and the parallel data structure of JAUMIN framework, a parallel finite element (FE) solution module is established. Using the solution procedure on a supercomputer equipped with up to thousands of processors, the correctness and parallel scalability of the algorithm are evaluated via numerical experiments of typical engineering examples.FindingsThe results show that the solution module has the same precision as the commercial FE software ANSYS; the maximum solution scale achieves 154 million degrees of freedom (DOFs) with a favorable parallel computing efficiency, going far beyond the computing ability of the commercial FE software.Originality/valueThe solution scale in this paper is very challenging for the large-scale parallel computing of structural dynamics and will promote the dynamic analysis ability of complex facilities greatly.

Randomized Approximate Nearest Neighbor Search with Limited Adaptivity

We study the complexity of parallel data structures for approximate nearest neighbor search in d -dimensional Hamming space {0,1} d . A classic model for static data structures is the cell-probe model [27]. We consider a cell-probe model with limited adaptivity , where given a k ≥1, a query is resolved by making at most k rounds of parallel memory accesses to the data structure. We give two randomized algorithms that solve the approximate nearest neighbor search using k rounds of parallel memory accesses: —a simple algorithm with O ( k (log d ) 1/ k ) total number of memory accesses for all k ≥1; —an algorithm with O ( k +(1/ k log d ) O (1/ k ) ) total number of memory accesses for all sufficiently large k . Both algorithms use data structures of polynomial size. We prove an Ω(1/ k (log d ) 1/ k ) lower bound for the total number of memory accesses for any randomized algorithm solving the approximate nearest neighbor search within k ≤log log d /2log log log d rounds of parallel memory accesses on any data structures of polynomial size. This lower bound shows that our first algorithm is asymptotically optimal when k = O (1). And our second algorithm achieves the asymptotically optimal tradeoff between number of rounds and total number of memory accesses. In the extremal case, when k = O (log log d /log log log d ) is big enough, our second algorithm matches the Θ(log log d /log log log d ) tight bound for fully adaptive algorithms for approximate nearest neighbor search in [11].

MetaNIRS: A Relational Database for the Categorization, Organization and Meta-Analysis of Optical Functional Neuroimaging Research

MetaNIRS: A Relational Database for the Categorization, Organization and Meta-Analysis of Optical Functional Neuroimaging Research

A finite-difference method for the variable coefficient Poisson equation on hierarchical Cartesian meshes

We consider problems governed by a linear elliptic equation with varying coefficients across internal interfaces. The solution and its normal derivative can undergo significant variations through these internal boundaries. We present a compact finite-difference scheme on a tree-based adaptive grid that can be efficiently solved using a natively parallel data structure. The main idea is to optimize the truncation error of the discretization scheme as a function of the local grid configuration to achieve second-order accuracy. Numerical illustrations are presented in two and three-dimensional configurations.

Work‐efficient parallel union‐find

SummaryThe incremental graph connectivity (IGC) problem is to maintain a data structure that can quickly answer whether two given vertices in a graph are connected, while allowing more edges to be added to the graph. IGC is a fundamental problem and can be solved efficiently in the sequential setting using a solution to the classical union‐find problem. However, sequential solutions are not sufficient to handle modern‐day large, rapidly‐changing graphs where edge updates arrive at a very high rate. We present the first shared‐memory parallel data structure for union‐find (equivalently, IGC) that is both provably work‐efficient (ie, performs no more work than the best sequential counterpart) and has polylogarithmic parallel depth. We also present a simpler algorithm with slightly worse theoretical properties, but which is easier to implement and has good practical performance. Our experiments on large graph streams with various degree distributions show that it has good practical performance, capable of processing hundreds of millions of edges per second using a 20‐core machine.