Searcharxiv⌕ Search

arXiv subjects

Peter Robinson

Publications and source records attributed to Peter Robinson.

At least 37 records · Page 2Linked to original sources

Distributed Algorithms for Large-Scale Graphs

Motivated by the increasing need for fast processing of large-scale graphs, we study a number of fundamental graph problems in a message-passing model for distributed computing, called $k$-machine model, where we have $k$ machines that jointly perform computations on $n$-node graphs. The graph is assumed to be partitioned in a balanced fashion among the $k$ machines, a common implementation in many real-world systems. Communication is point-to-point via bandwidth-constrained links, and the goal is to minimize the round complexity, i.e., the number of communication rounds required to finish a computation. We present a generic methodology that allows to obtain efficient algorithms in the $k$-machine model using distributed algorithms for the classical CONGEST model of distributed computing. Using this methodology, we obtain algorithms for various fundamental graph problems such as connectivity, minimum spanning trees, shortest paths, maximal independent sets, and finding subgraphs, showing that many of these problems can be solved in $\tilde{O}(n/k)$ rounds; this shows that one can achieve speedup nearly linear in $k$. To complement our upper bounds, we present lower bounds on the round complexity that quantify the fundamental limitations of solving graph problems distributively. We first show a lower bound of $Ω(n/k)$ rounds for computing a spanning tree of the input graph. This result implies the same bound for other fundamental problems such as computing a minimum spanning tree, breadth-first tree, or shortest paths tree. We also show a $\tilde Ω(n/k^2)$ lower bound for connectivity, spanning tree verification and other related problems. The latter lower bounds follow from the development and application of novel results in a random-partition variant of the classical communication complexity model.

cs.DC↗

Byzantine-Resilient Counting in Networks

We present two distributed algorithms for the {\em Byzantine counting problem}, which is concerned with estimating the size of a network in the presence of a large number of Byzantine nodes. In an $n$-node network ($n$ is unknown), our first algorithm, which is {\em deterministic}, finishes in $O(\log{n})$ rounds and is time-optimal. This algorithm can tolerate up to $O(n^{1 - γ})$ arbitrarily (adversarially) placed Byzantine nodes for any arbitrarily small (but fixed) positive constant $γ$. It outputs a (fixed) constant factor estimate of $\log{n}$ that would be known to all but $o(1)$ fraction of the good nodes. This algorithm works for \emph{any} bounded degree expander network. However, this algorithms assumes that good nodes can send arbitrarily large-sized messages in a round. Our second algorithm is {\em randomized} and most good nodes send only small-sized messages (Throughout this paper, a small-sized message is defined to be one that contains $O(\log{n})$ bits in addition to at most a constant number of node IDs.). This algorithm works in \emph{almost all} $d$-regular graphs. It tolerates up to $B(n) = n^{\frac{1}{2} - ξ}$ (note that $n$ and $B(n)$ are unknown to the algorithm) arbitrarily (adversarially) placed Byzantine nodes, where $ξ$ is any arbitrarily small (but fixed) positive constant. This algorithm takes $O(B(n)\log^2{n})$ rounds and outputs a (fixed) constant factor estimate of $\log{n}$ with probability at least $1 - o(1)$. The said estimate is known to most nodes, i.e., $\geq (1 - β)n$ nodes for any arbitrarily small (but fixed) positive constant $β$. To complement our algorithms, we also present an impossibility result that shows that it is impossible to estimate the network size with any reasonable approximation with any non-trivial probability of success if the network does not have sufficient vertex expansion.

cs.DC↗

Survey of Crosschain Communications Protocols

Crosschain communications allows information to be communicated between blockchains. Consensus in the context of crosschain communications relates to how participants on one blockchain are convinced of the state of a remote blockchain. It describes how parties associated with a source blockchain come to agreement and communicate with a destination blockchain such that information from the source blockchain can be trusted. This paper surveys crosschain communications protocols, presenting them based on the top-level usage scenarios they are trying to meet: value swapping, crosschain messaging, and blockchain pinning. It analyses how each protocol achieves crosschain consensus, what trust assumptions are made, their ability to operate successfully in Permissionless and Permissioned blockchains contexts, and whether the protocol delivers atomic updates across blockchains.

