Search

Software Defined Networks (SDN) has been attracting researchers, scientist, and technology experts from both academia and industry to enhance the current ICT stakes and networking paradigm. The beauty of SDN is the division of Control and Data planes and make it easy for the engineers to modify the networking protocols without visiting onsite devices. Similarly, smart cities concept has been coined recently, where a plethora of smart devices will be connected and providing tons of services to the citizens, officials, and governmental departments. The Internet of Things (IoT) plays a vital role in guaranteeing such services. Few efforts have been made to merge SDN and IoT with the sole purpose of efficient Data retrieval and achieve remotely configurable networks. In this paper, we explicitly define the Internet of Software Defined Things architecture and bring it to Smart Cities as a use-case. Our 3-tier architecture consists of Data Collection, Data Management, and Application levels that are further connected via two intermediate levels working on SDN principles. Followed by the potentials of SDN and IoT for Smart Cities, we evaluated our proposed architecture using Spark and GraphX with Hadoop Ecosystem and the results shows that efficient transfer of Data over SDN for real-time processing is achieved. [ABSTRACT FROM AUTHOR]

The coherence protocol presented in this work, denoted MOSAIC, introduces a new approach to face the challenges of complex multilevel cache hierarchies in future many-core systems. The essential aspect of the proposal is to eliminate the condition of inclusiveness through the different levels of the memory hierarchy while maintaining the complexity of the protocol limited. Cost reduction decisions taken to reduce this complexity may introduce artificial inefficiencies in the on-chip cache hierarchy, especially when the number of cores and private cache size is large. Our approach trades area and complexity for on-chip bandwidth, employing an integrated broadcast mechanism in a directory structure. In energy terms, the protocol scales like a conventional directory coherence protocol, but relaxes the shared information inclusiveness. This allows the performance implications of directory size and associativity reduction to be overcome. As it is even simpler than a conventional directory, the results of our evaluation show that the approach is quite insensitive, in terms of performance and energy expenditure, to the size and associativity of the directory. [ABSTRACT FROM AUTHOR]

Optimizing Message Passing Interface (MPI) point-to-point communication for large messages is of paramount importance since most communications in MPI applications are performed by such operations. Remote Direct Memory Access (RDMA) allows one-sided data transfer and provides great flexibility in the design of efficient communication protocols for large messages. However, achieving high point-to-point communication performance on RDMA-enabled clusters is challenging due to both the complexity in communication protocols and the impact of the protocol invocation scenario on the performance of a given protocol. In this work, we analyze existing protocols and show that they are not ideal in many situations, and propose to use protocol customization, that is, different protocols for different situations to improve MPI performance. More specifically, by leveraging the RDMA capability, we develop a set of protocols that can provide high performance for all protocol invocation scenarios. Armed with this set of protocols that can collectively achieve high performance in all situations, we demonstrate the potential of protocol customization by developing a trace-driven toolkit that allows the appropriate protocol to be selected for each communication in an MPI application to maximize performance. We evaluate the performance of the proposed techniques using micro-benchmarks and application benchmarks. The results indicate that protocol customization can out-perform traditional communication schemes by a large degree in many situations. [ABSTRACT FROM AUTHOR]

In order to exploit parallel resources, most transactional memory (TM) systems execute atomic blocks concurrently and must thus be prepared for data conflicts. In the event of a conflict, a TM system must choose a policy to decide when and how to manage the resulting contention. In this paper, we analyze the interplay between conflict resolution time and contention management policy in the context of hardware-supported TM systems, highlighting the performance and implementation implications of the various points in the design space. We show that both policy decisions have a significant impact on the ability to exploit available parallelism and ensure progress of individual transactions. Our analysis corroborates previous research findings that stalling (especially at access time and retrying the problematic access) helps side-step conflicts and avoid wasted work. We demonstrate that conflict resolution time has the dominant effect on performance: Lazy (which delays resolution to commit time) uncovers more parallelism than Eager (which resolves conflicts at access time). With Lazy, in spite of an aborted transaction tending to waste more work (31% more than Eager), the cumulative amount of wasted work is lower since fewer transactions are aborted (1.6 × less than Eager). Lazy's delayed conflict resolution also ensures progress and decreases the likelihood of pathologies (like livelock) while Eager needs sophisticated priority mechanisms in the contention management to avoid pathologies. Finally, we evaluate a mixed conflict resolution that detects write-write conflicts eagerly while detecting read-write conflicts lazily, and show that it provides a good compromise between implementation complexity and exploiting concurrency for performance. [ABSTRACT FROM AUTHOR]

The objective of this paper is the review of the log file formats that allow the performance visualization of parallel applications based on the usage of message passing interface (MPI) standard. These file formats have been designed by the LANS (Laboratory for Advanced Numerical Software) group of the Argonne National Laboratory and they are distributed together with the corresponding viewers as part of the MPE (multipurpose environment) library of the MPICH implementation of the MPI. The formats studied in this paper is the ALOG, CLOG, SLOG1 and SLOG2 file formats—the formats are studied in chronological order and the main features of their structures are presented. [ABSTRACT FROM AUTHOR]

Overlapping computation with communication is a key technique to conceal the effect of communication latency on the performance of parallel applications. Message Passing Interface (MPI) is a widely used message passing standard for high performance computing. One of the most important factors in achieving a good level of overlap is the MPI ability to make progress on outstanding communication operations. In this paper, we propose a novel speculative MPI Rendezvous protocol that uses RDMA Read and RDMA Write to effectively improve communication progress and consequently the overlap ability. Performance results based on a modified MPICH2 implementation over 10-Gigabit iWARP Ethernet reveal a significant (80–100%) improvement in receiver side overlap and progress ability. We have also observed up to 30% improvement in application wait time for some NPB applications as well as the RADIX application. For applications that do not benefit from this protocol, an adaptation mechanism is used to stop the speculation to effectively reduce the protocol overhead. [ABSTRACT FROM AUTHOR]

This paper presents a language independent runtime framework—called Weaves—for object based composition of unmodified code modules that enables selective sharing of state between multiple control flows through a process. Furthermore, the framework allows dynamic instantiation of code modules and control flows through them. In effect, weaves create intra-process modules (similar to objects in OOP) from code written in any language. Applications can be built by instantiating Weaves to form Tapestries of dynamically interacting code. The framework enables objects to be arbitrarily shared—it is a true superset of both processes as well as threads, with code sharing and fast context switching time similar to threads. Weaves does not require any special support from either the language or application code—practically any code can be weaved. Weaves also include support runtime loading and linking of object modules enabling the next generation of highly dynamic applications. This paper presents the elements of the Weaves framework and its implementation on the Linux platform over source-code independent ELF object files. The current implementation has been validated over Sweep3D, a benchmark for 3D discrete ordinates neutron transport (Koch et al. Trans. Am. Nucl. Soc. 65 (198) [1992]), and a user-level port of the Linux 2.4 family kernel TCP/IP protocol stack. [ABSTRACT FROM AUTHOR]