Parallel Minimum Spanning Forest Computation using Sparse Matrix Kernels

Sparse linear algebra includes the fundamental and important operations in various large-scale scientific computing and real-world applications. There exists performance bottleneck for sparse linear algebra since it mainly contains the memory-bound computations with low arithmetic intensity. How to improve its performance has increasingly become a focus of research efforts. Using parallel computing techniques to accelerate sparse linear algebra is currently the most popular method, while facing various challenges, e.g., large-scale data brings difficulties in storage, and the sparsity of data leads to irregular memory accesses and parallel load imbalance. Therefore, this article provides a comprehensive overview on acceleration of sparse linear algebra operations using parallel computing platforms, where we focus on four main classifications: sparse matrix-vector multiplication (SpMV), sparse matrix-sparse vector multiplication (SpMSpV), sparse general matrix-matrix multiplication (SpGEMM), and sparse tensor algebra. The takeaways from this article include the following: understanding the challenges of accelerating linear sparse algebra on various hardware platforms; understanding how structured data sparsity can improve storage efficiency; understanding how to optimize parallel load balance; understanding how to improve the efficiency of memory accesses; understanding how do the adaptive frameworks automatically select the optimal algorithms; and understanding recent design trends for acceleration of parallel sparse linear algebra.

This paper shows how to compile sparse array programming languages. A sparse array programming language is an array programming language that supports element-wise application, reduction, and broadcasting of arbitrary functions over dense and sparse arrays with any fill value. Such a language has great expressive power and can express sparse and dense linear and tensor algebra, functions over images, exclusion and inclusion filters, and even graph algorithms. Our compiler strategy generalizes prior work in the literature on sparse tensor algebra compilation to support any function applied to sparse arrays, instead of only addition and multiplication. To achieve this, we generalize the notion of sparse iteration spaces beyond intersections and unions. These iteration spaces are automatically derived by considering how algebraic properties annotated onto functions interact with the fill values of the arrays. We then show how to compile these iteration spaces to efficient code. When compared with two widely-used Python sparse array packages, our evaluation shows that we generate built-in sparse array library features with a performance of 1.4× to 53.7× when measured against PyData/Sparse for user-defined functions and between 0.98× and 5.53× when measured against SciPy/Sparse for sparse array slicing. Our technique outperforms PyData/Sparse by 6.58× to 70.3×, and (where applicable) performs between 0.96× and 28.9× that of a dense NumPy implementation, on end-to-end sparse array applications. We also implement graph linear algebra kernels in our system with a performance of between 0.56× and 3.50× compared to that of the hand-optimized SuiteSparse:GraphBLAS library.

This article analyzes problems of determining the shortest path and optimal route amongst the given stoppages. The model of the problem is presented as a directional graph, where nodes are pickup points (termed as stoppage point in database) and crossings outside stoppage points and edges are roads among stoppage points and crossings. Each node has some information attached to it: stoppageId, stoppageName, latitude, longitude and numberOfPassengers of the stop, maintenance organizations, and mark(s) of the crossing(s). All pickup points are connected by roads. These roads are considered as the edges of the graph. Edges also have information attached to it: roadId, source, destination, distance, time etc.We have selected Floyd Warshall algorithm to nd the shortest path between two stoppages. This algorithm works in two stages: in rst stage, it nds the shortest path between all stoppages, and in second stage it nds optimized route to visit some of these stoppages. The solution is displayed in the form of shortest distance and time between two locations. The program is written in java language. It uses 3 tables as input from database : nodes, vehicle details and road. This paper gives implementation outcome of Floyd Warshall algorithm to solve the all pairs shortestpath problem for directed road graph system. We have considered an example of a map of Pune. Keyword: Adjacency matrix,intermediate path,optimal route, shortest path,transitive closure I. Introduction Now days in the current scenario companies and schools provide transportation facilities to their employees and students from their organizations to their respective houses and vice versa. The purpose of this article is to present an interface between a traveling agency and its traveller so that, the subscribers can keep a track of the service they have subscribed.A key problem in public conveyance system is the computation of shortest paths between di erent locations for a given region. Sometimes this computation has to be done in real time. During the literature survey we found how di cult it is to nd the shortest path covering all pickup points and how to allocate available transport vehicles to these speci c routes manually. There is always a need to nd optimal path for their operational viability. So, just the idea that our system will help in e cient allocation of vehicles and shortest route creation to save time and fuel consumption. The system scope is to design such system for a small area of the city.

