25 research outputs found
Benchmarking SciDB Data Import on HPC Systems
SciDB is a scalable, computational database management system that uses an
array model for data storage. The array data model of SciDB makes it ideally
suited for storing and managing large amounts of imaging data. SciDB is
designed to support advanced analytics in database, thus reducing the need for
extracting data for analysis. It is designed to be massively parallel and can
run on commodity hardware in a high performance computing (HPC) environment. In
this paper, we present the performance of SciDB using simulated image data. The
Dynamic Distributed Dimensional Data Model (D4M) software is used to implement
the benchmark on a cluster running the MIT SuperCloud software stack. A peak
performance of 2.2M database inserts per second was achieved on a single node
of this system. We also show that SciDB and the D4M toolbox provide more
efficient ways to access random sub-volumes of massive datasets compared to the
traditional approaches of reading volumetric data from individual files. This
work describes the D4M and SciDB tools we developed and presents the initial
performance results. This performance was achieved by using parallel inserts, a
in-database merging of arrays as well as supercomputing techniques, such as
distributed arrays and single-program-multiple-data programming.Comment: 5 pages, 4 figures, IEEE High Performance Extreme Computing (HPEC)
2016, best paper finalis
Database Operations in D4M.jl
Each step in the data analytics pipeline is important, including database
ingest and query. The D4M-Accumulo database connector has allowed analysts to
quickly and easily ingest to and query from Apache Accumulo using MATLAB(R)/GNU
Octave syntax. D4M.jl, a Julia implementation of D4M, provides much of the
functionality of the original D4M implementation to the Julia community. In
this work, we extend D4M.jl to include many of the same database capabilities
that the MATLAB(R)/GNU Octave implementation provides. Here we will describe
the D4M.jl database connector, demonstrate how it can be used, and show that it
has comparable or better performance to the original implementation in
MATLAB(R)/GNU Octave.Comment: IEEE HPEC 2018. arXiv admin note: text overlap with arXiv:1708.0293
HPCmatlab: A Framework for Fast Prototyping of Parallel Applications in Matlab
AbstractThe HPCmatlab framework has been developed for Distributed Memory Programming in Matlab/Octave using the Message Passing Interface (MPI). The communication routines in the MPI library are implemented using MEX wrappers. Point-to-point, collective as well as one-sided communication is supported. Benchmarking results show better performance than the Mathworks Distributed Computing Server. HPCmatlab has been used to successfully parallelize and speed up Matlab applications developed for scientific computing. The application results show good scalability, while preserving the ease of programmability. HPCmatlab also enables shared memory programming using Pthreads and Parallel I/O using the ADIOS package
Achieving 100,000,000 database inserts per second using Accumulo and D4M
The Apache Accumulo database is an open source relaxed consistency database
that is widely used for government applications. Accumulo is designed to
deliver high performance on unstructured data such as graphs of network data.
This paper tests the performance of Accumulo using data from the Graph500
benchmark. The Dynamic Distributed Dimensional Data Model (D4M) software is
used to implement the benchmark on a 216-node cluster running the MIT
SuperCloud software stack. A peak performance of over 100,000,000 database
inserts per second was achieved which is 100x larger than the highest
previously published value for any other database. The performance scales
linearly with the number of ingest clients, number of database servers, and
data size. The performance was achieved by adapting several supercomputing
techniques to this application: distributed arrays, domain decomposition,
adaptive load balancing, and single-program-multiple-data programming.Comment: 6 pages; to appear in IEEE High Performance Extreme Computing (HPEC)
201
Parallel MATALAB Techniques
In this chapter, we show why parallel MATLAB is useful, provide a comparison
of the different parallel MATLAB choices, and describe a number of applications
in Signal and Image Processing: Audio Signal Processing, Synthetic Aperture
Radar (SAR) Processing and Superconducting Quantum Interference Filters
(SQIFs). Each of these applications have been parallelized using different
methods (Task parallel and Data parallel techniques). The applications
presented may be considered representative of type of problems faced by signal
and image processing researchers. This chapter will also strive to serve as a
guide to new signal and image processing parallel programmers, by suggesting a
parallelization strategy that can be employed when developing a general
parallel algorithm. The objective of this chapter is to help signal and image
processing algorithm developers understand the advantages of using parallel
MATLAB to tackle larger problems while staying within the powerful environment
of MATLAB
pPython Performance Study
pPython seeks to provide a parallel capability that provides good speed-up
without sacrificing the ease of programming in Python by implementing
partitioned global array semantics (PGAS) on top of a simple file-based
messaging library (PythonMPI) in pure Python. pPython follows a SPMD (single
program multiple data) model of computation. pPython runs on a single-node
(e.g., a laptop) running Windows, Linux, or MacOS operating systems or on any
combination of heterogeneous systems that support Python, including on a
cluster through a Slurm scheduler interface so that pPython can be executed in
a massively parallel computing environment. It is interesting to see what
performance pPython can achieve compared to the traditional socket-based MPI
communication because of its unique file-based messaging implementation. In
this paper, we present the point-to-point and collective communication
performances of pPython and compare them with those obtained by using mpi4py
with OpenMPI. For large messages, pPython demonstrates comparable performance
as compared to mpi4py.Comment: arXiv admin note: substantial text overlap with arXiv:2208.1490
Recommended from our members
Interactive Supercomputing’s Star-P Platform
The thesis of this extended abstract is simple. High productivity comes from high level infrastructures. To measure this, we introduce a methodology that goes beyond the tradition of timing software in serial and tuned parallel modes. We perform a classroom productivity study involving 29 students who have written a homework exercise in a low level language (MPI message passing) and a high level language (Star-P with MATLAB client). Our conclusions indicate what perhaps should be of little surprise: (1) the high level language is always far easier on the students than the low level language. (2) The early versions of the high level language perform inadequately compared to the tuned low level language, but later versions substantially catch up. Asymptotically, the analogy must hold that message passing is to high level language parallel programming as assembler is to high level environments such as MATLAB, Mathematica, Maple, or even Python. We follow the Kepner method that correctly realizes that traditional speedup numbers without some discussion of the human cost of reaching these numbers can fail to reflect the true human productivity cost of high performance computing. Traditional data compares low level message passing with serial computation. With the benefit of a high level language system in place, in our case Star-P running with MATLAB client, and with the benefit of a large data pool: 29 students, each running the same code ten times on three evolutions of the same platform, we can methodically demonstrate the productivity gains. To date we are not aware of any high level system as extensive and interoperable as Star-P, nor are we aware of an experiment of this kind performed with this volume of data