The Parallel Boost Graph Library 2.0

The mixture of data in real life exhibits structure or connection property in nature. Typical data include biological data, communication network data, image data, etc. Graphs provide a natural way to represent and analyze these types of data and their relationships. For instance, more recently, graphs have found new applications in solving problems for emerging research fields such as social network analysis, design of robust computer network topologies, frequency allocation in wireless networks, and bioinformatics. Unfortunately, the related algorithms usually suffer from high computational complexity, since some of these problems are NP-hard. Therefore, in recent years, many graph models and optimization algorithms have been proposed to achieve a better balance between efficacy and efficiency. The aim of this Special Issue is to provide an opportunity for researchers and engineers from both academia and the industry to publish their latest and original results on graph models, algorithms, and applications to problems in the real world, with a focus on optimization and computational complexity.

The scalability and efficiency of graph applications are significantly constrained by conventional systems and their supporting programming models. Technology trends such as multicore, manycore, and heterogeneous system architectures are introducing further challenges and possibilities for emerging application domains such as graph applications. This paper explores the parallel execution of graphs that are generated using the Barnes–Hut algorithm to exemplify dynamic workloads. The workloads are expressed using the semantics of an exascale computing execution model called ParalleX. For comparison, results using conventional execution model semantics are also presented. We find improved load balancing during runtime and automatic parallelism discovery by using the advanced semantics for exascale computing.

Relational algebra forms a basis of primitive operations suitable for applications in graphs and networks, program analysis, deductive databases, and constraint logic programming. Despite its expressive power, relational algebra has not received the same attention in high-performance-computing research as more common primitives like stencil computations, floating-point operations, numerical integration, and sparse linear algebra. Furthermore, specific challenges in addressing representation and communication among distributed portions of a relation, especially for inherently imbalanced relations, have previously thwarted successful scaling of relational algebra applications to supercomputers. In this paper, we present a set of efficient algorithms to effectively parallelize and scale key relational algebra primitives. We introduce a hybrid hash-tree approach to representing distributed imbalanced relations and permitting efficient communication. Finally, we demonstrate the scalability of our implementation with a fixed-point algorithm computing the transitive closure of a large graph (generating over 276 billion edges) on 32,768 processes.

Complex applications in domains such as decision support systems and real time systems require a functionality that is achieved by combining the active and temporal database technologies. In this paper we present TALE, a Temporal Active Language and Execution model. TALE is a temporal active database programming language, combined with an execution model that enables a correct and efficient processing of operations. As such, TALE is a step in accommodating software engineering challenges in modern information systems. TALE primitives are presented using examples and an EBNF. The run-time control mechanism of the model is introduced and TALE properties, namely active and temporal capabilities, and reflective programming capabilities are discussed.

Significant efforts are being made at present to define, evaluate, and ultimately deploy, various forms of intelligent transportation systems (ITS). These systems permit the implementation of advanced traffic control strategies through the application of advanced surveillance, control and communication systems. Traditionally, the evaluation of the performance of these communication systems and traffic networks has been performed predominantly independent of each other. This paper describes the development and application of an extension to an ITS benefits evaluation model to permit a partially coupled evaluation of the communication system loading and the ATMS/ATIS functions. This extended model is capable of estimating dynamic local and network wide communication loadings that depend on the spatial and temporal traffic demands, the network topology, the characteristics of the communication hardware and the communication system operating rules. The model is applied in this paper to a simple hypothetical network to demonstrate the potential benefits of carrying out a partially coupled evaluation of communication system loading and traffic network efficiency. A sensitivity analysis was carried out to determine the impact of the fraction of ITS equipped vehicles and the level of congestion on the level of communication loadings. It was demonstrated that, as a result of congestion and traffic diversion, antenna communication loads did not uniformly increase in direct proportion to the average number of equipped vehicles entering the network.

