Destination Vertex Research Articles

Dynamic-ACTS - A Dynamic Graph Analytics Accelerator For HBM-Enabled FPGAs

Graph processing frameworks suffer performance degradation from under-utilization of available memory bandwidth, because graph traversal often exhibits poor locality. A prior work, ACTS [ 24 ], accelerates graph processing with FPGAs and High Bandwidth Memory (HBM). ACTS achieves locality by partitioning vertex-update messages (based on destination vertex IDs) generated online after active edges have been processed. This work introduces Dynamic-ACTS which builds on ideas in ACTS to support dynamic graphs. The key innovation is to use a hash table to find the edges to be updated. Compared to Gunrock, a GPU graph engine, Dynamic-ACTS achieves a geometric mean speedup of 1.5X, with a maximum speedup of 4.6X. Compared to GraphLily, an FPGA-HBM graph engine, Dynamic-ACTS achieves a geometric speedup of 3.6X, with a maximum speedup of 16.5X. Our results also showed a geometric mean power reduction of 50% and a mean reduction of energy-delay product of 88% over Gunrock. Compared to GraSU, an FPGA graph updating engine, Dynamic-ACTS achieves an average speedup of 15X.

STEP: Sequence of time-aligned edge plots

We present sequence of time-aligned edge plots (STEP): a sequence- and edge-scalable visualization of dynamic networks and, more broadly, graph ensembles. We construct the graph sequence by ordering the individual graphs based on specific criteria, such as time for dynamic networks. To achieve scalability with respect to long sequences, we partition the sequence into equal-sized subsequences. Each subsequence is represented by a horizontal axis placed between two vertical axes. The horizontal axis depicts the order within the subsequence, while the two vertical axes depict the source and destination vertices. Edges within each subsequence are depicted as segmented lines extending from the source vertices on the left to the destination vertices on the right throughout the entire subsequence, and only the segments corresponding to the sequence members where the edges occur are drawn. By partitioning the sequence, STEP provides an overview of the graphs’ structural changes and avoids aspect ratio distortion. We showcase the utility of STEP for two realistic datasets. Additionally, we evaluate our approach by qualitatively comparing it against three state-of-the-art techniques using synthetic graphs with varying complexities. Furthermore, we evaluate the generalizability of STEP by applying it to a graph ensemble dataset from the architecture domain.

The Rabin numbers of enhanced hypercubes

The ω-Rabin number rω(G) and strong ω-Rabin number rω⁎(G) are two effective parameters to assess transmission latency and fault tolerance of an interconnection network G. As determining the Rabin number of a general graph is NP-complete, we consider the Rabin number of the enhanced hypercube Qn,k which is a variant of the hypercube Qn. For n≥k≥5, we prove that rω(Qn,k)=rω⁎(Qn,k)=d(Qn,k) for 1≤ω<n−⌊k2⌋; rω(Qn,k)=rω⁎(Qn,k)=d(Qn,k)+1 for n−⌊k2⌋≤ω≤n+1, where d(Qn,k) is the diameter of Qn,k. In addition, we present algorithms to construct internally disjoint paths of length at most rω⁎(Qn,k) from a source vertex to other ω (1≤ω≤n+1) destination vertices (not necessarily distinct) in Qn,k.

Fault-tolerant unicast paths constructive algorithms in a family of recursive networks

ABSTRACT In parallel and distributed systems, interconnection networks and data center networks are two crucial networks. They are also crucial parts of high-performance computing and cloud computing services. With the rapid growth of high-performance computing and cloud computing, both networks are growing in size. At the same time, vertex faults are unavoidable. In computer/communication networks, unicast refers to one-to-one communication between the source vertex and the destination vertex. Fault-tolerant routing of vertices in networks is an important problem that has been widely discussed. In this paper, for a class of recursive networks with less than g -restrict connectivity fault vertices and each fault-free vertex having at least g fault-free neighbors, we provide a fault-tolerant unicast path design algorithm in this study. The algorithm’s correctness is then demonstrated and its time complexity is analyzed. In addition, the results obtained can be used for unknown and known networks, including the dragonfly network, DCell, and generalized DCell.

Application of Dijkstra's Algorithm to Determine the Shortest Route from City Center to Medan City Tourist Attractions

