Reduce Communication Overhead Research Articles

An efficient coarse‐grained parallel algorithm for global–local multiscale computations on massively parallel systems

AbstractThe existing global–local multiscale computational methods, using finite element discretization at both the macro‐scale and micro‐scale, are intensive both in terms of computational time and memory requirements and their parallelization using domain decomposition methods incur substantial communication overhead, limiting their application. We are interested in a class of explicit global–local multiscale methods whose architecture significantly reduces this communication overhead on massively parallel machines. However, a naïve task decomposition based on distributing individual macro‐scale integration points to a single group of processors is not optimal and leads to communication overheads and idling of processors. To overcome this problem, we have developed a novel coarse‐grained parallel algorithm in which groups of macro‐scale integration points are distributed to a layer of processors. Each processor in this layer communicates locally with a group of processors that are responsible for the micro‐scale computations. The overlapping groups of processors are shown to achieve optimal concurrency at significantly reduced communication overhead. Several example problems are presented to demonstrate the efficiency of the proposed algorithm. Copyright © 2009 John Wiley & Sons, Ltd.

Distributed Recursive Least-Squares for Consensus-Based In-Network Adaptive Estimation

Recursive least-squares (RLS) schemes are of paramount importance for reducing complexity and memory requirements in estimating stationary signals as well as for tracking nonstationary processes, especially when the state and/or data model are not available and fast convergence rates are at a premium. To this end, a fully distributed (D-) RLS algorithm is developed for use by wireless sensor networks (WSNs) whereby sensors exchange messages with one-hop neighbors to consent on the network-wide estimates adaptively. The WSNs considered here do not necessarily possess a Hamiltonian cycle, while the inter-sensor links are challenged by communication noise. The novel algorithm is obtained after judiciously reformulating the exponentially-weighted least-squares cost into a separable form, which is then optimized via the alternating-direction method of multipliers. If powerful error control codes are utilized and communication noise is not an issue, D-RLS is modified to reduce communication overhead when compared to existing noise-unaware alternatives. Numerical simulations demonstrate that D-RLS can outperform existing approaches in terms of estimation performance and noise resilience, while it has the potential of performing efficient tracking.

Software for Petascale Computing Systems

Developing software for highly scalable systems with nearly a million processors or cores raises unique challenges. To succeed, application developers must reconsider both their code's structure and the tools they use to develop, tune, and run that code. Petascale systems aren't just bigger versions of the current terascale systems. The degree of concurrency as well as increasingly complex processors means that existing algorithmic and software approaches no longer work. Although a few applications might be nearly ready for petascale systems, others need more extensive changes to exploit the system's scale and power. To ensure that applications are ready, we must reexamine everything in light of the system's massive size. Still, the situation isn't as grim as that sounds. Researchers are creating new tools to develop, debug, and tune applications that rely on adaptively determining and grouping behavior, as well as creating new programming models and languages that could enhance scalability by reducing communication overhead. Petascale system size and complexity can force developers to use well-designed components, both in the applications themselves and in the tools and middleware they use to develop them. Ultimately, while applications must adapt to petascale systems, the changes required is relatively modest and software tools can available to help.

Greedy Routing with Anti-Void Traversal for Wireless Sensor Networks

The unreachability problem (i.e., the so-called void problem) that exists in the greedy routing algorithms has been studied for the wireless sensor networks. Some of the current research work cannot fully resolve the void problem, while there exist other schemes that can guarantee the delivery of packets with the excessive consumption of control overheads. In this paper, a greedy anti-void routing (GAR) protocol is proposed to solve the void problem with increased routing efficiency by exploiting the boundary finding technique for the unit disk graph (UDG). The proposed rolling-ball UDG boundary traversal (RUT) is employed to completely guarantee the delivery of packets from the source to the destination node under the UDG network. The boundary map (BM) and the indirect map searching (IMS) scheme are proposed as efficient algorithms for the realization of the RUT technique. Moreover, the hop count reduction (HCR) scheme is utilized as a short-cutting technique to reduce the routing hops by listening to the neighbor's traffic, while the intersection navigation (IN) mechanism is proposed to obtain the best rolling direction for boundary traversal with the adoption of shortest path criterion. In order to maintain the network requirement of the proposed RUT scheme under the non-UDG networks, the partial UDG construction (PUC) mechanism is proposed to transform the non-UDG into UDG setting for a portion of nodes that facilitate boundary traversal. These three schemes are incorporated within the GAR protocol to further enhance the routing performance with reduced communication overhead. The proofs of correctness for the GAR scheme are also given in this paper. Comparing with the existing localized routing algorithms, the simulation results show that the proposed GAR-based protocols can provide better routing efficiency.

