Shared-memory Multi-core Machines Research Articles

A Conflict-Resilient Lock-Free Linearizable Calendar Queue

In the last two decades, great attention has been devoted to the design of non-blocking and linearizable data structures, which enable exploiting the scaled-up degree of parallelism in off-the-shelf shared-memory multi-core machines. In this context, priority queues are highly challenging. Indeed, concurrent attempts to extract the highest-priority item are prone to create detrimental thread conflicts that lead to abort/retry of the operations. In this article, we present the first priority queue that jointly provides: (i) lock-freedom and linearizability; (ii) conflict resiliency against concurrent extractions; (iii) adaptiveness to different contention profiles; and (iv) amortized constant-time access for both insertions and extractions. Beyond presenting our solution, we also provide proof of its correctness based on an assertional approach. Also, we present an experimental study on a 64-CPU machine, showing that our proposal provides performance improvements over state-of-the-art non-blocking priority queues.

Efficient parallel graph trimming by arc-consistency

Given a large data graph, trimming techniques can reduce the search space by removing vertices without outgoing edges. One application is to speed up the parallel decomposition of graphs into strongly connected components (SCC decomposition), which is a fundamental step for analyzing graphs. We observe that graph trimming is essentially a kind of arc-consistency problem, and AC-3, AC-4, and AC-6 are the most relevant arc-consistency algorithms for application to graph trimming. The existing parallel graph trimming methods require worst-case \(\mathcal O(nm)\) time and worst-case \(\mathcal O(n)\) space for graphs with n vertices and m edges. We call these parallel AC-3-based as they are much like the AC-3 algorithm. In this work, we propose AC-4-based and AC-6-based trimming methods. That is, AC-4-based trimming has an improved worst-case time of \(\mathcal O(n+m)\) but requires worst-case space of \(\mathcal O(n+m)\); compared with AC-4-based trimming, AC-6-based has the same worst-case time of \(\mathcal O(n+m)\) but an improved worst-case space of \(\mathcal O(n)\). We parallelize the AC-4-based and AC-6-based algorithms to be suitable for shared-memory multi-core machines. The algorithms are designed to minimize synchronization overhead. For these algorithms, we also prove the correctness and analyze time complexities with the work-depth model. In experiments, we compare these three parallel trimming algorithms over a variety of real and synthetic graphs on a multi-core machine, where each core corresponds to a worker. Specifically, for the maximum number of traversed edges per worker by using 16 workers, AC-3-based traverses up to 58.3 and 36.5 times more edges than AC-6-based trimming and AC-4-based trimming, respectively. That is, AC-6-based trimming traverses much fewer edges than other methods, which is meaningful especially for implicit graphs. In particular, for the practical running time, AC-6-based trimming achieves high speedups over graphs with a large portion of trimmable vertices.

Analyzing stochastic reward nets by model checking and parallel simulation

This paper deals with Stochastic Reward Nets (SRN), which are a powerful extension of Generalized Stochastic Petri Nets (GSPN). SRN have proved their usefulness in modelling and analysis of performance, availability and reliability of complex timed systems. SRN are supported by special-case tools like the Stochastic Petri Net Package (SPNP) which enables both analytic (based on Markov Reward Models) and simulative studies. The work described in this paper argues that there is still a gap in SRN analysis concerning functional correctness and non-deterministic property checking. Toward this a novel approach is proposed, which is based on two developed tools. First a formal reduction of SRN onto the Timed Automata (TA) of the popular Uppaal toolbox was defined and implemented. The Uppaal reduction enables a more complete investigation of SRN models, not allowed by existing SRN tools. However, the practical use of Uppaal forbids to study the performance of large models. Then, an SRN kernel, inspired by the carried formal Uppaal modelling and reasoning, was achieved in Java using the Theatre actor system. The realization supports the parallel simulation of scalable models. The paper applies the developed tools to a realistic grid-computing model and reports some experimental results, together with good execution performance (speedup) when using a scalable version of the grid model on a shared memory multi-core machine.

GeoGraph