Linear algebra provides the building blocks for a wide variety of scientific and engineering simulation codes. Users of these codes face a world of continuously changing algorithms and high-performance implementations. In this paper, we describe new capabilities of our Lighthouse framework, whose goal is to match specific problems in the area of high-performance numerical computing with the best available solutions. Lighthouse's innovative strategy eliminates intensive reading of documents and automates the process for developing linear algebra software. Lighthouse provides a searchable taxonomy of popular but difficult to use numerical software for dense and sparse linear algebra while providing the user with the best algorithms for a given problem based on machine learning methods. We introduce the design of Lighthouse and show examples of its interface. We also present algorithm classification results for the preconditioned iterative linear solvers in the Parallel Extensible Toolkit for Scientific Computation (PETSc) and the Trilinos library.

The graph G is a pair of sets consisting of a vertex set V(G) and an edge set E(G), denoted by G = (V (G),E(G)). Coloring a graph involves assigning colors to each vertex, edge, or region such that no adjacent vertices, edges, or regions share the same color. A bijective function f∶ V (G) → {1,2,3,...,|V (G)|} is called a local edge antimagic coloring if for any two adjacent edges e_1 and e_2, they have different weights, w(e_1) ≠ w(e_2), where e = uv ∈ E(G) and w(e) = f (u)+f (v). The chromatic number is the term used in the context of local antimagic coloring, referring to the minimum number of colors derived from local antimagic labeling. This research discusses the local antimagic edge coloring on the Gear Graph (G_n) and the Semi Parachute Graph (SP_(2n-1)). The aim of the research is to determine the chromatic number of local antimagic edge coloring χlea(G) for the researched graphs. The method used in this research is pattern detection to derive the general pattern. Based on the analysis, the chromatic number of local antimagic edge coloring is obtained for the Gear Graph (G_n) and the Semi Parachute Graph (SP_(2n-1)) are χlea (G_n)=n + 2 and χlea(SP_(2n-1) )=n+ 2.

The efficiency of a sparse linear algebra operation heavily relies on the ability of the sparse matrix storage format to exploit the computing power of the underlying hardware. Since no format is universally better than the others across all possible kinds of operations and computers, sparse linear algebra software packages should provide facilities to easily implement and integrate new storage formats within a sparse linear algebra application without the need to modify it; it should also allow to dynamically change a storage format at run-time depending on the specific operations to be performed. Aiming at these important features, we present an Object Oriented design model for a sparse linear algebra package which relies on Design Patterns. We show that an implementation of our model can be efficiently achieved through some of the unique features of the Fortran 2003 language. Experimental results show that the proposed software infrastructure improves the modularity and ease of use of the code at no performance loss.

The paper considers two problems: computation of shortest paths on triangle surfaces and calculation of principal curvatures at vertices of triangle surfaces. A technique that allows us to compute smoother and shorter paths using intermediate admissible directions and linear interpolation of potential functions is proposed. Conventional methods that compute the curvature in nodes of triangle surfaces are based on processing only adjacent vertices. They are non stable because triangle meshes contain frequently oscillating errors in positions of the vertices. We propose a simple practical method that accounts for larger neighborhoods of vertices. The kriging method aimed to the sparse representation of specific surface parts (aesthetic regions) is sketched. Preliminary numerical results are presented.

Let Φ ~ = ( G , w ) be a connected weighted graph and A ( Φ ~ ) be its adjacency matrix. The rank r ( G , w ) of Φ ~ is defined as the rank of its adjacency matrix A ( Φ ~ ) . For a given underlying graph G, the girth g ( G ) (or simply g) is the length of a shortest cycle (shortest graph-theoretic distance) in G. In this paper, we establish the bound r ( G , w ) ≥ g ( G ) − 2 for any weighted graph ( G , w ) . Furthermore, we characterize the cases where equality holds, specifically when r ( G , w ) = g − 2 and r ( G , w ) = g . Our results extend previous work on ordinary graphs by Zhou et al. (Linear Algebra Appl., 2021), signed graphs by Wu et al. (Linear Algebra Appl., 2022), and complex unit gain graphs by Khan (Linear Algebra Appl., 2024) to the setting of weighted graphs.

