Among the existing computational parallel models, Gamma and Dynamic Dataflow are equivalent models where parallel programs can be developed in a natural way. However, the implementation of Gamma paradigm poses several communication and architectural challenges. On the other hand, interest-based protocols have emerged as possible solutions of communication routing enabling an efficient communication in IoT environments. An interesting property of Gamma is the possibility of locality exploration in a non-complex way that sounds quite suitable for IoT applications. This work proposes a novel execution model for Gamma programs integrating the Radnet --- an interest-based protocol --- as communication protocol. Since the interest processing using Gamma paradigm is not a trivial task, a dynamic dataflow graph is used to express the interest as edges between vertices. We explore the equivalence results between Gamma and dataflow and, also, provide experiments showing the potential of Gamma when used to implement approximate computing techniques.

Summary The use of Dynamic Voltage and Frequency Scaling (DVFS) by Energy‐Efficient (EE) computer systems considerably increases the requirements regarding the design of efficient system clocks. On the one hand, the operation of a system clock must support the independent operating frequencies of the processor core units, the dynamic migration of the running processes between the processors core units, and the use of synchronization and time interpolation techniques to maintain the accuracy of the system clock. On the other hand, an efficient system clock has to minimize the overhead of its own operation, aiming at energy efficiency of EE computer systems. In this paper, we present the design and evaluation of the RVEC virtual system clock for the EE Wireless Raspberry Pi (RasPi) platform. In the RasPi platform, the use of DVFS for reducing the energy consumption hinders the direct use of the cycle count of the ARM11 processor core for building an efficient system clock. Therefore, a distinct feature of RVEC is to obviate this obstacle, such that it can make use of the cycle count circuit for precise and accurate time measurements, concurrently with the use of DVFS by the operating system of the ARM11 processor core. Specifically, this paper presents the design and experimental evaluation of an implementation of the RVEC virtual system clock in the Linux kernel of the RasPi platform with DVFS. Our experimental results validate the RVEC virtual system clock as an efficient system clock for the EE RasPi platform that runs the Linux operating system. Copyright © 2016 John Wiley & Sons, Ltd.

In this study, we propose a variation of the RAdNet for vehicular environments (RAdNet-VE). The proposed scheme extends the message header, mechanism for registering interest, and message forwarding mechanism of RAdNet. Based on results obtained from simulation experiments, we compare the performance of RAdNet-VE against that of RAdNet, a basic content-centric network (CCN) using reactive data routing, (CCNr), and a basic CCN using proactive data routing, CCNP. These CCNs provide non-cacheable data services. Moreover, the communication radio standards adopted in the scenarios 1 and 2 were respectively IEEE 802.11n and IEEE 802.11p. The results shown that the performance of the RAdNet-VE was superior to than those of RAdNet, CCNRand CCNP. In this sense, RAdNet-VE protocol (RVEP) presented low communication latencies among nodes of just 20.4ms (scenario 1) and 2.87 ms (scenario 2). Our protocol also presented high data delivery rates, i.e, 83.05% (scenario 1) and 88.05% (scenario 2). Based on these and other results presented in this study, we argue that RAdNet-VE is a feasible alternative to CCNs as information-centric network (ICN) model for VANET, because the RVEP satisfies all of the necessary communication requirements.

SUMMARY Distributed hash tables (DHTs) have been used in several applications, but most DHTs have opted to solve lookups with multiple hops, to minimize bandwidth costs while sacrificing lookup latency. This paper presents D1HT, an original DHT that has a peer‐to‐peer and self‐organizing architecture and maximizes lookup performance with reasonable maintenance traffic, and a Quarantine mechanism to reduce overheads caused by volatile peers. We implemented both D1HT and a prominent single‐hop DHT, and we performed an extensive and highly representative DHT experimental comparison, followed by complementary analytical studies. In comparison with current single‐hop DHTs, our results showed that D1HT consistently had the lowest bandwidth requirements, with typical reductions of up to one order of magnitude, and that D1HT could be used even in popular Internet applications with millions of users. In addition, we ran the first latency experiments comparing DHTs to directory servers, which revealed that D1HT can achieve latencies equivalent to or better than a directory server, and confirmed its greater scalability properties. Overall, our extensive set of results allowed us to conclude that D1HT can provide a very effective solution for a broad range of environments, from large‐scale corporate data centers to widely deployed Internet applications. Copyright © 2014 John Wiley & Sons, Ltd.

