Skil: an imperative language with algorithmic skeletons for efficient distributed programming

Efficient high-level parallel programming

Algorithmic skeletons are polymorphic higher-order functions representing common parallelization patterns and implemented in parallel. They can be used as the building blocks of parallel and distributed applications by integrating them into a sequential language. In this paper, we present a new approach to programming with skeletons. We integrate the skeletons into an imperative host language enhanced with higher-order functions and currying, as well as with a polymorphic type system. We thus obtain a high-level programming language which can be implemented very efficiently. After describing a series of skeletons which work with distributed arrays, we give two examples of parallel algorithms implemented in our language, namely matrix multiplication and a statistical numerical algorithm for solving partial differential equations. Run-time measurements show that we approach the efficiency of message-passing C up to a factor between 1 and 1.75.

Segmentation task plays an important role in image processing. In this paper, we attempt to extract information from images using texture analysis. Moreover, we propose characterization of pixels in images to define the similarity relation between them. These are based on textural information and findings of shortest paths in the graph representation of images. To reflect effectiveness of our method, we apply it to the benchmark Berkeley image database and we compare it to well-established image segmentation methods (sum and difference histograms for texture classification method, Mean-Shift method and mixture of Gaussian distributions method). The proposed approach achieves the best segmentation results measured by distance-based metrics. The experimental results show that our approach is efficient method for texture analysis and image segmentation.

Reconfiguring two shortest paths in a graph means modifying one shortest path to the other by changing one vertex at a time, so that all the intermediate paths are also shortest paths. This problem has several natural applications, namely: (a) revamping road networks, (b) rerouting data packets in a synchronous multiprocessing setting, (c) the shipping container stowage problem, and (d) the train marshalling problem. When modelled as graph problems, (a) is the most general case while (b), (c) and (d) are restrictions to different graph classes. We show that (a) is intractable, even for relaxed variants of the problem. For (b), (c) and (d), we present efficient algorithms to solve the respective problems. We also generalise the problem to when at most k (for some k >= 2) contiguous vertices on a shortest path can be changed at a time.

In various applications where the problem domain can be modeled into graphs, the shortest path computation in the graph is an indispensable challenge. In applications like online social networks and shortest route computation problems, the size of the graph is so large; the number of nodes have become close to hundreds of billions. Shortest path graph algorithms like SSSP (Single Source Shortest Path) and APSP (All Pairs Shortest Path) have low arithmetic intensity and irregular memory access patterns. The GPU implementation of many arithmetic and logical problems exceed the performance of the CPU system implementations. There is an increasing need for faster computation of shortest path in graphs for various applications. The objective of the work is to demonstrate that GPUs can efficiently perform shortest path computations on undirected weighted graphs considering space efficiency. For the implementation, GPUs supporting CUDA (Compute Unified Device Architecture) programming have been used. Additionally a space efficient approach called Triangular Matrix Method has been used.

The radius-stepping algorithm is an efficient, parallelixable algorithm for finding the shortest paths in graphs. It solved the problem in Δ-Stepping algorithm, which has no known theoretical bounds fur general graphs. 1" this paper, we describe a parallel privacy-preserving method for finding SingleSource Shortest Paths (SSSP). Our optimized method is based on the Radius-Stepping algorithm. The method is implemented on iop of the Secure Multiparty Computation (SMC) Sharemiiid platform. We have reshaped the radius-stepping algorithm to work on vectors representing the graph in a SIMD manner, in order to enable a fast execution using the secret-sharing based SMC protocol set of Sharemind. The results of the real implementation show an efficient method that reduced the execution time hundreds of times iii comparison with a standard case of the privacy-preserving radius-stepping and Δ-Stepping algorithms.

We present the buffer heap , a cache-oblivious priority queue that supports Delete-Min , Delete , and a hybrid Insert / Decrease-Key operation in O (1/ B log 2 N / M ) amortized block transfers from main memory, where M and B are the (unknown) cache size and block size, respectively, and N is the number of elements in the queue. We introduce the notion of a slim data structure that captures the situation when only a limited portion of the cache, which we call a slim cache , is available to the data structure to retain data between data structural operations. We show that a buffer heap automatically adapts to such an environment and supports all operations in O (1/λ + 1/ B log 2 N /λ) amortized block transfers each when the size of the slim cache is λ. Our results provide substantial improvements over known trivial cache performance bounds for cache-oblivious priority queues with Decrease-Keys . Using the buffer heap, we present cache-oblivious implementations of Dijkstra’s algorithm for undirected and directed single-source shortest path (SSSP) problems for graphs with non-negative real edge-weights. On a graph with n vertices and m edges, our algorithm for the undirected case performs O ( n + m / B log 2 n / M ) block transfers and for the directed case performs O (( n + m / B ) ċ log 2 n / B ) block transfers. These results give the first non-trivial cache-oblivious bounds for the SSSP problem on general graphs. For the all-pairs shortest path (APSP) problem on weighted undirected graphs, we incorporate slim buffer heaps into multi-buffer-buffer-heaps and use these to improve the cache-aware cache complexity. We also present a simple cache-oblivious APSP algorithm for unweighted undirected graphs that performs O ( mn / B log M / B n / B ) block transfers. This matches the cache-aware bound and is a substantial improvement over the previous cache-oblivious bound for the problem.