Many graph processing applications consist of read-only workloads that need to perform low-latency traversals over large graphs. These traversals are inherently expensive, and storage and processing systems need to be optimized for them. The performance of secondary storage-based systems can be improved by caching locality-driven data in memory. Exploring the data reuse of graph objects in applications is important to decrease the page faults in the cache. However, graph applications can suffer from poor access locality, making caching of graph data challenging. Locality can be imposed through graph ordering algorithms that can be exploited by cache replacement algorithms. We propose a graph locality-aware cache replacement policy called LAC that exploits the serialization layout obtained by graph ordering techniques. We show that the spatial locality that is captured on disk pages offers temporal locality for subsequent accesses of cache pages, and this information can be used to make improved cache replacement decisions. We evaluate LAC against the popular GCLOCK algorithm for input graphs with different structural properties while running various query types. Our evaluation shows that LAC can outperform GCLOCK through page fault improvements by reducing latency up to 1.42X in simulation studies and up to 1.23X with integration into the Neo4j system.

Large-scale graphs can be analyzed by lightweight systems on a single server, e.g., GraphChi, X-Stream, and Grid-Graph. Studies indicate that graph algorithms have different performance impacted by partitioning schemes, scheduling strategies and execution models. Existing systems of singleserver graph processing often suffer from poor I/O locality, inefficient selective scheduling or expensive synchronization costs.In this paper, we propose AsyncStripe, an I/O efficient asynchronous graph system aiming at solving all these three problems on a single server. First, AsyncStripe adopts a 2--dimensional asymmetric graph partitioning scheme to enable optimized locality and fine selective-scheduling. Second, AsyncStripe utilizes an efficient stripe-based data access strategy, obtaining high disk bandwidth and smaller I/O amount. Third, AsyncStripe executes graph algorithms asynchronously with two kinds of consistency models, therefore reducing unnecessary intermediate I/O and accelerating the convergence speed.We implement the AsyncStripe prototype by modifying the GridGraph system. Experimental results show that Async-Stripe has better performance than state-of-the-art graph analysis systems. For traversal algorithms, e.g., BFS, Async-Stripe can outperform X-Stream and GridGraph in the computation speed by up to 10.18 and 4.59 times faster respectively. For sparse matrix multiplication algorithms, e.g., SpMV, AsyncStripe can outperform X-Stream and Grid-Graph by up to 463.89% and 50.97% faster respectively.

The article discusses the ideas expressed in the study by Yu.N. Oleinik and A.L. Zhuravlev, devoted to the problem of scientific traditions as a mechanism for the continuity of psychological knowledge. It is argued that the low interest of the psychological community in the targeted development of the problem, recorded in the study, also characterizes foreign studies of the history of psychology. At the same time, it is proposed to more clearly draw the line between scientific traditions as a subject of historical and psychological research and their study as a subject of targeted theoretical and methodological analysis. In the first case, scientific traditions are quite actively studied in the context of studying personalities, scientific schools, psychological institutes, etc. In the second case, scientific traditions really rarely become the subject of special theoretical and methodological analysis, which may be a consequence of the unsatisfactory state of the methodology of the history of psychology. It is shown that the analysis of scientific traditions is actually not included in the subject, tasks and methods of the modern history of psychology. The above allows us to assert that the methodology proposed by A.L. Zhuravlev and Yu.N. Oleynik “theoretical model for studying the totality of traditions in domestic psychology” is in demand and is aimed at developing the methodology of the history of psychology. The advantages of the proposed model are discussed, and questions of a theoretical, methodological, and historical-psychological nature that arise due to familiarity with it are formulated.

A significant role is played by visualization of complex projects as graphs with nodes and edges in the area of software engineering. A graphical visualization of the whole project is the best way to understand it as a whole and effectively comprehend the dependencies between the participating entities. Graph databases are always easy to understand and work with, when it comes to complex projects. Leveraging the concepts of graph database for software engineering education, plagiarism detection, component evaluation etc. can be accomplished. This paper shows how to make use of a graph database obtained from a Java project for plagiarism detection. Graph databases along with graph algorithms have great applications in the field of software testing, plagiarism detection, partial evaluation and many more.

Graph Algorithms and Applications 2