Tourist attractions are very interesting things to visit in an area that we are living. It is no exception when visiting the city of Medan, the tourists will visit interesting tourist spots in the city of Medan. To optimize time so that you can visit all tourist attractions in Medan City, you need to map locations so that you can create the shortest route that can be used to take all the tourist sites you want to visit in Medan City. The shortest route of a trip will shorten the travel time. Likewise in terms of seeking experts. When requesting a route from one point (start point) to another location (destination point), usually the result that comes out is the "shortest path" from the starting point to the destination point. The shortest path is the problem of finding a path between two or more vertices in a minimum weighted graph. To simplify solving the shortest path problem, a search algorithm is needed. Dijkstra's algorithm solves the problem of finding the shortest path between two vertices in a weighted graph with the smallest total number, by finding the shortest distance between the initial vertex and other vertices, so that the path formed from the initial vertex to the destination vertex has the smallest total weight. In this study, Dijkstra's algorithm looks for the shortest path based on the smallest weight from one point to another, so that it can help provide a choice of paths. Based on the trials of Dijkstra's algorithm, it has the ability to find the shortest path, because in this algorithm each graph is selected an edge with a minimum weight that connects the selected vertices with other unselected vertices.

Routing Permutations on Spectral Expanders via Matchings

We consider the following matching-based routing problem. Initially, each vertex v of a connected graph G is occupied by a pebble which has a unique destination $$\pi (v)$$ . In each round the pebbles across the edges of a selected matching in G are swapped, and the goal is to route each pebble to its destination vertex in as few rounds as possible. We show that if G is a sufficiently strong d-regular spectral expander then any permutation $$\pi $$ can be achieved in $$O(\log n)$$ rounds. This is optimal for constant d and resolves a problem of Alon et al. (SIAM J Discret Math 7:516–530, 1994).

ECONOMICALLY EFFICIENT CACHE FRIENDLY ADJACENCY LIST FOR GRAPH PROCESSING ALGORITHMS

Graphs are a fundamental part of computer science and various scientific fields. They are used in numerous applications, from social networks to electronic design automation. Efficient graph representation is important for modern algorithms, especially in economical contexts, where resource-efficient implementations play a significant role by reducing the resource consumption. This is essential in environments where computing resources are a high priority. There are many representations of graphs as data structure. One of these types is adjacency list: it is collection of linked lists which shows the connection of source and destination vertices. Adjacency lists are more memory-efficient than adjacency matrices because they only allocate memory for vertices with at least one edge in the graph. However, traditional implementations of adjacency lists do not fully use the features provided by modern CPUs, such as the cache line. Our design of Adjacency List is cache friendly and is keeping the main structure of traditional implementation. The main idea is derived from C#’s dictionary implementation for hash tables, which uses one array combining all data that should be in linked lists. Our results show that cache friendly implementation of Adjacency list outperforms it in lookup and insertion operations.

Structural parameterizations of Tracking Paths problem

Given a graph G with source and destination vertices s,t∈V(G) respectively, Tracking Paths asks for a minimum set of vertices T⊆V(G), such that the sequence of vertices restricted to T encountered in each simple path from s to t is unique. The problem was proven NP-hard [3] and was found to admit a quadratic kernel when parameterized by the size of the desired solution [8]. Following recent trends, for the first time, we study Tracking Paths with respect to structural parameters of the input graph, parameters that measure how far the input graph is, from an easy instance. We prove that Tracking Paths admits fixed-parameter tractable (FPT) algorithms when parameterized by the following parameters: (i) size of a 2-dominating set, (ii) size of cluster vertex deletion set, and (iii) size of split deletion set. En route we also look at Vertex Cover parameterized by the size of edge clique cover and show it fixed-parameter tractable.

Algorithms for optimal min hop and foremost paths in interval temporal graphs