On Connected Target Coverage for Wireless Heterogeneous Sensor Networks with Multiple Sensing Units

The paper considers the connected target coverage (CTC) problem in wireless heterogeneous sensor networks (WHSNs) with multiple sensing units, termed MU-CTC problem. MU-CTC problem can be reduced to a connected set cover problem and further formulated as an integer linear programming (ILP) problem. However, the ILP problem is an NP-complete problem. Therefore, two distributed heuristic schemes, REFS (remaining energy first scheme) and EEFS (energy efficiency first scheme), are proposed. In REFS, each sensor considers its remaining energy and its neighbors’ decisions to enable its sensing units and communication unit such that all targets can be covered for the required attributes and the sensed data can be delivered to the sink. The advantages of REFS are its simplicity and reduced communication overhead. However, to utilize sensors’ energy efficiently, EEFS is proposed. A sensor in EEFS considers its contribution to the coverage and the connectivity to make a better decision. To our best knowledge, this paper is the first to consider target coverage and connectivity jointly for WHSNs with multiple sensing units. Simulation results show that REFS and EEFS can both prolong the network lifetime effectively. EEFS outperforms REFS in network lifetime, but REFS is simpler.

Secure encrypted-data aggregation for wireless sensor networks

This paper proposes a secure encrypted-data aggregation scheme for wireless sensor networks. Our design for data aggregation eliminates redundant sensor readings without using encryption and maintains data secrecy and privacy during transmission. Conventional aggregation functions operate when readings are received in plaintext. If readings are encrypted, aggregation requires decryption creating extra overhead and key management issues. In contrast to conventional schemes, our proposed scheme provides security and privacy, and duplicate instances of original readings will be aggregated into a single packet. Our scheme is resilient to known-plaintext attacks, chosen-plaintext attacks, ciphertext-only attacks and man-in-the-middle attacks. Our experiments show that our proposed aggregation method significantly reduces communication overhead and can be practically implemented in on-the-shelf sensor platforms.

The ARISE Approach for Extending Embedded Processors With Arbitrary Hardware Accelerators

ARISE introduces a systematic approach for extending once an embedded processor to support thereafter the coupling of an arbitrary number of custom computing units (CCUs). A CCU can be a hardwired or a reconfigurable unit, which can be utilized following a tight and/or loose model of computation. By selecting the appropriate model of computation for each part of the application, the complete application space is considered for acceleration, resulting in significant performance improvements. Also, ARISE offers modularity and scalability and is not restricted by the opcode space and operands limitation problems that exist in such type of machines. To support these features we introduce a machine organization that allows the cooperation of a processor and a set of CCUs. To control the CCUs we extend once the instruction set of the processor with eight instructions. To efficiently incorporate these features to an embedded processor, we propose a micro-architecture implementation that minimizes the control and communication overhead between the processor and the CCUs. To evaluate our proposal, we extended a MIPS processor with the ARISE infrastructure and implemented it on a Xilinx field-programmable gate array (FPGA). Implementation results, demonstrate that the timing model of the processor is not affected. Also, we implemented a set of benchmarks on the ARISE evaluation machine. Performance results prove significant improvements and reduced communication overhead compared to a typical coprocessor approach.

The Circulate architecture: avoiding workflow bottlenecks caused by centralised orchestration

As the number of services and the size of data involved in workflows increases, centralised orchestration techniques are reaching the limits of scalability. In the classic orchestration model, all data passes through a centralised engine, which results in unnecessary data transfer, wasted bandwidth and the engine to become a bottleneck to the execution of a workflow. This paper presents and evaluates the Circulate architecture which maintains the robustness and simplicity of centralised orchestration, but facilitates choreography by allowing services to exchange data directly with one another. Circulate could be realised within any existing workflow framework, in this paper, we focus on WS-Circulate, a Web services based implementation. Taking inspiration from the Montage workflow, a number of common workflow patterns (sequence, fan-in and fan-out), input to output data size relationships and network configurations are identified and evaluated. The performance analysis concludes that a substantial reduction in communication overhead results in a 2---4 fold performance benefit across all patterns. An end-to-end pattern through the Montage workflow results in an 8 fold performance benefit and demonstrates how the advantage of using the Circulate architecture increases as the complexity of a workflow grows.