In the upcoming exa-scale era, the exploitation of data locality in parallel programs is very important because it benefits both program performance and energy efficiency. However, this is a hard topic for graph algorithms such as the Breadth First Search (BFS) due to the irregular data access patterns. This study analyzes the exploitation of data locality in the BFS and its impact on the energy efficiency with the Codelet fine-grain dataflow-inspired execution model. The Codelet Model more efficiently exploits data locality than the OpenMP-like execution models which traditionally focus on coarse-grain parallelism inside loops. A BFS algorithm is then given to exploit the locality between two loop iterations that belong to two different loops (inter-loop locality). This kind of locality can be exploited by the Codelet Model but not by traditional coarse-grain execution models like OpenMP. Tests were performed on fsim which is a simulation platform developed by Intel for the Ubiquitous High Performance Computing (UHPC) project to design future exa-scale architectures. The results show that this BFS algorithm saves up to 7% of the dynamic energy for memory accesses compared to a BFS implementation based on OpenMP loop scheduling.

Graph algorithms are used to implement data mining tasks on graph data-sets. Besides conducting the algorithms by the default deterministic manner, some graph processing frameworks, especially those supporting asynchronous execution model, provide interfaces for the algorithms to be executed in nondeterministic manner, which can improve the scalability and performance of the algorithm's executions. However, is the graph algorithm eligible for nondeterministic execution, and will the execution produce expected results? The literature gives few answers to these questions. In this paper, we study the nondeterministic execution of graph algorithms by considering the scenario where data dependences happen in the edges in graph processing frameworks that employ asynchronous execution model. Our study reveals that only by guaranteeing the atomicity of individual reads and writes, some algorithms (e.g., Graph traversal algorithms) can converge by recovering from corrupted intermediate results with nondeterministic execution, and thus tolerate even write-write conflicts, while some other algorithms (e.g., Fixed point iteration algorithms) can converge but tolerate only read-write conflicts. By conducting graph algorithms on real-world graphs in Graph Chi, and comparing their performances and results with deterministic executions, we find that their performance gains are generally scalable to the available processors with nondeterministic executions, and the results at convergence of fixed point iteration algorithms from nondeterministic executions exhibit larger variances from one run to another than their deterministic executions.

Many systems are designed to run graph algorithms efficiently in memory but they achieve only cache efficiency or work efficiency. We tackle this fundamental trade-off in existing systems by designing CoroGraph, a system that attains both cache efficiency and work efficiency for in-memory graph processing. CoroGraph adopts a novel hybrid execution model , which generates update messages at vertex granularity to prioritize promising vertices for work efficiency, and commits updates at partition granularity to share data access for cache efficiency. To overlap the random memory access of graph algorithms with computation, CoroGraph extensively uses coroutine , i.e., a lightweight function in C++ that can yield and resume with low overhead, to prefetch the required data. A suite of designs are incorporated to reap the full benefits of coroutine, which include prefetch pipeline, cache-friendly graph format, and stop-free synchronization. We compare CoroGraph with five state-of-the-art graph algorithm systems via extensive experiments. The results show that CoroGraph yields shorter algorithm execution time than all baselines in 18 out of 20 cases, and its speedup over the best-performing baseline can be over 2x. Detailed profiling suggests that CoroGraph achieves both cache efficiency and work efficiency with a low memory stall and a small number of processed edges.

Abstract

Distributed algorithms for graph searching require a high-performance CPU-efficient hash table that supports find-or-put. This operation either inserts data or indicates that it has already been added before. This paper focuses on the design and evaluation of such a hash table, targeting supercomputers. The latency of find-or-put is minimized by using one-sided RDMA operations. These operations are overlapped as much as possible to reduce waiting times for roundtrips. In contrast to existing work, we use linear probing and argue that this requires less roundtrips. The hash table is implemented in UPC. A peak-throughput of 114.9 million op/s is reached on an Infiniband cluster. With a load-factor of 0.9, find-or-put can be performed in 4.5μs on average. The hash table performance remains very high, even under high loads.