cs.CR↗

General Purpose Atomic Crosschain Transactions

The General Purpose Atomic Crosschain Transaction protocol allows composable programming across multiple Ethereum blockchains. It allows for inter-contract and inter-blockchain function calls that are both synchronous and atomic: if one part fails, the whole call execution tree of function calls is rolled back. The protocol operates on existing Ethereum blockchains without modification. It works for both public permissioned and consortium blockchains. Additionally, the protocol is expected to work across heterogeneous blockchains other than Ethereum. This paper describes the protocol, analyses it in terms of Gas usage and Finalised Block Periods for three scenarios: reading a value from one blockchain to another, writing a value from one blockchain to another, and a trade finance system involving five contracts on five blockchains with a complex call execution tree, and provides an initial security analysis that shows that the protocol has Safety and Liveness properties.

cs.CR↗

Enabling Machine Learning-Ready HPC Ensembles with Merlin

With the growing complexity of computational and experimental facilities, many scientific researchers are turning to machine learning (ML) techniques to analyze large scale ensemble data. With complexities such as multi-component workflows, heterogeneous machine architectures, parallel file systems, and batch scheduling, care must be taken to facilitate this analysis in a high performance computing (HPC) environment. In this paper, we present Merlin, a workflow framework to enable large ML-friendly ensembles of scientific HPC simulations. By augmenting traditional HPC with distributed compute technologies, Merlin aims to lower the barrier for scientific subject matter experts to incorporate ML into their analysis. In addition to its design, we describe some example applications that Merlin has enabled on leadership-class HPC resources, such as the ML-augmented optimization of nuclear fusion experiments and the calibration of infectious disease models to study the progression of and possible mitigation strategies for COVID-19.

cs.DC↗

Can We Break Symmetry with o(m) Communication?

We study the communication cost (or message complexity) of fundamental distributed symmetry breaking problems, namely, coloring and MIS. While significant progress has been made in understanding and improving the running time of such problems, much less is known about the message complexity of these problems. In fact, all known algorithms need at least $Ω(m)$ communication for these problems, where $m$ is the number of edges in the graph. We address the following question in this paper: can we solve problems such as coloring and MIS using sublinear, i.e., $o(m)$ communication, and if so under what conditions? [See full abstract in pdf]

cs.DC↗

The Complexity of Symmetry Breaking in Massive Graphs

The goal of this paper is to understand the complexity of symmetry breaking problems, specifically maximal independent set (MIS) and the closely related $β$-ruling set problem, in two computational models suited for large-scale graph processing, namely the $k$-machine model and the graph streaming model. We present a number of results. For MIS in the $k$-machine model, we improve the $\tilde{O}(m/k^2 + Δ/k)$-round upper bound of Klauck et al. (SODA 2015) by presenting an $\tilde{O}(m/k^2)$-round algorithm. We also present an $\tildeΩ(n/k^2)$ round lower bound for MIS, the first lower bound for a symmetry breaking problem in the $k$-machine model. For $β$-ruling sets, we use hierarchical sampling to obtain more efficient algorithms in the $k$-machine model and also in the graph streaming model. More specifically, we obtain a $k$-machine algorithm that runs in $\tilde{O}(βnΔ^{1/β}/k^2)$ rounds and, by using a similar hierarchical sampling technique, we obtain one-pass algorithms for both insertion-only and insertion-deletion streams that use $O(β\cdot n^{1+1/2^{β-1}})$ space. The latter result establishes a clear separation between MIS, which is known to require $Ω(n^2)$ space (Cormode et al., ICALP 2019), and $β$-ruling sets, even for $β= 2$. Finally, we present an even faster 2-ruling set algorithm in the $k$-machine model, one that runs in $\tilde{O}(n/k^{2-ε} + k^{1-ε})$ rounds for any $ε$, $0 \le ε\le 1$.

cs.DC↗

Robust Lower Bounds for Graph Problems in the Blackboard Model of Communication