In many applications of graph processing, the input data is often generated from an underlying geometric point data set. However, existing high-performance graph processing frameworks assume that the input data is given as a graph. Therefore, to use these frameworks, the user must write or use external programs based on computational geometry algorithms to convert their point data set to a graph, which requires more programming effort and can also lead to performance degradation. In this paper, we present our ongoing work on the Geo- Graph framework for shared-memory multicore machines, which seamlessly supports routines for parallel geometric graph construction and parallel graph processing within the same environment. GeoGraph supports graph construction based on k-nearest neighbors, Delaunay triangulation, and b-skeleton graphs. It can then pass these generated graphs to over 25 graph algorithms. GeoGraph contains highperformance parallel primitives and algorithms implemented in C++, and includes a Python interface. We present four examples of using GeoGraph, and some experimental results showing good parallel speedups and improvements over the Higra library. We conclude with a vision of future directions for research in bridging graph and geometric data processing.

Parallel splitting solvers for the isogeometric analysis of the Cahn-Hilliard equation

Modeling tumor growth in biological systems is a challenging problem with important consequences for diagnosis and treatment of various forms of cancer. This growth process requires large simulation complexity due to evolving biological and chemical processes in living tissue and interactions of cellular and vascular constituents in living organisms. Herein, we describe with a phase-field model, namely the Cahn-Hilliard equation the intricate interactions between the tumors and their host tissue. The spatial discretization uses highly-continuous isogeometric elements. For fast simulation of the time-dependent Cahn-Hilliard equation, we employ an alternating directions implicit methodology. Thus, we reduce the original problems to Kronecker products of 1 D matrices that can be factorized in a linear computational cost. The implementation enables parallel multi-core simulations and shows good scalability on shared-memory multi-core machines. Combined with the high accuracy of isogeometric elements, our method shows high efficiency in solving the Cahn-Hilliard equation on tensor-product meshes.

Pipelined fission for stream programs with dynamic selectivity and partitioned state

There is an ever increasing rate of digital information available in the form of online data streams. In many application domains, high throughput processing of such data is a critical requirement for keeping up with the soaring input rates. Data stream processing is a computational paradigm that aims at addressing this challenge by processing data streams in an on-the-fly manner, in contrast to the more traditional and less efficient store-and-then process approach. In this paper, we study the problem of automatically parallelizing data stream processing applications in order to improve throughput. The parallelization is automatic in the sense that stream programs are written sequentially by the application developers and are parallelized by the system. We adopt the asynchronous data flow model for our work, which is typical in Data Stream Processing Systems (DSPS), where operators often have dynamic selectivity and are stateful. We solve the problem of pipelined fission, in which the original sequential program is parallelized by taking advantage of both pipeline parallelism and data parallelism at the same time. Our pipelined fission solution supports partitioned stateful data parallelism with dynamic selectivity and is designed for shared-memory multi-core machines. We first develop a cost-based formulation that enables us to express pipelined fission as an optimization problem. The bruteforce solution of this problem takes a long time for moderately sized stream programs. Accordingly, we develop a heuristic algorithm that can quickly, but approximately, solve the pipelined fission problem. We provide an extensive evaluation studying the performance of our pipelined fission solution, including simulations as well as experiments with an industrial-strength DSPS. Our results show good scalability for applications that contain sufficient parallelism, as well as close to optimal performance for the heuristic pipelined fission algorithm.

Novel Frequent Pattern Mining Algorithm Based on Parallelization Scheme

Frequent pattern mining (FPM) is a very important technique in data mining and has attracted a wide range of practical applications. Equivalent Class Clustering (Eclat) has been identified as one of the most efficient FPM algorithm. We present P-Eclat, a novel parallel FPM algorithm which is an improvement of the Eclat algorithm, where a partial breadth-first search is employed to achieve maximum parallelism. Our approach uses a TIDset representation of the vertical transaction lists across multiple threads on a CPU. Current parallelization techniques for mining frequent patterns don’t fully utilize benefits accrued from multi core shared memory machines. Our parallel mining approach reduces the synchronization requirements, maximizing independence of data and enhances scalability. We also introduce several optimization techniques to improve the algorithm’s performance. Experimental results show that P-Eclat algorithm outperforms both Eclat and dEclat algorithms.

Engineering Parallel String Sorting

