Parallel Breadth-first Search Research Articles

Parallel BFS through pennant data structure with reducer hyper‐object based data hiding for 3D mesh images

AbstractData hiding refers to the technique employed to conceal sensitive data within various forms of multimedia, such as video, audio, text, 2D images, 3D images, and more, while also being able to successfully extract said information from the multimedia file. Although numerous data hiding techniques exist for 2D images, research on data hiding in 3D images is still in its early stages. Current 3D image steganography methods suffer from limitations in terms of embedding capacity and time complexity. To overcome these difficulties, we propose a novel 3D image steganographic technique using Parallel Breadth First Search (PBFS) with hyper‐object. Our approach utilizes the PBFS searching strategy, along with layer synchronization, to embed private information within the vertices of the 3D mesh images. To maximize the effectiveness of the process and minimize time, cost, complexity, and execution, we involved the data structure “bag” to parallelize the BFS. The implementation of bags is based on the pennant data structure. This methodology obtained an impressive Embedding Capacity (EC) of 9.00 bits per vertex (bpv) while maintaining superior visual quality and time complexity. Consequently, the proposed methodology holds great potential for widespread utilization across numerous sectors, including private and government organizations such as intelligence agencies, intellectual property rights management, cloud data security, defense, covert communication, medical imagery, and more.

A parallel Breadth-First Search using shared memory level-synchronization

Breadth-first search (BFS) stands as a cornerstone in graph exploration techniques, enabling systematic traversal of a provided graph. As the digital era continues to burgeon, there has been a marked upswing in the need to process vast graph-based data sets. To harness the power of such data effectively, it becomes imperative to use computational tools efficiently. Parallelizing BFS emerges as a pivotal strategy in this regard, leveraging the expansive capabilities of multiprocessor systems to maximize efficiency. This manuscript introduces a level-synchronous parallel BFS that is predicated on the shared-memory model. Recognizing the potential pitfalls of such an approach, especially regarding overhead induced by implicit barriers and critical sections, meticulous optimization techniques are infused into the model. These strategies are not mere afterthoughts; they are woven into the fabric of the design, ensuring smooth operations even when scaled. To validate the efficacy of this model, a rigorous assessment is carried out using the Graph500 benchmark. This offers insights into the performance scale of the parallel BFS algorithm, especially focusing on its speedup in relation to the number of operational threads. Concluding this exploration, the paper delineates prospective avenues for refining and further enhancing the proposed parallel implementation, aiming for even greater efficiencies in future endeavors.

Efficient parallelism in Breadth-First Search: A comprehensive analysis and implementation

The Breadth-First Search (BFS) entails a systematic traversal of a given graph, G = (V, E), layer by layer, starting from a specific vertex. Recognized as a cornerstone methodology for graph exploration, the importance of BFS has skyrocketed, especially with the increasing demands of graph-based data processing. However, as the vertex count expands, traditional serial implementations reveal their limitations, faltering in terms of time and space efficiency. This paper aims to contrast the efficiencies of standard BFS with its parallelized iteration. Introducing a shared-memory model of level-synchronous parallel BFS, the approach integrates optimizations to navigate the challenges posed by implicit barriers and critical sections. Employing the Graph500 benchmark, this parallel methodology is meticulously evaluated, highlighting the speedup concerning various thread counts. Initial findings unveil a compelling pattern: speedup generally correlates positively with the number of active threads. However, if the thread count breaches the system's inherent capacity, the speedup hits a plateau, showing only marginal fluctuations without significant increases. These statistical revelations not only vouch for the advantages of BFS parallelization but also emphasize a critical insight: judiciously increasing thread count, up to a system-specified limit, can yield peak efficiency.

Hypergraph-based locality-enhancing methods for graph operations in Big Data applications

The need for speeding up data analytics increases inevitably due to the need for extracting valuable information from social media, data generated by smart devices with sensors, patterns of people’s communications over the web, items viewed and bought by global-scale customers, cloud applications, etc., all of which take part in the “Big Data.” Such kind of interaction data is very well represented as sparse graphs to enable the graph analytics, which requires efficient underlying kernels. The breadth-first search (BFS)-based traversal is a commonly used kernel in graph algorithms such as the betweenness centrality algorithm for centrality analysis. In this work, we focus on parallel BFS operations and propose hypergraph-based combinatorial models that aim at reducing cache misses and hence exploiting data locality during the parallel BFS operations. Our models are based on finding new vertex visit orders so that locality in accessing the data associated with vertices is exploited. Experiments on graphs arising in a wide range of applications show that our proposed models achieve on average 9% performance improvement in the CPU-based Ligra data analytics framework.