SCODE: A Secure Coordination-Based Data Dissemination to Mobile Sinks in Sensor Networks

For many sensor network applications such as military, homeland security, it is necessary for users (sinks) to access sensor networks while they are moving. However, sink mobility brings new challenges to secure routing in large-scale sensor networks. Mobile sinks have to constantly propagate their current location to all nodes, and these nodes need to exchange messages with each other so that the sensor network can establish and maintain a secure multi-hop path between a source node and a mobile sink. This causes significant computation and communication overhead for sensor nodes. Previous studies on sink mobility have mainly focused on efficiency and effectiveness of data dissemination without security consideration. In this paper, we propose a secure and energy-efficient data dissemination protocol — Secure COodination-based Data dissEmination (SCODE) — for mobile sinks in sensor networks. We take advantages of coordination networks (grid structure) based on Geographical Adaptive Fidelity (GAF) protocol to construct a secure and efficient routing path between sources and sinks. Our security analysis demonstrates that the proposed protocol can defend against common attacks in sensor network routing such as replay attacks, selective forwarding attacks, sinkhole and wormhole, Sybil attacks, HELLO flood attacks. Our performance evaluation both in mathematical analysis and simulation shows that the SCODE significantly reduces communication overhead and energy consumption while the latency is similar compared with the existing routing protocols, and it always delivers more than 90 percentage of packets successfully.

Parallel SART algorithm of linear scan cone-beam CT for fixed pipeline

Linear scan cone-beam Computed Tomography (CT) is useful to fixed pipeline inspection. We extend Simultaneous Algebraic Reconstruction Technique (SART) to linear scan cone-beam CT and focus on reducing its reconstruction time through cluster computing. In order to reduce communication overhead, we investigate a trapeziform image space decomposition scheme and a subsets-reduce communication technique. The performance of proposed parallel algorithm is analyzed theoretically and verified through experiment. The results show that the proposed parallel algorithm can generate approving CT images and its performance is mainly influenced by load imbalance and network bandwidth.

A decentralized parallel implementation for parallel tempering algorithm

Parallel tempering (PT), also known as replica exchange, is a powerful Markov Chain Monte Carlo sampling approach, which aims at reducing the relaxation time in simulations of physical systems. In this paper, we present a novel decentralized parallel implementation of PT using the message passing interface (MPI) and the scalable parallel random number generators (SPRNG) library. By taking advantage of the characteristics of pseudorandom number generators, this implementation eliminates global synchronization and reduces the overhead caused by interprocessor communication in replica exchange in PT. Moreover, our proposed non-blocking replica exchange reduces communication overhead in pair-wise process replica exchanges by allowing the process reaching the replica exchange point to leap-ahead while waiting for the other one to reach the common replica exchange point. Also, temperature exchange instead of conformation replica exchange is proposed to reduce communication and achieve load balancing in the participating processors in the PT computation. All these enable one to efficiently apply PT to large-scale massively parallel systems. The efficiency of this parallel PT implementation is demonstrated in the context of minimizing various benchmark functions with complicated landscapes as objective functions. Our computational results and analysis have shown that the decentralized PT is scalable, reproducible, load-balanced, and yields insignificant communication overhead.

EEDTC: Energy-efficient dominating tree construction in multi-hop wireless networks

Motivated by reducing communication overhead and prolonging network lifetime in multi-hop wireless networks, we propose an energy-efficient dominating tree construction ( EEDTC) algorithm to construct a dominating tree that can serve as a communication backbone in wireless infrastructures. The algorithm uses k -hop neighbors’ information ( k ∈ [ 1 , D G ] , where D G is the diameter of graph G ). EEDTC has a theoretical approximation factor of at most 9. When k is equal to 1, it has O ( n ) message complexity and O ( ⌈ n 1 − 1 / D G ⌉ − 1 ) time complexity. Due to the low message complexity, EEDTC performs well on energy consumption. The energy-aware ranking technique that is introduced can also balance energy consumption in the network, and hence reduce the probability of network failures caused by energy depletion of backbone nodes.

Anonymous Geo-Forwarding in MANETs through Location Cloaking