We discuss how string sorting algorithms can be parallelized on modern multi-core shared memory machines. As a synthesis of the best sequential string sorting algorithms and successful parallel sorting algorithms for atomic objects, we first propose string sample sort. The algorithm makes effective use of the memory hierarchy, uses additional word level parallelism, and largely avoids branch mispredictions. Then we focus on NUMA architectures, and develop parallel multiway LCP-merge and -mergesort to reduce the number of random memory accesses to remote nodes. Additionally, we parallelize variants of multikey quicksort and radix sort that are also useful in certain situations. As base-case sorter for LCP-aware string sorting we describe sequential LCP-insertion sort which calculates the LCP array and accelerates its insertions using it. Comprehensive experiments on five current multi-core platforms are then reported and discussed. The experiments show that our parallel string sorting implementations scale very well on real-world inputs and modern machines.

Novel parallel method for association rule mining on multi-core shared memory systems

ShaFEM: a novel association rule mining method for multi-core shared memory systems.ShaFEM self-adapts to data characteristic to run fast on sparse and dense databases.ShaFEM uses two mining strategies and dynamically switching between them.ShaFEM applies its new lock free solution, new data structure named XFP-tree.ShaFEM is up to 5.8 times faster and 7.1 times less memory than the compared method. Association rule mining (ARM) is an important task in data mining with many practical applications. Current methods for association rule mining have shown unstable performance for different database types and under-utilize the benefits of multi-core shared memory machines. In this paper, we address these issues by presenting a novel parallel method for finding frequent patterns, the most computational intensive phase of ARM. Our proposed method, named ShaFEM, combines two mining strategies and applies the most appropriate one to each data subset of the database to efficiently adapt to the data characteristics and run fast on both sparse and dense databases. In addition, our newlock-free design minimizes the synchronization needs and maximizes the data independence to enhance the scalability. The new structure lends itself well to dynamic job scheduling resulting in a well-balanced load on the new multi-core shared memory architectures. We have evaluated ShaFEM on 12-core multi-socket servers and found that our method run up to 5.8 times faster and consumes memory up to 7.1 times less than the state-of-the-art parallel method. For some test cases, ShaFEM can save up to 4.9days of execution time over the compared method.

Multicore Parallelization of Min-Cost Flow for CAD Applications

Computational complexity has been the primary challenge of many very large scale integration computer-aided design (CAD) applications. The emerging multicore and many-core microprocessors have the potential to offer scalable performance improvements. How to explore the multicore resources to speed up CAD applications is thus a natural question but also a huge challenge for CAD researchers. This paper proposes a methodology to explore concurrency via nondeterministic transactional models, and to program them on multicore processors for CAD applications. Various run-time scheduling implementations on multicore shared-memory machines are discussed and the most efficient one is identified. The proposed methodology is applied to the min-cost flow problem which has been identified as the key problem in many design optimizations, from wire-length optimization in detailed placement to timing-constrained voltage assignment. A concurrent algorithm for min-cost flow has been developed based on the methodology. Experiments on voltage island generation in floorplanning have demonstrated its efficiency and scalable speedup over different numbers of cores.

Scalable, Parallel Best-First Search for Optimal Sequential Planning

Large-scale, parallel clusters composed of commodity processors are increasingly available, enabling the use of vast processing capabilities and distributed RAM to solve hard search problems. We investigate parallel algorithms for optimal sequential planning, with an emphasis on exploiting distributed memory computing clusters. In particular, we focus on an approach which distributes and schedules work among processors based on a hash function of the search state. We use this approach to parallelize the A* algorithm in the optimal sequential version of the Fast Downward planner. The scaling behavior of the algorithm is evaluated experimentally on clusters using up to 128 processors, a significant increase compared to previous work in parallelizing planners. We show that this approach scales well, allowing us to effectively utilize the large amount of distributed memory to optimally solve problems which require hundreds of gigabytes of RAM to solve. We also show that this approach scales well for a single, shared-memory multicore machine.

Parallel modal analysis with concurrent distributed objects

This paper presents a novel object-oriented implementation of component mode synthesis and mode superposition for dynamic finite element analysis. Interfaces are used extensively to maximize program maintainability and flexibility. Parallelization is achieved using ‘concurrent distributed objects’ (facilitated by Microsoft.NET) instead of the message passing approach. The methodology allows consistency in modelling and implementation; this eases program development. It also results in better program portability across memory architectures. Tests on a cluster of computers and on a shared memory multi-core machine demonstrate the effectiveness of the proposed implementation.