Fast and efficient parallel breadth-first search with power-law graph transformation

In the big data era, graph computing is widely used to exploit the hidden value in real-world graphs in various scenarios such as social networks, knowledge graphs, web searching, and recommendation systems. However, the random memory accesses result in inefficient use of cache and the irregular degree distribution leads to substantial load imbalance. Breadth-First Search (BFS) is frequently utilized as a kernel for many important and complex graph algorithms. In this paper, we describe a preprocessing approach using Reverse Cuthill-Mckee (RCM) algorithm to improve data locality and demonstrate how to achieve an efficient load balancing for BFS. Computations on RCM-reordered graph data are also accelerated with SIMD executions. We evaluate the performance of the graph preprocessing approach on Kronecker graphs of the Graph500 benchmark and real-world graphs. Our BFS implementation on RCM-reordered graph data achieves 326.48 MTEPS/W (mega TEPS per watt) on an ARMv8 system, ranking 2nd on the Green Graph500 list in June 2020 (the 1st rank uses GPU acceleration).

Identification of Influential Modules Considering Design Change Impacts Based on Parallel Breadth-First Search and Bat Algorithm.

Modular design is a widely used strategy that meets diverse customer requirements. Close relationships exist between parts inside a module and loose linkages between modules in the modular products. A change of one part or module may cause changes of other parts or modules, which in turn propagate through a product. This paper aims to present an approach to analyze the associations and change impacts between modules and identify influential modules in modular product design. The proposed framework explores all possible change propagation paths (CPPs), and measures change impact degrees between modules. In this article, a design structure matrix (DSM) is used to express dependence relationships between parts, and change propagation trees of affected parts within module are constructed. The influence of the affected part in the corresponding module is also analyzed, and a reachable matrix is employed to determine reachable parts of change propagation. The parallel breadth-first algorithm is used to search propagation paths. The influential modules are identified according to their comprehensive change impact degrees that are computed by the bat algorithm. Finally, a case study on the grab illustrates the impacts of design change in modular products.

Parallel BFS implementing optimized decomposition of space and kMC simulations for diffusion of vacancies for quantum storage

We present a novel breadth-first search (BFS) algorithm based on the notion of temporal evolvability that is adaptable to various multicore architectures for simulating diffusion of vacancies in hexagonal silicon carbide (4H-SiC) for information storage. The algorithm is formulated in the semi-ring algebraic framework of BFS and incorporates a real-space grid decomposition to optimize the number of nodes that are evaluated in each frontier of the evolution.Scaling characteristics are first evaluated from performance runs for two formulations: (i) recursive depth-first search (DFS) and (ii) semi-ring implementations of BFS. The results for a real-space grid implementation of BFS are then presented. We demonstrate that each new iteration reduces the communication overhead, enhancing performance. A comparison of the real-space grid based BFS with a kinetic Monte Carlo (kMC) algorithm is also presented for the case of diffusion without the influence of the Coulomb interaction. The efficient parallel implementations of this latter approach enables simulations of larger systems than those studied before.

GPU implementation of Borůvka’s algorithm to Euclidean minimum spanning tree based on Elias method

We present both sequential and data parallel approaches to build hierarchical minimum spanning forest (MSF) or tree (MST) in Euclidean space (EMSF/EMST) for applications whose input N points are uniformly or boundedly distributed in Euclidean space. Each iteration of the sequential approach takes O(N) time complexity through combining Borůvka’s algorithm with an improved component-based neighborhood search algorithm, namely sliced spiral search, which is a newly proposed improvement to Bentley’s spiral search for finding a component graph’s closest outgoing point on the plane. It works based on the uniqueness property in Euclidean space, and allows O(1) time complexity for one search from a query point to find the component’s closest outgoing point at different iterations of Borůvka’s algorithm. The data parallel approach includes a newly proposed two-direction breadth-first search (BFS) implementation on graphics processing unit (GPU) platform, which is specialized for selecting a spanning tree’s shortest outgoing edge. This GPU two-direction parallel BFS enables a tree traversal operation to start from any one of its vertex acting as root. These GPU parallel implementations work by assigning N threads with one thread associated to one input point, one thread occupies O(1) local memory and the whole algorithm occupies O(N) global memory. Experiments are conducted on both uniformly distributed data sets and TSPLIB database. We evaluate computation time of the proposed approaches on more than 80 benchmarks with size N growing up to 106 points on personal laptop.