Energy-efficient computer systems are making increasing use of processors that have multiple core units, DVFS, and virtualization support. However, current system clocks have not been usually designed to cope with the capacity of such mechanisms to decelerate/accelerate the passage of time, which increases the time drifts in the system and produces two adverse side effects. First, a reduction in the precision of the system clocks, which makes it infeasible to run applications that are dependent on precise time measurements. Second, increasing the rate of system resynchronization with an external global clock, which adds more noise to the system and counteracts the attainment of a desirable energy efficiency. As an alternative to the system clock, we propose an original virtual clock, named RVEC, with the property that the time count is strictly increasing and precise (SIP). A preliminary experimental evaluation of an implementation of RVEC in Linux using a beowulf cluster of four energy-efficient computer systems showed that RVEC exhibited the SIP property while was highly precise and had negligible overhead in comparison with representative Linux system clocks. Furthermore, we used RVEC to build a High-Precision Global Clock (HPGC) which is free from resynchronization and implemented HPGC in the OpenMPI library as a time synchronization service for the MPI_Wtime() function to improve its timekeeping functions and lower the system noise. Our preliminary results from micro benchmarks executing in the same cluster indicated that the HPGC is highly scalable and precise solution which allowed the micro benchmarks to stay globally synchronized by using only 30 messages per node to initially synchronize the cluster nodes, thanks to the RVEC's SIP property. These results suggest that RVEC and HPGC can be effective alternatives to the system clock and the global clock respectively, in energy-efficient computer systems, especially for MPI applications running on beowulf clusters.

Mobile ad hoc Networks (MANETs) pose significant shared communication medium constraints such as finite memory, number of access channels, and bandwidth to the development of effective communication protocols. Furthermore, multihop message forwarding multiplies the amount of simultaneous transmissions, which augment both channel contention and network congestion, increasing interference and reducing protocol performance. With these issues in mind, we propose a variation of MANET which we called interest-centric mobile adhoc network or simply Radnet in which every participant node implements in the network layer an Active Prefix (AP) composed of a prefix and an application interest, which the Radnet protocol uses for node identification, message addressing, probabilistic message forwarding, and name search in a distributed way. To evaluate the effectiveness of Radnets for generating lower disturbance in the shared communication medium, thus enabling resource savings, and reducing message overheads, we compared the simulated performances of Radnet protocol (RP) against those of AODV and AODV + Gossip3 (G3AODV) protocols. The results showed that RP achieved a 16 percent higher message delivery rate and one order of magnitude lower latency and message overhead for short 0.5 kB messages in scenarios with 150 mobile nodes. For 5 kB messages, however, AODV and G3AODV rarely ran until the end, due to their overwhelming message overheads, while Radnet protocol showed performances similar to that of the short message case. To evaluate the use of Radnets in practice, we ran experiments in the laboratory, including a chat application on a 20-node Radnet.

Mobile ad hoc Networks (MANETs) pose significant shared communication medium constraints such as finite memory, number of access channels, and bandwidth, which make Quality of Experience (QoE) a critical issue for the development of applications. Furthermore, the use of multihop for message forwarding multiplies the amount of messages, increasing interference which in turn augments both channel contention and network congestion in the shared communication medium. The REP protocol for MANETs has been developed with these issues in mind. REP is an interest-centric communication protocol that generates minimal disturbance in the shared communication medium, thus enabling resource savings and allowing applications with QoE. REP introduces the Active Prefixes (APs), a new scheme for addressing, message forwarding, and interest-centric communication. An AP is composed of prefix (P) and interest (I), which every device builds P and each running application sets I. A service named REPD, using REP protocol, was implemented in Linux-based systems (Ubuntu and Android). Moreover, an API (REP API) provides basic communication functions that ease the development of interest-centric applications. The use of REPD service by mobile devices together with running applications create an interest-centric ad hoc network, which is called Radnet. As proof of concept for demonstrating the usability we implemented an interest-centric chat application using AP for running in a Radnet.

Efficiently locating information in large-scale distributed systems is a challenging problem to which Peer-to-Peer (P2P) Distributed Hash Tables (DHTs) can provide a highly scalable and cost-effective solution. However, there is very little experience on using DHTs in performance sensitive environments such as High Performance Computing (HPC) datacenters, and there is no published experimental comparison among low-latency DHTs. To fill this gap, we conducted an in-depth performance comparison of three proposed low-latency single-hop DHTs namely 1h-Calot, D1HT, and OneHop. Specifically, we compared experimentally the lookup latency and CPU use of D1HT with those of 1h-Calot by running each of them concurrently with the normal workload production for a subset of 1,800 nodes of a heavy-loaded HPC datacenter. In addition, we carried out an analytical performance comparison among the three single-hop DHTs for system sizes of up to 10 million nodes. The results showed that D1HT consistently had the smallest overhead and in most cases it required one order of magnitude less bandwidth than 1h-Calot and OneHop. Overall, the combination of our experimental and analytical results suggests that D1HT can provide a very effective solution for a broad range of environments, from large-scale HPC datacenters to widely deployed Internet P2P applications such as BitTorrent with up to one million peers. This ability to support such a wide range of environments may allow D1HT to be used as an inexpensive and scalable commodity software substrate for large-scale distributed applications.