Due to the importance of linear algebra and matrix operations in data analytics, there is significant interest in using relational query optimization and processing techniques for evaluating (sparse) linear algebra programs. In particular, in recent years close connections have been established between linear algebra programs and relational algebra that allow transferring optimization techniques of the latter to the former. In this paper, we ask ourselves which linear algebra programs in MATLANG correspond to the free-connex and q-hierarchical fragments of conjunctive first-order logic. Both fragments have desirable query processing properties: free-connex conjunctive queries support constant-delay enumeration after a linear-time preprocessing phase, and q-hierarchical conjunctive queries further allow constant-time updates. By characterizing the corresponding fragments of MATLANG, we hence identify the fragments of linear algebra programs that one can evaluate with constant-delay enumeration after linear-time preprocessing and with constant-time updates. To derive our results, we improve and generalize previous correspondences between MATLANG and relational algebra evaluated over semiring-annotated relations. In addition, we identify properties on semirings that allow to generalize the complexity bounds for free-connex and q-hierarchical conjunctive queries from Boolean annotations to general semirings.

Computation of shortest paths on free-form surfaces is an important problem in ship design, robot motion planning, computation of medial axis transforms of trimmed surface patches, terrain navigation and NC machining. The objective of this paper is to provide an efficient and reliable method for computing the shortest path between two points on a free-form parametric surface and the shortest path between a point and a curve on a free-form parametric surface. These problems can be reduced to solving a two point boundary value problem. Our approach for solving the two point boundary value problem is based on a relaxation method relying on finite difference discretization. Examples illustrate our method.

If there is a function f : E(G) → {1, 2, 3, . . . , K} suchthat for any two adjacent vertices u and v of the samedegree, the sets S(u) and S(v) are equal, where S(u) ={f(uv), uv ∈ E(G)}, then a graph G = (V, E) is said tohave an adjacent vertex reducible edge coloring. The term“chromatic number of adjacent vertex reducible edge coloring” refers to the highest value of K. The purpose of this study is to ascertain the chromatic number for adjacent vertex reducible edge coloring of specific graphs, including mirror graphs, alternate triangular cycles, prism wheel graphs, double wheel graphs, antiprism graphs, crown (or sun) graphs, degree splitting graphs, and H-graph.

Sparse matrices and linear algebra are at the heart of scientific simulations. More than 70 sparse matrix storage formats have been developed over the years, targeting a wide range of hardware architectures and matrix types. Each format is developed to exploit the particular strengths of an architecture, or the specific sparsity patterns of matrices, and the choice of the right format can be crucial in order to achieve optimal performance. The adoption of dynamic sparse matrices that can change the underlying data-structure to match the computation at runtime without introducing prohibitive overheads has the potential of optimizing performance through dynamic format selection.In this paper, we introduce Morpheus, a library that provides an efficient abstraction for dynamic sparse matrices. The adoption of dynamic matrices aims to improve the productivity of developers and end-users who do not need to know and understand the implementation specifics of the different formats available, but still want to take advantage of the optimization opportunity to improve the performance of their applications. We demonstrate that by porting HPCG to use Morpheus, and without further code changes, 1) HPCG can now target heterogeneous environments and 2) the performance of the Sparse Matrix-Vector Multiplication (SpMV) kernel is improved up to 2.5× and 7× on CPUs and GPUs respectively, through runtime selection of the best format on each MPI process.

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.

An adjacent vertex distinguishing edge coloring of a graph $$G$$ is a proper edge coloring of $$G$$ such that any pair of adjacent vertices admit different sets of colors. The minimum number of colors required for such a coloring of $$G$$ is denoted by $$\chi ^{\prime }_{a}(G)$$ . In this paper, we prove that if $$G$$ is a planar graph with girth at least 5 and $$G$$ is not a 5-cycle, then $$\chi ^{\prime }_{a}(G)\le \Delta +2$$ , where $$\Delta $$ is the maximum degree of $$G$$ . This confirms partially a conjecture in Zhang et al. (Appl Math Lett 15:623---626, 2002).

The problem of point-to-point shortest path computation in spatial networks is extensively studied with many approaches proposed to speed-up the computation. Most of the existing approaches make the simplifying assumption that weights (e.g., travel-time) of the network edges are constant. However, with real-world spatial networks the edge travel-times are time-dependent, where the arrival-time to an edge determines the actual travel-time of the edge. With this paper, we study the applicability of existing shortest path algorithms to real-world large time-dependent spatial networks. In addition, we evaluate the importance of considering time-dependent edge travel-times for route planning in spatial networks. We show that time-dependent shortest path computation can reduce the travel-time by 36% on average as compared to the static shortest path computation that assumes constant edge travel-times.