We consider the shortest paths between all pairs of nodes in a directed or undirected complete graph with edge lengths which are uniformly and independently distributed in [0, 1]. We show that die longest of these paths is bounded by c log n/n almost surely, where c is a constant and n is the number of nodes. Our bound is the best possible up to a constant. We apply this result to some well-known problems and obtain several algorithmic improvements over existing results. Our results hold with obvious modifications to random (as opposed to complete) graphs and to any distribution of weights whose density is positive and bounded from below at a neighborhood of zero. As a corollary of our proof we get a new result concerning the diameter of random graphs.

We consider digit expansions \(n=\sum_{i=0}^l \epsilon_iq^i\) in redundant number systems to base q with \(-(q-1)\le \epsilon_i\le q-1\) and consider such an expansion as minimal, if \(l + \sum\nolimits_{i = 0}^l {|\varepsilon _i |} \) is minimal. We describe an efficient algorithm for determining a minimal representation and give an explicit characterization of optimal representations for odd q.

We present a general toolbox, based on new vertex sparsifiers, for designing data structures to maintain shortest paths in graphs undergoing edge insertions and/or deletions. In particular, we obtain the following results:

This paper presents the first Learning Automaton-based solution to the dynamic single source shortest path problem. It involves finding the shortest path in a single-source stochastic graph topology where there are continuous probabilistic updates in the edge-weights. The algorithm is significantly more efficient than the existing solutions, and can be used to find the "statistical" shortest path tree in the "average" graph topology. It converges to this solution irrespective of whether there are new changes in edge-weights taking place or not. In such random settings, the proposed learning automata solution converges to the set of shortest paths. On the other hand, the existing algorithms will fail to exhibit such a behavior, and would recalculate the affected shortest paths after each weight-change. The important contribution of the proposed algorithm is that all the edges in a stochastic graph are not probed, and even if they are, they are not all probed equally often. Indeed, the algorithm attempts to almost always probe only those edges that will be included in the shortest path graph, while probing the other edges minimally. This increases the performance of the proposed algorithm. All the algorithms were tested in environments where edge-weights change stochastically, and where the graph topologies undergo multiple simultaneous edge-weight updates. Its superiority in terms of the average number of processed nodes, scanned edges and the time per update operation, when compared with the existing algorithms, was experimentally established. The algorithm can be applicable in domains ranging from ground transportation to aerospace, from civilian applications to military, from spatial database applications to telecommunications networking.

Computing shortest paths is a fundamental operation in processing graph data. In many real-world applications, discovering shortest paths between two vertices empowers us to make full use of the underlying structure to understand how vertices are related in a graph, e.g. the strength of social ties between individuals in a social network. In this paper, we study the shortest-path-graph problem that aims to efficiently compute a shortest path graph containing exactly all shortest paths between any arbitrary pair of vertices on complex networks. Our goal is to design an exact solution that can scale to graphs with millions or billions of vertices and edges. To achieve high scalability, we propose a novel method, Query-by-Sketch (QbS), which efficiently leverages offline labelling (i.e., precomputed labels) to guide online searching through a fast sketching process that summarizes the important structural aspects of shortest paths in answering shortest-path-graph queries. We theoretically prove the correctness of this method and analyze its computational complexity. To empirically verify the efficiency of QbS, we conduct experiments on 12 real-world datasets, among which the largest dataset has 1.7 billion vertices and 7.8 billion edges. The experimental results show that QbS can answer shortest-path graph queries in microseconds for million-scale graphs and less than half a second for billion-scale graphs.

Enhancements to a visual dataflow language called Show-and-Tell (STL) are described. These enhancements enrich STL by a polymorphic-type system similar to the one used in ML, and they introduce user-definable higher-order functions. A short overview of STL is given, and the concept of higher-order functions is discussed.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Finding shortest distances and paths have always been a crucial area of study. In this article, we have proposed a linear time pre-processing method for optimization of shortest path and distance algorithms, for an undirected weighted graph with non-negative edges. In this approach, certain parts of a graph are grouped together as subgraphs termed as optimized deterministic routing areas (ODRAs). Each ODRA has a unique representative element called optimized proxy. The input graph is reduced by replacing ODRAs with optimized proxies and the new reduced graph is used for the shortest path and distance queries. This is a linear time pre-processing stage which helps in significant decrease in computation time for finding shortest distances and paths in graphs. The lower bound and upper bound of time complexity of the proposed algorithm is O(n/2) and O(n) respectively.

Globally optimal sequencing of optimal reactive dispatch control adjustments to minimize operational losses in transmission systems by graph shortest path, parallel computing, and dynamic programming