We give lower bounds on the communication complexity of graph problems in the multi-party blackboard model. In this model, the edges of an $n$-vertex input graph are partitioned among $k$ parties, who communicate solely by writing messages on a shared blackboard that is visible to every party. We show that any non-trivial graph problem on $n$-vertex graphs has blackboard communication complexity $Ω(n)$ bits, even if the edges of the input graph are randomly assigned to the $k$ parties. We say that a graph problem is non-trivial if the output cannot be computed in a model where every party holds at most one edge and no communication is allowed. Our lower bound thus holds for essentially all key graph problems relevant to distributed computing, including Maximal Independent Set (MIS), Maximal Matching, ($Δ+1$)-coloring, and Dominating Set. In many cases, e.g., MIS, Maximal Matching, and $(Δ+1)$-coloring, our lower bounds are optimal, up to poly-logarithmic factors.

cs.DS↗

Network Size Estimation in Small-World Networks under Byzantine Faults

We study the fundamental problem of counting the number of nodes in a sparse network (of unknown size) under the presence of a large number of Byzantine nodes. We assume the full information model where the Byzantine nodes have complete knowledge about the entire state of the network at every round (including random choices made by all the nodes), have unbounded computational power, and can deviate arbitrarily from the protocol. Our main contribution is a randomized distributed algorithm that estimates the size of a network under the presence of a large number of Byzantine nodes. In particular, our algorithm estimates the size of a sparse, "small-world", expander network with up to $O(n^{1 - δ})$ Byzantine nodes, where $n$ is the (unknown) network size and $δ$ can be be any arbitrarily small (but fixed) positive constant. Our algorithm outputs a (fixed) constant factor estimate of $\log(n)$ with high probability; the correct estimate of the network size will be known to a large fraction ($(1 - ε)$-fraction, for any fixed positive constant $ε$) of the honest nodes. Our algorithm is fully distributed, lightweight, and simple to implement, runs in $O(\log^3{n})$ rounds, and requires nodes to send and receive messages of only small-sized messages per round; any node's local computation cost per round is also small.

cs.DC↗

Adaptive Accessible AR/VR Systems

Augmented, virtual and mixed reality technologies offer new ways of interacting with digital media. However, such technologies are not well explored for people with different ranges of abilities beyond a few specific navigation and gaming applications. While new standardization activities are investigating accessibility issues with existing AR/VR systems, commercial systems are still confined to specialized hardware and software limiting their widespread adoption among people with disabilities as well as seniors. This proposal takes a novel approach by exploring the application of user model-based personalization for AR/VR systems to improve accessibility. The workshop will be organized by experienced researchers in the field of human computer interaction, robotics control, assistive technology, and AR/VR systems, and will consist of peer reviewed papers and hands-on demonstrations. Keynote speeches and demonstrations will cover latest accessibility research at Microsoft, Google, Verizon and leading universities.

cs.HC↗

Layer 2 Atomic Cross-Blockchain Function Calls

The Layer 2 Atomic Cross-Blockchain Function Calls protocol allows composable programming across Ethereum blockchains. It allows for inter-contract and inter-blockchain function calls that are both synchronous and atomic: if one part fails, the whole call graph of function calls is rolled back. Existing atomic cross-blockchain function call protocols are Blockchain Layer 1 protocols, which require changes to the blockchain platform software to operate. Blockchain Layer 2 technologies such as the one described in this paper require no such changes. They operate on top of the infrastructure provided by the blockchain platform software. This paper introduces the protocol and a more scalable variant, provides an initial safety and liveness analysis, and presents the expected overhead of using this technology when compared to using multiple non-atomic single blockchain transactions. The overhead is analysed for three scenarios involving multiple blockchains: the Hotel and Train problem, Supply Chain with Provenance, and an Oracle. The protocol is shown to provide 93.8 or 186 cross-blockchain function calls per second for the Hotel and Train scenario when there are many travel agencies, for the standard and scalable variant of the protocol respectively, given the Ethereum client, Hyperledger Besu's performance of 375 tps, assuming a block period of one second, and assuming all transactions take the same amount of time to execute as the benchmark transactions.

cs.CR↗

Performance Overhead of Atomic Crosschain Transactions

