The 19th Workshop on Advances in Parallel and Distributed Computational Models (APDCM), which was held in conjunction with the International Parallel and Distributed Processing Symposium (IPDPS) on May 29 - June 2, 2017, in Orlando, USA, aims to provide a timely forum for the exchange and dissemination of new ideas, techniques and research in the field of the parallel and distributed computational models. The APDCM workshop has a history of attracting participation from reputed researchers worldwide. The program committee has encouraged the authors of accepted papers to submit full-versions of their manuscripts to the International Journal of Networking and Computing (IJNC) after the workshop. After a thorough reviewing process, with extensive discussions, five articles on various topics have been selected for publication on the IJNC special issue on APDCM. On behalf of the APDCM workshop, we would like to express our appreciation for the large efforts of reviewers who reviewed papers submitted to the special issue. Likewise, we thank all the authors for submitting their excellent manuscripts to this special issue. We also express our sincere thanks to the editorial board of the International Journal of Networking and Computing, in particular, to the Editor-in-chief Professor Koji Nakano. This special issue would not have been possible without his support.
Fault tolerance is gaining importance in parallel computing, especially on large clusters. Traditional approaches handle the issue on system-level. Application-level approaches are becoming increasingly popular, since they may be more efficient. This paper presents a fault-tolerant work stealing technique on application level, and describes its implementation in a generic reusable task pool framework for Java. When using this framework, programmers can focus on writing sequential code to solve their actual problem. The framework is written in Java and utilizes the APGAS library for parallel programming. It implements a comparatively simple algorithm that relies on a resilient data structure for storing backups of local pools and other information. Our implementation uses Hazelcast's IMap for this purpose, which is an automatically distributed and fault-tolerant key-value store.?The number of backup copies is configurable and determines how many simultaneous failures can be tolerated. Our algorithm is shown to be correct in the sense that failures are either tolerated and the computed result is the same as in non-failure case, or the program aborts with an error message. Experiments were conducted with the UTS, NQueens and BC benchmarks on up to 144 workers. First, we compared the performance of our framework with that of a non-fault-tolerant variant during failure-free operation. Depending on the parameter settings, the overhead was at most 46.06%. The particular value tended to increase with the number of steals. Second, we compared our framework's performance with that of a related, but less flexible fault-tolerant X10 framework. Here, we did not observe a clear winner. Finally, we measured the overheads for restoring a failed worker and for raising the number of backup copies from one to six, and found both to be negligible.
We consider the distributed setting of N autonomous?mobile robots that operate in Look-Compute-Move (LCM) cycles and communicate with other robots using colored lights (the robots with lights model). We study the fundamental Complete Visibility problem of repositioning N robots on a plane so that each robot is visible to all others. We assume obstructed visibility under which a robot cannot see another robot if a third robot is positioned between them on the straight line connecting them. We are interested in fault-tolerant algorithms; all existing algorithms for this problem are not fault-tolerant (except handling some special cases). We study fault-tolerance with respect to failures on the mobility of robots. Therefore, any algorithm for Complete Visibility is required to provide visibility between all non-faulty robots, independently of the behavior of the faulty ones. We model mobility failures as crash faults in which each faulty robot is allowed to stop its movement at any time and, once the faulty robot stopped moving, that robot will remain stationary indefinitely. In this paper, we present and analyze an algorithm that solves Complete Visibility tolerating one crash-faulty robot in a system of N>=3 robots, starting from any arbitrary initial configuration. We also provide an impossibility result on solving Complete Visibility if a single robot is Byzantine-faulty in a system of N=3 robots; in the Byzantine fault model, a faulty robot might behave in an unpredictable, arbitrary, and unforeseeable ways. Furthermore, we discuss how to solve Complete Visibility for some initial configurations of robots (which we call feasible initial configurations) in the crash fault model, where two robots are (crash) faulty.
We introduce a new network structure named a maximal (σ, τ )-directed acyclic mixed graph (DAMG). A maximal (σ,τ)-DAMG allows both arcs (directed edges) and (undirected) edges which is constructed, for any given connected undirected graph with a set of σ nodes specified as source nodes and a set of τ nodes specified as sink nodes, by assigning directions to as many (undirected) edges as possible (i.e., by changing edges into arcs) so that the following conditions are satisfied: (i) each node specified as a source node has at least one outgoing arc but no incoming arc, (ii) each node specified as a sink node has at least one incoming arc but no outgoing arc, (iii) each other node has no arc or has both outgoing and incoming arcs, and (iv) no directed cycle (consisting only of arcs) exists. This maximality implies that changing any more edges to arcs violates these conditions, for example, a source node has an incoming arc, a node which is specified as neither a source node nor a sink node has only outgoing or incoming arcs other than edges, or a directed cycle is created in the network.
In this paper, we propose a self-stabilizing algorithm which constructs a (1,1)-maximal DAMG in any connected graph with a specified source node and a specified sink node by assigning directions to as many edges as possible.
Graph algorithms play an important role in several fields of sciences and engineering. Prominent among them are the All-Pairs-Shortest-Paths (APSP) and related problems. Indeed there are several efficient implementations for such problems on a variety of modern multi- and many-core architectures.
It can be noticed that for several graph problems, parallelism offers only a limited success as current parallel architectures have severe short-comings when deployed for most graph algorithms. At the same time, some of these graphs exhibit clear structural properties due to their sparsity. This calls for particular solution strategies aimed at scalable processing of large, sparse graphs on modern parallel architectures.
In this paper, we study the applicability of an ear decomposition of graphs to problems such as all-pairs-shortest-paths and minimum cost cycle basis. Through experimentation, we show that the resulting solutions are scalable in terms of both memory usage and also their speedup over best known current implementations. We believe that our techniques have the potential to be relevant for designing scalable solutions for other computations on large sparse graphs.
In Transactional Memory each shared object can be accessed by concurrent transactions which may cause conflicts and aborts. Opacity is a precise consistency property which maps a concurrent execution to a legal sequential execution that preserves the real time order of events. However, having precise consistency in large scale network and database applications may result in a large rate of aborts, especially in systems that have frequent memory updates. Actually, high rate of aborts causes huge negative performance impact. In real applications, there are systems that do not require precise consistency especially when the data is not sensitive. Thus, we introduce here the notion of approximate consistency in transactional memory. We define K-opacity as a relaxed consistency property where transactions are allowed to read one of the K most recent written values to the objects (and not just the latest value only). This increases the throughput and reduces the abort rate by reducing the chance of conflicts. In multi-version transactional memory, the relaxed consistency allows to save a new object version once every K object updates, and hence, reduces space requirements by a factor of K. In fact, we apply the concept of K-opacity to regular read/write, count, and queue objects, which are common objects used in typical concurrent programs. We use the technique of writer lists to keep track of the transactions and the data being written to the system, in order to control the error rate and to prevent error propagation. We illustrate with an experimental analysis the positive impact of our approach on performance, where higher opacity relaxation (higher values of K) increases the throughput and decreases the aborts rate significantly.
A wireless inductive coupling ThruChip Interface (TCI) is a flexible system-in-package (SiP) technique which enables to build a powerful interconnection network between stacked chips. For easy use of TCI, we have developed intellectual properties (IPs), and proposed an interconnection network which can make the use of IPs. We also developed a real chip embedded the IP, and evaluated the performance. By stacking multiple chips with the proposed IP, an inter-chip network with link-to-link flow control by piggyback control is established. The new proposed escalator network which uses piggyback of the credit packets outperforms the ring network used in the first prototype by 28%-59% in terms of throughput. The performance overhead by the piggyback control was less than 3%-4% of that without control messages.