In this paper, we address the problem of destination anonymity for applications in mobile ad hoc networks where geographic information is ready for use in both ad hoc routing and Internet services. Geographic forwarding becomes a lightweight routing protocol in favor of the scenarios. Traditionally the anonymity of an entity of interest can be achieved by hiding it among a group of other entities with similar characteristics, i.e., an anonymity set. In mobile ad hoc networks, generating and maintaining an anonymity set for any ad hoc node is challenging because of the node mobility, consequently the dynamic network topology. We propose protocols that use the destination position to generate a geographic area called an anonymity zone (AZ). A packet for a destination is delivered to all the nodes in the AZ, which make up the anonymity set. The size of the anonymity set may decrease because nodes are mobile, yet the corresponding anonymity set management is simple. We design techniques to further improve node anonymity and reduce communication overhead. We use analysis and extensive simulation to study the node anonymity and routing performance, and to determine the parameters that most impact the anonymity level that can be achieved by our protocol.

A structured P2P network based on the small world phenomenon

In this paper, we propose a new structured P2P overlay network, named SW-Uinta(small-world). In order to reduce the routing latency, we firstly construct the Uinta network in which both physical characteristics of network and data semantic are considered. Furthermore, based on Uinta, a nondeterministic caching strategy is employed to allow for poly-logarithmic search time while having only a constant cache size. Compared with the deterministic caching strategy proposed by previous P2P systems, the nondeterministic caching strategy can reduce communication overhead for maintaining the routing cache table. Cache entries in the cache table of peer nodes can be updated by subsequent queries rather than only by running stabilization periodically. In the following, a novel cache replacement scheme, named the SW cache replacement scheme, is used to improve lookup performance, which has proved to satisfy the small-world principle. So we call this network SW-Uinta(small-world). After that, according to the theoretical analysis, it can be proved that SW-Uinta(small-world) can get O((log?2 N)/k) search time with O(k) cache size. Lastly, the performance of SW-Uinta(small-world) is compared with those of other structured P2P networks such as Chord and Uinta. It shows that SW-Uinta(small-world) can achieve improved object lookup performance and reduce maintenance cost.

Secure and Efficient Time Synchronization in Heterogeneous Sensor Networks

Due to the collaborative nature of sensor nodes, time synchronization is critical for many sensor network operations. For sensor networks deployed in hostile environments, security is critical to the success of time synchronization. Over the past few years, a number of secure time-synchronization schemes have been proposed for sensor networks. However, these schemes are designed for homogeneous sensor networks and may incur large communication/computation overhead or may cause accumulated synchronization errors (due to multihop relays of time reference messages). Several works have shown that better performance and security can be achieved in heterogeneous sensor networks (HSNs). In this paper, we present a secure and efficient time synchronization scheme for HSNs by utilizing powerful high-end sensors. We implement the time-synchronization scheme in real sensor nodes, and the experiments show that our scheme achieves higher synchronization accuracy than a popular sensor time-synchronization scheme. The analyses demonstrate that our scheme is resilient to various attacks and significantly reduces communication overhead.

XMem

Developers commonly build contemporary enterprise applications using type-safe, component-based platforms, such as J2EE, and architect them to comprise multiple tiers, such as a web container, application server, and database engine. Administrators increasingly execute each tier in its own managed runtime environment (MRE) to improve reliability and to manage system complexity through the fault containment and modularity offered by isolated MRE instances. Such isolation, however, necessitates expensive cross-tier communication based on protocols such as object serialization and remote procedure calls. Administrators commonly co-locate communicating MREs on a single host to reduce communication overhead and to better exploit increasing numbers of available processing cores. However, state-of-the-art MREs offer no support for more efficient communication between co-located MREs, while fast inter-process communication mechanisms, such as shared memory, are widely available as a standard operating system service on most modern platforms. To address this growing need, we present the design and implementation of XMem ? type-safe, transparent, shared memory support for co-located MREs. XMem guarantees type-safety through coordinated, parallel, multi-process class loading and garbage collection. To avoid introducing any level of indirection, XMem manipulates virtual memory mapping. In addition, object sharing in XMem is fully transparent: shared objects are identical to local objects in terms of field access, synchronization, garbage collection, and method invocation, with the only difference being that sharedto-private pointers are disallowed. XMem facilitates easy integration and use by existing communication technologies and software systems, such as RMI, JNDI, JDBC, serialization/XML, and network sockets. We have implemented XMem in the open-source, productionquality HotSpot Java Virtual Machine. Our experimental evaluation, based on core communication technologies underlying J2EE, as well as using open-source server applications, indicates that XMem significantly improves throughput and response time by avoiding the overheads imposed by object serialization and network communication.