Path problems are fundamental to the study of graphs. Temporal graphs are graphs in which the edges connecting the vertices change with time. Min hop paths problem in a temporal graph is the problem of finding time respecting paths from source vertex to every destination vertex such that the path goes through minimum number of edges. Foremost paths problem in a temporal graph requires to find time respecting paths that arrive at the destination vertices at earliest possible time. In this paper we present algorithms to find min hop paths and foremost paths in interval temporal graphs. These algorithms are benchmarked against the fastest algorithms known for foremost and min-hop paths by Wu et al. (IEEE Trans Knowl Data Eng 28(11):2927–2942, 2016a. https://doi.org/10.1109/TKDE.2016.2594065) that work on contact sequence temporal graph model. On the available test data, our foremost path algorithm provides a speedup of up to 1800 over the fastest algorithm for contact sequence graphs; the speedup for our min-hop algorithm is up to 6700. We also demonstrate that interval temporal graph model on which our algorithms work represents a superset of contact sequence temporal graphs. We show that path problems exist that are NP-hard in interval temporal graph model but polynomial in the contact sequence temporal graph model in terms of the number of vertices and edges in the input graph. This is due to the fact that the contact sequence graph model may require much larger number of edges than the corresponding interval temporal graph to represent a given temporal graph.

Construction of Dual-CISTs on an Infinite Class of Networks

The main method to achieve fault-tolerant network systems is by exploiting and effectively utilizing the edge-disjoint and/or inner-vertex-disjoint paths between pairs of source and destination vertices. Completely independent spanning trees (CISTs for short) are powerful tools for reliable broadcasting/unicasting and secure message distribution. Particularly, it has been shown that two CISTs have an application on configuring a protection routing in IP networks, such as mobile ad hoc networks and relatively large (static) network topologies with scalability in [IEEE/ACM Trans. Netw., 27 (2019) 1112-1123]. Many results focus on CISTs in specific networks in the literature, however, few results are given on an infinite class of networks having common properties. In this article, we prove the existence of dual-CISTs in an infinite number of networks satisfying some Hamilton sufficient conditions. A unique algorithm to construct a CIST-partition is proposed, which can be applied to not only many kinds of networks, but our algorithm can also be implemented very easily in parallel or distributed systems satisfying the conditions. In addition, we make a comparative analysis between the proposed conditions and several known results on an infinite number of networks, the advantage of our result is significant. In particular, the bound in our conditions is sharp. The results will provide a powerful framework for the design of fault-tolerant network topologies and routing protocols for future networks.

Attack-Resilient Path Planning Using Dynamic Games With Stopping States

In this article, we consider a path planning problem on a graph, wherein a vehicle (defender) seeks to find an optimal path from a source to a destination vertex in the presence of an attacker. The defender is equipped with a countermeasure that can detect and permanently disable the attack if it occurs concurrently. We model the problem over an edge as a zero-sum multistage game played between the defender and the attacker with a stopping state, termed as the edge game. We analyze this game under <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">full information</i> , in which each player has complete knowledge of the past actions taken by the opponent at every stage. We also analyze the game under a <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">partial information structure</i> , wherein the defender obtains complete knowledge of the attacker’s actions only when the defender uses the countermeasure. We characterize the Nash equilibria of the edge game in both information structures with two actions per player and analyze its sensitivity to the game parameters. We then construct a meta-game using the edge game solutions to determine an attack-resilient path and compare it with an efficient novel heuristic with a constraint on the number of edges attacked. We illustrate our methodology through simulations in a Robot Operating System/Gazebo environment and with experiments on a ground robot.

Waypoint routing on bounded treewidth graphs

In the Waypoint Routing Problem one is given an undirected capacitated and weighted graph G, a source-destination pair s,t∈V(G) and a set W⊆V(G), of waypoints. The task is to find a walk which starts at the source vertex s, visits, in any order, all waypoints, ends at the destination vertex t, respects edge capacities, that is, traverses each edge at most as many times as is its capacity, and minimizes the cost computed as the sum of costs of traversed edges with multiplicities. We study the problem for graphs of bounded treewidth and present a new algorithm for the problem working in 2O(tw)⋅n time, significantly improving upon the previously known algorithms. We also show that this running time is optimal for the problem under Exponential Time Hypothesis.

Random Walks in Hypergraph

Random walks on graphs have been extensively used for a variety of graph-based problems such as ranking vertices, predicting links, recommendations, and clustering. However, many complex problems mandate a high-order graph representation to accurately capture the relationship structure inherent in them. Hypergraphs are particularly useful for such models due to the density of information stored in their structure. In this paper, we propose a novel extension to defining random walks on hypergraphs. Our proposed approach combines the weights of destination vertices and hyperedges in a probabilistic manner to accurately capture transition probabilities. We study and analyze our generalized form of random walks suitable for the structure of hypergraphs. We show the effectiveness of our model by conducting a text ranking experiment on a real world data set with a 9% to 33% improvement in precision and a range of 7% to 50% improvement in Bpref over other random walk approaches.

Approximating the Canadian Traveller Problem with Online Randomization

In this paper, we study online algorithms for the Canadian Traveller Problem defined by Papadimitriou and Yannakakis in 1991. This problem involves a traveller who knows the entire road network in advance, and wishes to travel as quickly as possible from a source vertex s to a destination vertex t, but discovers online that some roads are blocked (e.g., by snow) once reaching them. Achieving a bounded competitive ratio for the problem is PSPACE-complete. Furthermore, if at most k roads can be blocked, the optimal competitive ratio for a deterministic online algorithm is \(2k+1\), while the only randomized result known so far is a lower bound of \(k+1\). We show, for the first time, that a polynomial time randomized algorithm can outperform the best deterministic algorithms when there are at least two blockages, and surpass the lower bound of \(2k+1\) by an o(1) factor. Moreover, we prove that the randomized algorithm can achieve a competitive ratio of \(\big (1+ \frac{\sqrt{2}}{2} \big )k + \sqrt{2}\) in pseudo-polynomial time. The proposed techniques can also be exploited to implicitly represent multiple near-shortest s-t paths.

A genetic algorithm for the fuzzy shortest path problem in a fuzzy network

The shortest path problem (SPP) is an optimization problem of determining a path between specified source vertex s and destination vertex t in a fuzzy network. Fuzzy logic can handle the uncertainties, associated with the information of any real life problem, where conventional mathematical models may fail to reveal proper result. In classical SPP, real numbers are used to represent the arc length of the network. However, the uncertainties related with the linguistic description of arc length in SPP are not properly represented by real number. We need to address two main matters in SPP with fuzzy arc lengths. The first matter is how to calculate the path length using fuzzy addition operation and the second matter is how to compare the two different path lengths denoted by fuzzy parameter. We use the graded mean integration technique of triangular fuzzy numbers to solve this two problems. A common heuristic algorithm to solve the SPP is the genetic algorithm. In this manuscript, we have introduced an algorithmic method based on genetic algorithm for determining the shortest path between a source vertex s and destination vertex t in a fuzzy graph with fuzzy arc lengths in SPP. A new crossover and mutation is introduced to solve this SPP. We also describe the QoS routing problem in a wireless ad hoc network.

Who witnesses The Witness? Finding witnesses in The Witness is hard and sometimes impossible

We analyze the computational complexity of the many types of pencil-and-paper-style puzzles featured in the 2016 puzzle video game The Witness. In all puzzles, the goal is to draw a simple path in a rectangular grid graph from a start vertex to a destination vertex. The different puzzle types place different constraints on the path: preventing some edges from being visited (broken edges); forcing some edges or vertices to be visited (hexagons); forcing some cells to have certain numbers of incident path edges (triangles); or forcing the regions formed by the path to be partially monochromatic (squares), have exactly two special cells (stars), or be singly covered by given shapes (polyominoes) and/or negatively counting shapes (antipolyominoes). We show that any one of these clue types (except the first) is enough to make path finding NP-complete (“witnesses exist but are hard to find”), even for rectangular boards. Furthermore, we show that a final clue type (antibody), which necessarily “cancels” the effect of another clue in the same region, makes path finding Σ2-complete (“witnesses do not exist”), even with a single antibody (combined with many anti/polyominoes), and the problem gets no harder with many antibodies. On the positive side, we give a polynomial-time algorithm for monomino clues, by reducing to hexagon clues on the boundary of the puzzle, even in the presence of broken edges, and solving “subset Hamiltonian path” for terminals on the boundary of an embedded planar graph in polynomial time.

Problems on One Way Road Networks

A One-Way Road Network is an ordered pair $OWRN = (W_x,W_y)$ comprising of a set $W_x$ of $m$ directed horizontal roads along with another set $W_y$ of $n$ directed vertical roads. An $OWRN$ can also be viewed as a directed grid graph $GG=(V, E)$, where $V$ corresponds to intersections between every pair of horizontal and vertical roads, and there is a directed edge between every pair of consecutive vertices in $V$ in the same direction corresponding to that road. A vehicle $c$ is defined as a 3-tuple $(t,s,P)$, where $c$ starts moving at time $t$ and moves with a constant speed $s$ from its start vertex to destination vertex along pre-specified directed path $P$, unless a collision occurs. A collision between a pair of vehicles $c_i$ and $c_j$ $(i \ne j)$ occurs if they reach a vertex $v \in V$ (a junction in $OWRN$) orthogonally at the same time. A traffic configuration on an $OWRN$ is a 2-tuple $TC=( GG, C)$, where $C$ is a set of vehicles, each travelling on a pre-specified path on $GG$. A collision-free $TC$ is a traffic configuration without any collision. We prove that finding a maximum cardinality subset $C_{max}\subseteq C$, such that $TC = (GG, C_{max})$ is collision-free, is NP-hard. We also show that $GG$ can be preprocessed into a data-structure in $\mathcal{O}(n+m)$ time and space, such that the length of the shortest path between any pair of vertices in $GG$ can be computed in $\mathcal{O}(1)$ time and the shortest path can be computed in $\mathcal{O}(p)$ time, where $p$ is the number of vertices in the path.

Efficient FPGA-based graph processing with hybrid pull-push computational model

Hybrid pull-push computational model can provide compelling results over either of single one for processing real-world graphs. Programmability and pipeline parallelism of FPGAs make it potential to process different stages of graph iterations. Nevertheless, considering the limited on-chip resources and streamline pipeline computation, the efficiency of hybrid model on FPGAs often suffers due to well-known random access feature of graph processing. In this paper, we present a hybrid graph processing system on FPGAs, which can achieve the best of both worlds. Our approach on FPGAs is unique and novel as follow. First, we propose to use edge block (consisting of edges with the same destination vertex set), which allows to sequentially access edges at block granularity for locality while still preserving the precision. Due to the independence of blocks in the sense that all edges in an inactive block are associated with inactive vertices, this also enables to skip invalid blocks for reducing redundant computation. Second, we consider a large number of vertices and their associated edge-blocks to maintain a predictable execution history. We also present to switch models in advance with few stalls using their state statistics. Our evaluation on a wide variety of graph algorithms for many real-world graphs shows that our approach achieves up to 3.69x speedup over state-of-the-art FPGA-based graph processing systems.

NGraph: Parallel Graph Processing in Hybrid Memory Systems

Big data applications like graph processing are highly imposed on memory capacity. Byte-addressable non-volatile memory (NVM) technologies can offer much larger memory capacity, lower cost per bit relative to traditional DRAM. They are expected to play a crucial role in mitigating I/O operations for big data processing. However, since the NVMs show higher access latency and lower bandwidth compared with DRAM, it is still challenging to fully exploit the advantages of both the DRAM and NVM for graph processing. In this paper, we propose NGraph, a new parallel graph processing framework specially designed for hybrid memory systems. According to different access patterns of graph data, NGraph exploits memory heterogeneity-aware data placement strategies to avoid random accesses and frequent updates to NVM. NGraph partitions graph by destination vertices and exploits a task decomposition scheme to avoid data contention between multicores. Meanwhile, the NGraph balances the execution time of parallel graph data processing on multicores through a work-stealing strategy. Moreover, the NGraph also proposes software-based data pre-fetching to improve cache hit rate, and supports huge page to reduce address translation overhead. We evaluate NGraph using a hybrid memory emulator. The experimental results show that NGraph can achieve up to 48.28% performance improvement for several typical benchmarks compared with the state-of-the-art systems Ligra and Polymer.

(Weakly) Self-approaching geometric graphs and spanners

A geometric graph is called self-approaching, if for each (ordered) pair of vertices of the graph, there exists a self-approaching (directed) path between them. A path from a vertex u to a vertex v of the graph is called self-approaching, if for any point (not just vertex) x on the path, the distance between x and any point that starts at u and moves toward x is decreasing. A path is called an increasing-chord, if it is self-approaching from both sides, source to destination and destination to source. A geometric graph is called a self-approaching t-spanner, for t>1, if for each pair (u,v) of vertices of the graph, there exists a self-approaching path from u to v of length at most t times the Euclidean distance between u and v.In 2015, Dehkordi et al. (2015) [16] left the problem of the existence of an increasing-chord planar geometric graph for a set of points that lie along the sides of an acute triangle, as an open problem, but they did not mention anything about the case of an obtuse triangle. In this paper, we show that for each set of points on the boundary of an obtuse triangle, there exists an increasing-chord planar geometric graph. Moreover, we show that for each set of points on the boundary of an acute triangle, there exists an increasing-chord planar geometric graph using at most three Steiner points.We also introduce weakly self-approaching geometric graphs (spanners) as a variation of self-approaching geometric graphs (spanners). A weakly self-approaching path is defined similarly to a self-approaching path, except that when a point p on the path moves from the source to the destination, the Euclidean distance between p and the destination vertex (but not all the points on the path) decreases. A weakly self-approaching geometric graph (spanner) is defined by replacing “self-approaching” by “weakly self-approaching” in the above definition. In this paper, we show that for every point set S⊆Rd, there is a weakly self-approaching planar geometric graph spanning S. Furthermore, this study shows how to test in polynomial time, whether a given geometric graph is weakly self-approaching. Notably, the corresponding decision problem in the context of self-approaching geometric graphs in Rd with d≥3 is NP-hard.We also propose some algorithms for constructing a weakly self-approaching geometric t-spanner for a given point set and a real constant t>1. Also, we show that for every point set S on the boundary of any triangle, there exists an increasing-chord t-spanner spanning S and a weakly self-approaching t-spanner spanning S, both with O(kn) edges, in which k depends only on t.