Abstract Distributed Java virtual machine (dJVM) systems enable concurrent Java applications to transparently run on clusters of commodity computers. This is achieved by supporting Java's shared‐memory model over multiple JVMs distributed across the cluster's computer nodes. In this work, we describe and evaluate selective dynamicdiffingand lazy home allocation, two new runtime techniques that enable dJVMs to efficiently support memory sharing across the cluster. Specifically, the two proposed techniques can contribute to reduce the overheads due to message traffic, extra memory space, and high latency of remote memory accesses that such dJVM systems require for implementing their memory‐coherence protocol either in isolation or in combination. In order to evaluate the performance‐related benefits of dynamicdiffingand lazy home allocation, we implemented both techniques in Cooperative JVM (CoJVM), a basic dJVM system we developed in previous work. In subsequent work, we carried out performance comparisons between the basic CoJVM and modified CoJVM versions for five representative concurrent Java applications (matrix multiply, LU, Radix, fast Fourier transform, and SOR) using our proposed techniques. Our experimental results showed that dynamicdiffingand lazy home allocation significantly reduced memory sharing overheads. The reduction resulted in considerable gains in CoJVM system's performance, ranging from 9% up to 20%, in four out of the five applications, with resulting speedups varying from 6.5 up to 8.1 for an 8‐node cluster of computers. Copyright © 2007 John Wiley & Sons, Ltd.

Distributed hash tables (DHTs) have been used in a variety of applications, but most DHTs so far have opted to solve lookups with multiple hops, which sacrifices performance in order to keep little routing information and minimize maintenance traffic. In this paper, we introduce D1HT, a novel single hop DHT that is able to maximize performance with reasonable maintenance traffic overhead even for huge and dynamic peer-to-peer (P2P) systems. We formally define the algorithm we propose to detect and notify any membership change in the system, prove its correctness and performance properties, and present a quarantine-like mechanism to reduce the overhead caused by volatile peers. Our analyses show that D1HT has reasonable maintenance bandwidth requirements even for very large systems, while presenting at least twice less bandwidth overhead than previous single hop DHT

State-of-the-art software distributed shared-memory systems (SDSMs) provide a cost-effective solution to run single-program-multiple-data (SPMD) applications on clusters of distributed memory computers. However, SDSMs are unsuitable for running applications with dynamic, highly asynchronous task parallelism (ATP), such as graphics, simulators, and decision support systems. In ATP-based applications, the execution of tasks depends not only on the input data but also on the variable amount of data that each task produces at runtime, which generates high load imbalance and communication traffic that degrades performance of SDSM systems drastically. In this work, we propose a new load balancing (LB) mechanism to enable SDSM systems to support dynamic task scheduling as required by ATP applications. To evaluate the benefits of our LB mechanism, we developed Clik a new multithreaded SDSM system with automatic load balancing. Our preliminary performance results of Clik running on a 16-node Linux SMP cluster for five ATP applications showed that Clik attained significant speedups. For four of our five applications, the speedups varied from 7.2 up to 13.8 on 16 processors

We propose a new distributed run-time environment, which we called cJava, that enables multithread Java applications to execute in clusters transparently. Our implementation of cJava supports the distributed shared memory (DSM) which required significant extensions to the original Java virtual machine (JVM). First, a distributed object manager was incorporated to the JVM's memory management subsystem for creating a global object space. Second, synchronized accesses to the global object space were extended so that they could use the lock() and unlock() primitives that cJava's DSM supports. Third, cJava adapted the thread subsystem to enable remote creation and global monitors. Last, a subsystem/or remote signaling was added to the original JVM. The main advantage of cJava is that it can execute existing multithread Java applications straightaway. Most importantly, our results of cJava's performance across several benchmarks show that cJava offers an efficient run-time system for executing transparently multithread Java applications in clusters.

We study the isolated and combined effects of several latency-tolerance techniques for software-based distributed shared-memory systems (software DSMs). More specifically, we focus on data prefetching, update-based coherence, and single-writer optimizations for page-based software DSMs. Our experimental results with six parallel applications show that, when these techniques are carefully combined, they can provide running time and speedup improvements of up to 54 percent and 110 percent, respectively, on a cluster of eight PCs.