Reducing Communication Overhead for Wireless Roaming Authentication: Methods and Performance Evaluation

The protocol design for wireless roaming authentication is challenging because of the key management regarding users and home/visited networks. In this paper, we present two authentication methods that demonstrate better performance in terms of authentication latency and energy consumption of a mobile terminal, compared to the 3G cellular network approach of home network transporting authentication vector to visited network. The proposed Method I, referred to as Nonce-based Authentication, eliminates the sequence numbers used in the 3G roaming authentication and employs the key derivation and caching technique for mobile terminal and visited network. The proposed Method II, called Lightweight Localized Authentication, introduces the computation-efficient protocol based on a carefully designed public key certificate infrastructure. With the design goal of achieving security by lower cost, both methods significantly reduce the communication overhead between home and visited networks for roaming authentication, as indicated by analytical and experimental result.

An Implementation of A Parallel Iterative Algorithm for the Solution of Large Banded System on A Cluster of Workstations

In this paper, we present a parallel iterative solution for large banded systems of linear equations based on incomplete LU-factorization (ILU). A master—workers parallel computing scheme is used. The proposed algorithm incurs reduced storage and communication overhead as compared to previous methods. The reduction in communication overhead has been achieved by pipelining the inter-workers message passing and limiting the communication between master and workers to initial work distribution and final results collection.The performance of the proposed algorithm is evaluated analytically and experimentally using Parallel Virtual Machine (PVM) as a parallel programming environment on a cluster of Linux work-stations. The obtained performance results show that the proposed algorithm exhibits higher efficiency for coarse grain computations corresponding to large matrix sizes and reduced number of processors.

Complexity in Scalable Computing

The rich history of scalable computing research owes much to a rapid rise in computing platform scale in terms of size and speed. As platforms evolve, so must algorithms and the software expressions of those algorithms. Unbridled growth in scale inevitably leads to complexity. This special issue grapples with two facets of this complexity: scalable execution and scalable development. The former results from efficient programming of novel hardware with increasing numbers of processing units (e.g., cores, processors, threads or processes). The latter results from efficient development of robust, flexible software with increasing numbers of programming units (e.g., procedures, classes, components or developers). The progression in the above two parenthetical lists goes from the lowest levels of abstraction (hardware) to the highest (people). This issue's theme encompasses this entire spectrum. The lead author of each article resides in the Scalable Computing Research and Development Department at Sandia National Laboratories in Livermore, CA. Their co-authors hail from other parts of Sandia, other national laboratories and academia. Their research sponsors include several programs within the Department of Energy's Office of Advanced Scientific Computing Research and its National Nuclear Security Administration, along with Sandia's Laboratory Directed Research and Development program and the Office ofmore » Naval Research. The breadth of interests of these authors and their customers reflects in the breadth of applications this issue covers. This article demonstrates how to obtain scalable execution on the increasingly dominant high-performance computing platform: a Linux cluster with multicore chips. The authors describe how deep memory hierarchies necessitate reducing communication overhead by using threads to exploit shared register and cache memory. On a matrix-matrix multiplication problem, they achieve up to 96% parallel efficiency with a three-part strategy: intra-node multithreading, non-blocking inter-node message passing, and a dedicated communications thread to facilitate concurrent communications and computations. On a quantum chemistry problem, they spawn multiple computation threads and communication threads on each node and use one-sided communications between nodes to minimize wait times. They reduce software complexity by evolving a multi-threaded factory pattern in C++ from a working, message-passing program in C.« less

Concise version vectors in WinFS

Conflicts naturally arise in optimistically replicated systems. The common way to detect update conflicts is via version vectors, whose storage and communication overhead are number of replicas × number of objects. These costs may be prohibitive for large systems. This paper presents predecessor vectors with exceptions (PVEs), a novel optimistic replication technique developed for Microsoft’s WinFS system. The paper contains a systematic study of PVE’s performance gains over traditional schemes. The results demonstrate a dramatic reduction of storage and communication overhead in normal scenarios, during which communication disruptions are infrequent. Moreover, they identify a cross-over threshold in communication failure-rate, beyond which PVEs loses efficiency compared with traditional schemes.