In this paper we consider the problem of identifying intersections between two sets of d-dimensional axis-parallel rectangles. This is a common operation that arises in many agent-based simulation studies, and is of central importance in the context of High Level Architecture (HLA), where it is at the core of the Data Distribution Management (DDM) service. Several realizations of the DDM service have been proposed; however, many of them are either inefficient or inherently sequential. We propose a parallel version of the Sort-Based Matching algorithm for shared-memory multiprocessors. Sort-Based Matching is one of the most efficient serial algorithms for the DDM problem, but is quite difficult to parallelize because of data dependencies. We describe the algorithm and compute its asymptotic running time; we complete the analysis by assessing its performance and scalability through extensive experiments on two commodity multicore systems based on a dual socket Intel Xeon processor, and a single socket Intel Core i7 processor.
Only few parallel solutions for DDM and interest matching @cite_15 have been proposed. Among them, the authors of this paper have proposed the ITM algorithm for computing intersections among @math -rectangles @cite_10 . ITM is based on an interval tree data structure, and after the tree is built, exhibits an embarrassingly parallel structure. The performance evaluation reported in @cite_10 shows that the sequential implementation of ITM is competitive with the sequential implementation of SBM .
@cite_15 @cite_10
1975191193 2001104644 1556166295 2151690061
Identifying intersections among a set of d-dimensional rectangular regions (d-rectangles) is a common problem in many simulation and modeling applications. Since algorithms for computing intersections over a large number of regions can be computationally demanding, an obvious solution is to take advantage of the multiprocessing capabilities of modern multicore processors. Unfortunately, many solutions employed for the Data Distribution Management service of the High Level Architecture are either inefficient, or can only partially be parallelized. In this paper we propose the Interval Tree Matching(ITM) algorithm for computing intersections among d-rectangles. ITMis based on a simple Interval Tree data structure, and exhibits an embarrassingly parallel structure. We implement the ITM algorithm, and compare its sequential performance with two widely used solutions(brute force and sort-based matching). We also analyze the scalability of ITM on shared-memory multicore processors. The results show that the sequential implementation of ITM is competitive with sort-based matching, moreover, the parallel implementation provides good speed upon multicore processors. In distribution simulation based on High-level architecture (HLA), data distribution management (DDM) is one of HLA services for the purpose of filtering the unnecessary data transferring over the network. DDM admits the sending federates and the receiving federates to express their interest using update regions and subscription regions in a multidimensional routing space. There are several matching algorithms to obtain overlap information between the update regions and subscription regions. When the number of regions increase sharply, the matching process is time consuming. However, the existing algorithms is hard to be parallelized to take advantage of the computing capabilities of multi-core processors. To reduce the computational overhead of region matching, we propose a parallel algorithm based on order relation to accelerate the matching process. The new matching algorithm adopts divide-and-conquer approach to divide the regions into multiple region bound sublists, each of which comprises parts of region bounds. To calculate the intersection inside and amongst the region bound sublists, two matching rules are presented. This approach has good performance since it performs region matching on the sublists parallel and does not require unnecessary comparisons within regions in different sublists. Theoretical analysis has been carried out for the proposed algorithm and experimental result shows that the proposed algorithm has better performance than major existing DDM matching algorithms. This paper presents efficient dataflow schemes for parallel string matching. Two subproblems known as the exact matching and the k-mismatches problems are covered. Three parallel algorithms based on multiple input (and output) streams are presented. Time complexities of these parallel algorithms are O((n d)+ spl alpha ), O spl les spl alpha spl les m, where n and m represent lengths of reference and pattern strings (n spl Gt m) and d represents the number of streams used (the degree of parallelism). We can control the degree of parallelism by using variable number (d) of input (and output) streams. These performances are better than those found in the literature. These algorithms present three different methods to design special purpose systolic array hardware for string matching. With linear systolic array architecture, m PEs are needed for serial design and d*m PEs are needed for parallel design. The greedy sequential algorithm for maximal independent set (MIS) loops over the vertices in an arbitrary order adding a vertex to the resulting set if and only if no previous neighboring vertex has been added. In this loop, as in many sequential loops, each iterate will only depend on a subset of the previous iterates (i.e. knowing that any one of a vertex's previous neighbors is in the MIS, or knowing that it has no previous neighbors, is sufficient to decide its fate one way or the other). This leads to a dependence structure among the iterates. If this structure is shallow then running the iterates in parallel while respecting the dependencies can lead to an efficient parallel implementation mimicking the sequential algorithm. In this paper, we show that for any graph, and for a random ordering of the vertices, the dependence length of the sequential greedy MIS algorithm is polylogarithmic (O(log^2 n) with high probability). Our results extend previous results that show polylogarithmic bounds only for random graphs. We show similar results for greedy maximal matching (MM). For both problems we describe simple linear-work parallel algorithms based on the approach. The algorithms allow for a smooth tradeoff between more parallelism and reduced work, but always return the same result as the sequential greedy algorithms. We present experimental results that demonstrate efficiency and the tradeoff between work and parallelism.