Software Distributed Shared Memory (SDSM) systems provide the shared memory abstraction on top of a message passing hardware, simplifying application programming in these architectures. However, some memory references exhibit long latencies due to remotely cached data. In order to hide this latency, many techniques that propagate data speculatively were developed. This requires that the data access behavior of the applications be determined. Traditionally, many of these techniques were directed at specific data sharing patterns such as producer-consumer and migratory. In this paper, we propose and evaluate generic data access prediction techniques for SDSM systems. By generic we mean.: that our strategies don't try to detect specific sharing patterns known a priori. The prediction strategies proposed can be divided into two classes: local information predictors (LIP), that are guided only by local information in each processor and global information predictors (GIP) that use the data access pattern of all processors in order to make predictions. Our experimental result show that techniques within both classes can attain high hit ratios in most of the applications evaluated. Overall, the results allow us to conclude that the prediction strategies for data accesses we propose can contribute to increase the performance of current page-based SDSMs significantly.

In this paper we introduce a scalable Video-on-Demand (VoD) system called GloVE (Global Video Environment) in which active clients cooperate to create a shareable video cache that is used as the primary source of video content for subsequent client requests. In this way, GloVE server's bandwidth does not limit the number of simultaneous clients that can watch a video since once its content is in the cooperative video cache (CVC) it can be directly transmitted from the cache rather than the VoD server Also, GloVE follows the peer-to-peer approach, allowing the use of low-cost PCs as video servers. In addition, GloVE supports video servers without multicast capability and videos in any stored format. We analyze preliminary performance results of GloVE implemented in a PC server using a Fast Ethernet interconnect and small video buffers at the clients. Our results confirm that while the GloVE-based server uses only a single video channel to deliver a highly popular video simultaneously to N clients, conventional VoD servers require as much as N times more channels.

In this paper we introduce MOMEMTO (MOre MEMory Than Others) a new set of kernel mechanisms that allow users to have full control of the distributed shared memory on a cluster of personal computers. In contrast to many existing software DSM systems, MOMEMTO supports efficiently and flexibly global shared-memory allowing applications to address larger memory space than that available in a single node. MOMEMTO has been implemented in the Linux 2.4 kernel and preliminary performance results show that MOMEMTO has low memory management and communication overheads and that it can indeed perform very well for large memory configurations.

Abstract There has been an increasing research interest in extending the use of Java towards high‐performance demanding applications such as scalable Web servers, distributed multimedia applications, and large‐scale scientific applications. However, extending Java to a multicomputer environment and improving the low performance of current Java implementations pose great challenges to both the systems developer and application designer. In this survey, we describe and classify 14 relevant proposals and environments that tackle Java's performance bottlenecks in order to make the language an effective option for high‐performance network‐based computing. We further survey significant performance issues while exposing the potential benefits and limitations of current solutions in such a way that a framework for future research efforts can be established. Most of the proposed solutions can be classified according to some combination of three basic parameters: the model adopted for inter‐process communication, language extensions, and the implementation strategy. In addition, where appropriate to each individual proposal, we examine other relevant issues, such as interoperability, portability, and garbage collection. Copyright © 2002 John Wiley & Sons, Ltd.

This work introduces a new technique that enables SDSMs to categorize dynamically and accurately memory sharing patterns in both classes of regular and irregular applications. The categorization is carried out automatically at run-time on a per-page basis, requiring no user or compiler assistance. We evaluate the potential benefits of our technique using execution-driven simulations of 8 applications running on TrendMarks on a network of 8 workstations. Surprisingly, we found that producer-consumer(s) and migratory are the dominant patterns even in irregular applications. Preliminary results suggest that the categorization technique we propose is a promising option to further improve the performance of current adaptive SDSM systems.

Filtered Back-Projection (FBP) is a well-known algorithm for reconstruction of tomographic images from projections. Some of FBP's highlights are: (i) it allows agile software implementations, and; (ii) it produces images of good quality, i.e., relatively free of artifacts. Our goal is to reconstruct images from fan beam projections collected by detectors set in a linear array.

In this paper we evaluate the impact of the programming model on the performance and complexity of Entry Consistency-based software distributed shared-memory systems (software DSMs). We study three novel software DSMs that can all take advantage of lock-style primitives but impose different variations of the shared-memory programming model. The first variation is a plain shared-memory model based on barriers and mutual exclusion locks, where the association between shared data and lock variables is determined transparently by the system. The second model dictates that all accesses to shared data must be delimited by lock/unlock-type primitives (with or without mutual exclusion), even though the lock-data association is still performed transparently. The third model requires that all shared data accesses be delimited by lock/unlock-type primitives and the association between locks and data is specified explicitly by the programmer. A comparison of our software DSMs shows that increasing the model complexity simplifies the systems substantially. Our results also show that the second model can perform significantly worse than the first model, while the third model improves performance by 25% and 27% on average compared to the first and second models, respectively. We conclude that increasing the burden on the programmer is not necessarily a good option for software DSMs; only the most elaborate model we study achieves performance that justifies its programming complexity.