Reducing communication in parallel graph search algorithms with software caches

In many scientific and computational domains, graphs are used to represent and analyze data. Such graphs often exhibit the characteristics of small-world networks: few high-degree vertexes connect many low-degree vertexes. Despite the randomness in a graph search, it is possible to capitalize on the characteristics of small-world networks and cache relevant information of high-degree vertexes. We applied this idea by caching remote vertex ids in a parallel breadth-first search benchmark. Our experiment with different implementations demonstrated significant performance improvements over the reference implementation in several configurations, using 64 to 1024 cores. We proposed a system design in which resources are dedicated exclusively to caching and shared among a set of nodes. Our evaluation demonstrates that this design reduces communication and has the potential to improve performance on large-scale systems in which the communication cost increases significantly with the distance between nodes. We also tested a memcached system as the cache server finding that its generic protocol, which does not match our usage semantics, hinders significantly the potential performance improvements and suggested that a generic system should also support a basic and lightweight communication protocol to meet the needs of high-performance computing applications. Finally, we explored different configurations to find efficient ways to utilize the resources allocated to solve a given problem size; to this extent, we found utilizing half of the compute cores per allocated node improves performance, and even in this case, caching variants always outperform the reference implementation.

An Adaptive Parallel Algorithm for Computing Connected Components

We present an efficient distributed memory parallel algorithm for computing connected components in undirected graphs based on Shiloach-Vishkin’s PRAM approach. We discuss multiple optimization techniques that reduce communication volume as well as load-balance the algorithm. We also note that the efficiency of the parallel graph connectivity algorithm depends on the underlying graph topology. Particularly for short diameter graph components, we observe that parallel Breadth First Search (BFS) method offers better performance. However, running parallel BFS is not efficient for computing large diameter components or large number of small components. To address this challenge, we employ a heuristic that allows the algorithm to quickly predict the type of the network by computing the degree distribution and follow the optimal hybrid route. Using large graphs with diverse topologies from domains including metagenomics, web crawl, social graph and road networks, we show that our hybrid implementation is efficient and scalable for each of the graph types. Our approach achieves a runtime of 215 seconds using 32 K cores of Cray XC30 for a metagenomic graph with over 50 billion edges. When compared against the previous state-of-the-art method, we see performance improvements up to 24 $\times$ .

Efficient Breadth-First Search on Massively Parallel and Distributed-Memory Machines

There are many large-scale graphs in real world such as Web graphs and social graphs. The interest in large-scale graph analysis is growing in recent years. Breadth-First Search (BFS) is one of the most fundamental graph algorithms used as a component of many graph algorithms. Our new method for distributed parallel BFS can compute BFS for one trillion vertices graph within half a second, using large supercomputers such as the K-Computer. By the use of our proposed algorithm, the K-Computer was ranked 1st in Graph500 using all the 82,944 nodes available on June and November 2015 and June 2016 38,621.4 GTEPS. Based on the hybrid BFS algorithm by Beamer (Proceedings of the 2013 IEEE 27th International Symposium on Parallel and Distributed Processing Workshops and PhD Forum, IPDPSW ’13, IEEE Computer Society, Washington, 2013), we devise sets of optimizations for scaling to extreme number of nodes, including a new efficient graph data structure and several optimization techniques such as vertex reordering and load balancing. Our performance evaluation on K-Computer shows that our new BFS is 3.19 times faster on 30,720 nodes than the base version using the previously known best techniques.

Large-Scale Graph Processing Analysis using Supercomputer Cluster

Graph implementation is widely use in various sector such as automotive, traffic, image processing and many more. They produce graph in large-scale dimension, cause the processing need long computational time and high specification resources. This research addressed the analysis of implementation large-scale graph using supercomputer cluster. We impelemented graph processing by using Breadth-First Search (BFS) algorithm with single destination shortest path problem. Parallel BFS implementation with Message Passing Interface (MPI) used supercomputer cluster at High Performance Computing Laboratory Computational Science Telkom University and Stanford Large Network Dataset Collection. The result showed that the implementation give the speed up averages more than 30 times and eficiency almost 90%.

A Reconfigurable Architecture for the Detection of Strongly Connected Components