Atomic Crosschain Transaction technology allows composable programming across permissioned Ethereum blockchains. It allows for inter-contract and inter-blockchain function calls that are both synchronous and atomic: if one part fails, the whole call graph of function calls is rolled back. This paper analyses the processing overhead of using this technique compared to using multiple standard non-atomic single blockchain transactions. The additional processing is analysed for three scenarios involving multiple blockchains: the Hotel - Train problem, Supply Chain with Provenance, and an Oracle. The technology is shown to reduce the performance of Hyperledger Besu from 375 tps to 39.5 tps if all transactions are instigated on one node, or approaching 65.2 tps if the transactions are instigated on a variety of nodes, for the Hotel-Train scenario.

cs.CR↗

Atomic Crosschain Transactions White Paper

Atomic Crosschain Transaction technology allows composable programming across private Ethereum blockchains. It allows for inter-contract and inter-blockchain function calls that are both synchronous and atomic: if one part fails, the whole call graph of function calls is rolled back. It is not based on existing techniques such as Hash Time Locked Contracts, relay chains, block header transfer, or trusted intermediaries. BLS Threshold Signatures are used to prove to validators on one blockchain that information came from another blockchain and that a majority of the validators of that blockchain agree on the information. Coordination Contracts are used to manage the state of a Crosschain Transaction and as a repository of Blockchain Public Keys. Dynamic code analysis and signed nested transactions are used together with live argument checking to ensure execution only occurs if the execution results in valid state changes. Contract Locking and Lockability enable atomic updates.

cs.CR↗

Latency, Capacity, and Distributed MST

We study the cost of distributed MST construction in the setting where each edge has a latency and a capacity, along with the weight. Edge latencies capture the delay on the links of the communication network, while capacity captures their throughput (in this case, the rate at which messages can be sent). Depending on how the edge latencies relate to the edge weights, we provide several tight bounds on the time and messages required to construct an MST. When edge weights exactly correspond with the latencies, we show that, perhaps interestingly, the bottleneck parameter in determining the running time of an algorithm is the total weight $W$ of the MST (rather than the total number of nodes $n$, as in the standard CONGEST model). That is, we show a tight bound of $\tildeΘ(D + \sqrt{W/c})$ rounds, where $D$ refers to the latency diameter of the graph, $W$ refers to the total weight of the constructed MST and edges have capacity $c$. The proposed algorithm sends $\tilde{O}(m+W)$ messages, where $m$, the total number of edges in the network graph under consideration, is a known lower bound on message complexity for MST construction. We also show that $Ω(W)$ is a lower bound for fast MST constructions. When the edge latencies and the corresponding edge weights are unrelated, and either can take arbitrary values, we show that (unlike the sub-linear time algorithms in the standard CONGEST model, on small diameter graphs), the best time complexity that can be achieved is $\tildeΘ(D+n/c)$. However, if we restrict all edges to have equal latency $\ell$ and capacity $c$ while having possibly different weights (weights could deviate arbitrarily from $\ell$), we give an algorithm that constructs an MST in $\tilde{O}(D + \sqrt{n\ell/c})$ time. In each case, we provide nearly matching upper and lower bounds.

cs.DC↗

Slow links, fast links, and the cost of gossip

