5,117 research outputs found
Parallel Implementation of AES using XTS Mode of Operation
Data encryption is essential for protecting data from unauthorized access. The Advanced Encryption Standard (AES), among many encryption algorithms, is the most popular algorithm currently employed to secure static and dynamic data. There are several modes of AES operation. Each of these modes defines a unique way to perform data encryption. XTS mode is the latest mode developed to protect data stored in hard-disk-like sector-based storage devices.
A recent increase in the rate of data breaches has triggered the necessity to encrypt stored data as well. AES encryption, however, is a complex process. As it involves a lot of computations, encrypting huge amount of data would undoubtedly be computationally intensive. Parallel computers have been used mostly in high-performance computation research to solve computationally intensive problems. Parallel systems are currently gaining popularity configured as general purpose multi-core system, even at a desktop level. Several programming models have been developed to assist the writing of parallel programs, and some have already been used to parallelize AES. As a result, AES data encryption has become more efficient and applicable.
The message passing model is a popular parallel communication/synchronization model with an early origin. Message Passing Interface (MPI) is the first standardized, vendor-independent, message passing library interface that establishes a portable, efficient, and flexible standard for message passing during computation. Therefore, this paper describes an implementation of AES using XTS mode in parallel via MPI
McMPI – a managed-code message passing interface library for high performance communication in C#
This work endeavours to achieve technology transfer between established best-practice in
academic high-performance computing and current techniques in commercial high-productivity
computing. It shows that a credible high-performance message-passing
communication library, with semantics and syntax following the Message-Passing Interface
(MPI) Standard, can be built in pure C# (one of the .Net suite of computer languages).
Message-passing has been the dominant paradigm in high-performance parallel
programming of distributed-memory computer architectures for three decades. The MPI
Standard originally distilled architecture-independent and language-agnostic ideas from
existing specialised communication libraries and has since been enhanced and extended.
Object-oriented languages can increase programmer productivity, for example by allowing
complexity to be managed through encapsulation. Both the C# computer language and the
.Net common language runtime (CLR) were originally developed by Microsoft Corporation
but have since been standardised by the European Computer Manufacturers Association
(ECMA) and the International Standards Organisation (ISO), which facilitates portability of
source-code and compiled binary programs to a variety of operating systems and hardware. Combining these two open and mature technologies enables mainstream programmers to
write tightly-coupled parallel programs in a popular standardised object-oriented language
that is portable to most modern operating systems and hardware architectures.
This work also establishes that a thread-to-thread delivery option increases shared-memory
communication performance between MPI ranks on the same node. This suggests that the
thread-as-rank threading model should be explicitly specified in future versions of the MPI
Standard and then added to existing MPI libraries for use by thread-safe parallel codes.
This work also ascertains that the C# socket object suffers from undesirable characteristics
that are critical to communication performance and proposes ways of improving the
implementation of this object
Learning from the Success of MPI
The Message Passing Interface (MPI) has been extremely successful as a
portable way to program high-performance parallel computers. This success has
occurred in spite of the view of many that message passing is difficult and
that other approaches, including automatic parallelization and directive-based
parallelism, are easier to use. This paper argues that MPI has succeeded
because it addresses all of the important issues in providing a parallel
programming model.Comment: 12 pages, 1 figur
MPICH-G2: A Grid-Enabled Implementation of the Message Passing Interface
Application development for distributed computing "Grids" can benefit from
tools that variously hide or enable application-level management of critical
aspects of the heterogeneous environment. As part of an investigation of these
issues, we have developed MPICH-G2, a Grid-enabled implementation of the
Message Passing Interface (MPI) that allows a user to run MPI programs across
multiple computers, at the same or different sites, using the same commands
that would be used on a parallel computer. This library extends the Argonne
MPICH implementation of MPI to use services provided by the Globus Toolkit for
authentication, authorization, resource allocation, executable staging, and
I/O, as well as for process creation, monitoring, and control. Various
performance-critical operations, including startup and collective operations,
are configured to exploit network topology information. The library also
exploits MPI constructs for performance management; for example, the MPI
communicator construct is used for application-level discovery of, and
adaptation to, both network topology and network quality-of-service mechanisms.
We describe the MPICH-G2 design and implementation, present performance
results, and review application experiences, including record-setting
distributed simulations.Comment: 20 pages, 8 figure
Parallel netCDF: A Scientific High-Performance I/O Interface
Dataset storage, exchange, and access play a critical role in scientific
applications. For such purposes netCDF serves as a portable and efficient file
format and programming interface, which is popular in numerous scientific
application domains. However, the original interface does not provide an
efficient mechanism for parallel data storage and access. In this work, we
present a new parallel interface for writing and reading netCDF datasets. This
interface is derived with minimum changes from the serial netCDF interface but
defines semantics for parallel access and is tailored for high performance. The
underlying parallel I/O is achieved through MPI-IO, allowing for dramatic
performance gains through the use of collective I/O optimizations. We compare
the implementation strategies with HDF5 and analyze both. Our tests indicate
programming convenience and significant I/O performance improvement with this
parallel netCDF interface.Comment: 10 pages,7 figure
DART-MPI: An MPI-based Implementation of a PGAS Runtime System
A Partitioned Global Address Space (PGAS) approach treats a distributed
system as if the memory were shared on a global level. Given such a global view
on memory, the user may program applications very much like shared memory
systems. This greatly simplifies the tasks of developing parallel applications,
because no explicit communication has to be specified in the program for data
exchange between different computing nodes. In this paper we present DART, a
runtime environment, which implements the PGAS paradigm on large-scale
high-performance computing clusters. A specific feature of our implementation
is the use of one-sided communication of the Message Passing Interface (MPI)
version 3 (i.e. MPI-3) as the underlying communication substrate. We evaluated
the performance of the implementation with several low-level kernels in order
to determine overheads and limitations in comparison to the underlying MPI-3.Comment: 11 pages, International Conference on Partitioned Global Address
Space Programming Models (PGAS14
Efficient Message Passing Interface (MPI) for Parallel Computing on Clusters of Workstations
Parallel computing on clusters of workstations and personal computers has very high
potential, since it leverages existing hardware and software. Parallel programming
environments offer the user a convenient way to express parallel computation and communication.
In fact, recently, a Message Passing Interface (MPI) has been proposed as an industrial
standard for writing "portable" message-passing parallel programs. The communication
part of MPI consists of the usual point-to-point communication as well as collective
communication. However, existing implementations of programming environments for clusters
are built on top of a point-to-point communication layer (send and receive) over local
area networks (LANs) and, as a result, suffer from poor performance in the collective
communication part.
In this paper, we present an efficient design and implementation of the collective
communication part in MPI that is optimized for clusters of workstations. Our system consists
of two main components: the MPI-CCL layer that includes the collective communication
functionality of MPI and a User-level Reliable Transport Protocol (URTP) that interfaces
with the LAN Data-link layer and leverages the fact that the LAN is a broadcast medium.
Our system is integrated with the operating system via an efficient kernel extension
mechanism that we developed. The kernel extension significantly improves the performance of
our implementation as it can handle part of the communication overhead without involving
user space.
We have implemented our system on a collection of IBM RS/6000 workstations con-
nected via a lOMbit Ethernet LAN. Our performance measurements are taken from typical
scientific programs that run in a parallel mode by means of the MPI. The hypothesis behind
our design is that system's performance will be bounded by interactions between the kernel
and user space rather than by the bandwidth delivered by the LAN Data-Link Layer. Our
results indicate that the performance of our MPI Broadcast (on top of Ethernet) is about
twice as fast as a recently published software implementation of broadcast on top of ATM
POSH: Paris OpenSHMEM: A High-Performance OpenSHMEM Implementation for Shared Memory Systems
In this paper we present the design and implementation of POSH, an
Open-Source implementation of the OpenSHMEM standard. We present a model for
its communications, and prove some properties on the memory model defined in
the OpenSHMEM specification. We present some performance measurements of the
communication library featured by POSH and compare them with an existing
one-sided communication library. POSH can be downloaded from
\url{http://www.lipn.fr/~coti/POSH}. % 9 - 67Comment: This is an extended version (featuring the full proofs) of a paper
accepted at ICCS'1
- …