We investigate whether arithmetic operations based on Residue Number Systems (RNS) are cost-effective solutions to implement DSP applications into reconfigurable hardware. We simulated several RNS addition and multiplication implementations by varying the RNS parameters. For RNS addition, our results show that it can be implemented into a 3-stage 80.6-92.5 MHz pipeline using about 22 to 33 FPGAs' logic cells. For RNS multiplication, the attainable speed range was between 78.1 and 87.7 MHz, for operand lengths varying between 5 and 8 bits. Overall, a hybrid solution that combines logical elements and blocks of RAM is the best option, producing better average performance across the whole range of operand lengths.

In this paper we propose and evaluate the Adaptive++ technique, a novel runtime-only data prefetching strategy for software-based distributed shared-memory systems (software DSMs).Adaptive++ improves the performance of regular parallel applications running on software DSMs by using the past history of memory access faults to adapt between repeated-phase and repeated-stride prefetching modes.Adaptive++ does not issue prefetches during periods when the application is not exhibiting one of these two types of behavior and is thus behaving irregularly.Through detailed execution-driven simulations of several applications, we show that our prefetching technique is very successful at reducing the data access overheads of regular applications running on the TreadMarks software DSM.Adaptive++ also reduces the overhead of applications that are not strictly regular but that exhibit periods of regularity.In terms of overall performance, our results show that Adaptive++ can provide speedup improvements as significant as 34% on 16 processors.A direct comparison against two runtime-only prefetching techniques proposed thus far shows that Adaptive++ is consistently competitive in terms of performance, while being able to optimize a larger set of applications.Our main conclusion is that Adaptive++ should definitely be considered by software DSM designers as an effective way of tolerating the overhead of remote data accesses.Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commen: ial advantage and that copies bear this notice and the full citation on the fust page.To oopy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific pe-rmission and/or a fee.

In this paper we propose a novel software-only distributed shared memory system (SW-DSM), the Affinity Entry Consistency (AEC) protocol. The protocol is based on Entry Consistency but, unlike previous approaches, does not require the explicit association of shared data to synchronization variables, uses the page as its coherence unit, and generates the set of modifications (in the form of diffs) made to shared pages eagerly. The AEC protocol hides the overhead of generating and applying diffs behind synchronization delays, and uses a novel technique, Lock Acquirer Prediction (LAP), to tolerate the overhead of transferring diffs through the network. LAP attempts to predict the next acquirer of a lock at the time of the release, so that the acquirer can be updated even before requesting ownership of the lack. Using execution-driven simulation of real applications, we show that LAP performs very well under AEC; LAP predictions are within the 80-97% range of accuracy. Our results also show that LAP improves performance by 7-28% for our applications. In addition we find that most of the diff creation overhead in the AEC protocol can usually be overlapped with synchronization latencies. A comparison against simulated TreadMarks shows that AEC outperforms TreadMarks by as much as 47%. We conclude that LAP is a useful technique for improving the performance of update-based SW-DSMs, while AEC is an efficient implementation of the Entry Consistency model.

In this paper we propose the use of a PCI-based programmable protocol controller for hiding communication and coherence overheads in software DSMs. Our protocol controller provides three different types of overhead tolerance: a) moving basic communication and coherence tasks away from computation processors; b) prefetching of diffs; and c) generating and applying diffs with hardware assistance. We evaluate the isolated and combined impact of these features on the performance of TreadMarks. We also compare performance against two versions of the Shrimp-based AURC protocol. Using detailed execution-driven simulations of a 16-node network of workstations, we show that the greatest performance benefits provided by our protocol controller come from our hardware-supported diffs. Reducing the burden of communication and coherence transactions on the computation processor is also beneficial but to a smaller extent. Prefetching is not always profitable. Our results show that our protocol controller can improve running time performance by up to 50% for TreadMarks, which means that it can double the TreadMarks speedups. The overlapping implementation of TreadMarks performs as well or better than AURC for 5 of our 6 applications. We conclude that the simple hardware support we propose allows for the implementation of high-performance software DSMs at low cost. Based on this conclusion, we are building the NCP2 parallel system at COPPE/UFRJ.