Consider the classical problem of information dissemination: one (or more) nodes in a network have some information that they want to distribute to the remainder of the network. In this paper, we study the cost of information dissemination in networks where edges have latencies, i.e., sending a message from one node to another takes some amount of time. We first generalize the idea of conductance to weighted graphs by defining $ϕ_*$ to be the "critical conductance" and $\ell_*$ to be the "critical latency". One goal of this paper is to argue that $ϕ_*$ characterizes the connectivity of a weighted graph with latencies in much the same way that conductance characterizes the connectivity of unweighted graphs. We give near tight lower and upper bounds on the problem of information dissemination, up to polylogarithmic factors. Specifically, we show that in a graph with (weighted) diameter $D$ (with latencies as weights) and maximum degree $Δ$, any information dissemination algorithm requires at least $Ω(\min(D+Δ, \ell_*/ϕ_*))$ time % in the worst case. We show several variants of the lower bound (e.g., for graphs with small diameter, graphs with small max-degree, etc.) by reduction to a simple combinatorial game. We then give nearly matching algorithms, showing that information dissemination can be solved in $O(\min((D+Δ)\log^3{n}, (\ell_*/ϕ_*)\log n)$ time. This is achieved by combining two cases. We show that the classical push-pull algorithm is (near) optimal when the diameter or the maximum degree is large. For the case where the diameter and the maximum degree are small, we give an alternative strategy in which we first discover the latencies and then use an algorithm for known latencies based on a weighted spanner construction. (Our algorithms are within polylogarithmic factors of being tight both for known and unknown latencies.)

cs.DC↗

Application Level Authentication for Ethereum Private Blockchain Atomic Crosschain Transactions

Atomic Crosschain Transaction technology allows composable programming across private Ethereum blockchains. It allows for inter-contract and inter-blockchain function calls that are both synchronous and atomic: if one part fails, the whole call graph of function calls is rolled back. Traditional Ethereum contract functions can limit which accounts can call them by specialised application program logic. This is important as it allows application developers to specify which callers can execute functions that update contract state. In this paper we introduce the strategy required to restrict which contracts on one blockchain can call a function in a contract that is deployed on another blockchain. We show that validating the Originating Blockchain Id (the blockchain the crosschain function call started on), From Blockchain Id, and From Account provides contracts with certainty that a function call came from a specific contract on a specific blockchain.

cs.CR↗

Parallelizing Training of Deep Generative Models on Massive Scientific Datasets

Training deep neural networks on large scientific data is a challenging task that requires enormous compute power, especially if no pre-trained models exist to initialize the process. We present a novel tournament method to train traditional as well as generative adversarial networks built on LBANN, a scalable deep learning framework optimized for HPC systems. LBANN combines multiple levels of parallelism and exploits some of the worlds largest supercomputers. We demonstrate our framework by creating a complex predictive model based on multi-variate data from high-energy-density physics containing hundreds of millions of images and hundreds of millions of scalar values derived from tens of millions of simulations of inertial confinement fusion. Our approach combines an HPC workflow and extends LBANN with optimized data ingestion and the new tournament-style training algorithm to produce a scalable neural network architecture using a CORAL-class supercomputer. Experimental results show that 64 trainers (1024 GPUs) achieve a speedup of 70.2 over a single trainer (16 GPUs) baseline, and an effective 109% parallel efficiency.

cs.DC↗

The merits of using Ethereum MainNet as a Coordination Blockchain for Ethereum Private Sidechains

A Coordination Blockchain is a blockchain with the task of coordinating activities of multiple private blockchains. This paper discusses the pros and cons of using Ethereum MainNet, the public Ethereum blockchain, as a Coordination Blockchain. The requirements Ethereum MainNet needs to fulfil to perform this role are discussed within the context of Ethereum Private Sidechains, a private blockchain technology which allows many blockchains to be operated in parallel, and allows atomic crosschain transactions to execute across blockchains. Ethereum MainNet is a permissionless network which aims to offer strong authenticity, integrity, and non-repudiation properties, that incentivises good behaviour using crypto economics. This paper demonstrates that Ethereum MainNet does deliver these properties. It then provides a comprehensive review of the features of Ethereum Private Sidechains, with a focus on the potential usage of Coordination Blockchains for these features. Finally, the merits of using Ethereum MainNet as a Coordination Blockchain are assessed. For Ethereum Private Sidechains, we found that Ethereum MainNet is best suited to storing long term static data that needs to be widely available, such as the Ethereum Registration Authority information. However, due to Ethereum MainNet's probabilistic finality, it is not well suited to information that needs to be available and acted upon immediately, such as the Sidechain Public Keys and Atomic Crosschain Transaction state information that need to be accessible prior to the first atomic crosschain transaction being issued on a sidechain. Although this paper examined the use of Ethereum MainNet as a Coordination Blockchain within reference to Ethereum Private Sidechains, the discussions and observations of the typical tasks a Coordination blockchain may be expected to perform are applicable more widely to any multi-blockchain system.

cs.CR↗