The Strongly Connected Components (SCCs) detection algorithm serves as a keystone for many graph analysis applications. The SCC execution time for large-scale graphs, as with many other graph algorithms, is dominated by memory latency. In this article, we investigate the design of a parallel hardware architecture for the detection of SCCs in directed graphs. We propose a design methodology that alleviates memory latency and problems with irregular memory access. The design is composed of 16 processing elements dedicated to parallel Breadth-First Search (BFS) and eight processing elements dedicated to finding intersection in parallel. Processing elements are organized to reuse resources and utilize memory bandwidth efficiently. We demonstrate a prototype of our design using the Convey HC-2 system, a commercial high-performance reconfigurable computing coprocessor. Our experimental results show a speedup of as much as 17× for detecting SCCs in large-scale graphs when compared to a conventional sequential software implementation.

BFS-4K: An Efficient Implementation of BFS for Kepler GPU Architectures

Breadth-first search (BFS) is one of the most common graph traversal algorithms and the building block for a wide range of graph applications. With the advent of graphics processing units (GPUs), several works have been proposed to accelerate graph algorithms and, in particular, BFS on such many-core architectures. Nevertheless, BFS has proven to be an algorithm for which it is hard to obtain better performance from parallelization. Indeed, the proposed solutions take advantage of the massively parallelism of GPUs but they are often asymptotically less efficient than the fastest CPU implementations. This paper presents BFS-4K , a parallel implementation of BFS for GPUs that exploits the more advanced features of GPU-based platforms (i.e., NVIDIA Kepler) and that achieves an asymptotically optimal work complexity. The paper presents different strategies implemented in BFS-4K to deal with the potential workload imbalance and thread divergence caused by any actual graph non-homogeneity. The paper presents the experimental results conducted on several graphs of different size and characteristics to understand how the proposed techniques are applied and combined to obtain the best performance from the parallel BFS visits. Finally, an analysis of the most representative BFS implementations for GPUs at the state of the art and their comparison with BFS-4K are reported to underline the efficiency of the proposed solution.

From Distributed Memory Cycle Detection to Parallel LTL Model Checking

In [J. Barnat, L. Brim, and J. Chaloupka. Parallel Breadth-First Search LTL Model-Checking. In 18th IEEE International Conference on Automated Software Engineering (ASE'03), pages 106–115. IEEE Computer Society, Oct. 2003.] we proposed a parallel graph algorithm for detecting cycles in very large directed graphs distributed over a network of workstations. The algorithm employs back-level edges as computed by the breadth first search. In this paper we describe how to turn the algorithm into an explicit state distributed memory LTL model checker by extending it with detection of accepting cycles, counterexample generation and partial order reduction. We discuss these extensions and show experimental results.

COPS: cooperative problem solving using DCOM

We present a framework that utilizes Distributed Component Object Model (DCOM) for distributed problem solving. The Cooperative Problem Solving (COPS) system provides for the coding and execution of a parallel algorithm by a number of networked computers running Microsoft Windows. We show the effectiveness of the COPS system by implementing parallel breadth-first search used in conjunction with a branch-and-bound algorithm for the Traveling Salesman Problem.

Parallel breadth-first search algorithms for trees and graphs

Parallel Breadth-First Search (BFS) algorithms for ordered trees and graphs on a shared memory model of a Single Instruction-stream Multiple Data-stream computer are proposed. The parallel BFS algorithm for trees computes the BFS rank of eachnode of an ordered tree consisting of n nodes in time of 0(β log n) when 0(n 1+1/β) processors are used, β being an integer greater than or equal to 2. The parallel BFS algorithm for graphs produces Breadth-First Spanning Trees (BFSTs) of a directedgraph G having n nodes in time 0(log d.log n) using 0(n 3) processors, where d is the diameter of G If G is a strongly connected graph or a connected undirected graph the BFS algorithm produces n BFSTs, each BFST having a different start node.

Parallel Computations in Graph Theory

In parallel computation two approaches are common, namely unbounded parallelism and bounded parallelism. In this paper both approaches will be considered with respect to graph theoretical algorithms. The problem of unbounded parallelism is studied in § 2 where some lower and upper bounds on different graph properties for directed and undirected graphs are presented. In § 3 we mention bounded parallelism and three different K-parallel graph search techniques, namely K-depth search, breadth-depth search, and breadth-first search. Each parallel algorithm is analyzed with respect to the optimal serial algorithm. It is shown that for sufficiently dense graphs the parallel breadth-first search technique is very close to the optimal bound.