Juan Carlos Chaves

Octave and Python: High-Level Scripting Languages Productivity and Performance Evaluation

Octave and Python are open source alternatives to MATLAB, which is widely used by the High Performance Computing Modernization Program (HPCMP) community. These languages are two well known examples of high-level scripting languages that promise to increase productivity without compromising performance on HPC systems. In this paper, we report our work and experience with these two non-traditional programming languages at the HPCMP Centers. We used a representative sample of SIP codes for the study, with special emphasis given to the understanding of issues such as portability, degree of complexity, productivity and suitability of Octave and Python to address signal/image processing (SIP) problems on the HPCMP HPC platforms. We implemented a relatively simple two-dimensional (2D) FFT and a more complex image enhancement algorithm in Octave and Python and benchmarked these SIP codes on several HPCMP platforms, paying special attention to usability, productivity and performance aspects. Moreover, we performed a thorough benchmark containing important low level SIP core functions and algorithms and compared the outcome with the corresponding results for MATLAB. We found that the capabilities of these languages are comparable to MATLAB and they are powerful enough to efficiently implement complex SIP algorithms. Productivity and performance results for each language vary depending on the specific task and the availability of high level functions in each system to address such tasks. Therefore, the choice of the best language to use in a particular instance will strongly depend upon the specifics of the SIP application that needs to be addressed. We concluded that Octave and Python look like promising tools that may provide an alternative to MATLAB without compromising performance and productivity. Their syntax and functionality are similar enough to MATLAB to present a very shallow learning curve for experienced MATLAB users

Survey of Parallel MATLAB Techniques and Applications to Signal and Image Processing

We present a survey of modern parallel MATLAB techniques. We concentrate on the most promising and well supported techniques with an emphasis in SIP applications. Some of these methods require writing explicit code to perform inter-processor communication while others hide the complexities of communication and computation by using higher level programming interfaces. We cover each approach with special emphasis given to performance and productivity issues.

Interfacing PC-based MATLAB Directly to HPC Resources

Many DoD HPC users, particularly in the SIP area, run codes developed with MATLAB and related applications (MatlabMPI, StarP, pMatlab, etc.). There is a desire to run codes from a desktop instance of MATLAB and connect to and interact with codes running on HPC resources. The PET SIP team has developed and demonstrated technology that makes this possible. The SSH toolbox for MATLAB enables users to connect to and use HPC resources using SSH without leaving the MATLAB environment. The toolbox uses a freely available implementation of SSH, a modified version of which is also used by the DoD HPCMP. The SSH toolbox consists of a Windows DLL written in C, which is used by MATLAB to communicate with the SSH client. The toolbox provides simple MATLAB commands for users to connect to remote resources, run code, retrieve results and end the SSH session. The complexity of the DLL interface and most of the security needs are hidden from the user, making this a very easy to use and powerful toolbox. Since the main component of the toolbox is written is C and packaged as a DLL, the toolbox can also be extended to work with other programming languages such as Java, Python and Octave. MATLAB-style documentation for the toolbox also makes it easy to obtain help on various aspects of the toolbox and a GUI-based installer makes distribution easier. This technology provides a revolutionary way of providing support to the DoD. Software developers are now able to provide all the hooks to a complicated HPC environment, thus removing the burden of end users

Enabling High-Productivity SIP Application Development: Modeling and Simulation of Superconducting Quantum Interference Filters

The inherent complexity in utilizing and programming high performance computing (HPC) systems is the main obstacle to widespread exploitation of HPC resources and technologies in the Department of Defense (DoD). Consequently, there is the persistent need to simplify the programming interface for the generic user. This need is particularly acute in the Signal/Image Processing (SIP), Integrated Modeling and Test Environments (IMT), and related DoD communities where typical users have heterogeneous unconsolidated needs. Mastering the complexity of traditional programming tools (C, MPI, etc.) is often seen as a diversion of energy that could be applied to the study of the given scientific domain. Many SIP users instead prefer high-level languages (HLLs) within integrated development environments, such as MATLAB. We report on our collaborative effort to use a HLL distribution for HPC systems called ParaM to optimize and parallelize a compute-intensive Superconducting Quantum Interference Filter (SQIF) application provided by the Navy SPAWAR Systems Center in San Diego, CA. ParaM is an open-source HLL distribution developed at the Ohio Supercomputer Center (OSC), and includes support for processor architectures not supported by MATLAB (e.g., Itanium and POWER5) as well as support for high-speed interconnects (e.g., InfiniBand and Myrinet). We make use of ParaM installations available at the Army Research Laboratory (ARL) DoD Supercomputing Resource Center (DSRC) and OSC to perform a successful optimization/parallelization of the SQIF application. This optimization/parallelization may be used to assess the feasibility of using SQIF devices as extremely sensitive detectors for electromagnetic radiation which is of great importance to the Navy and DoD in general.

Parallel MATLAB Using Standard MPI Implementations

Traditionally, applications written in MATLAB are oriented to single-processor systems. However, by applying standard parallel processing techniques and Message Passing Interface (MPI) implementations, these applications can benefit from the advantages of parallel computing. bcMPI facilitates this approach by providing MATLAB wrappers for calls to industrial-strength open-source MPI implementations such as MPICH and LAM-MPI. Originally written by the Ohio Supercomputing Center (OSC), the authors transformed bcMPI for general implementation. This result is independent of operating system, does not attempt to create another MPI implementation, and uses network message passing instead of shared files as in the Matlab MPI approach to parallel MATLAB. Strong potential for the porting of bcMPI to Simulink has also been demonstrated. With either MATLAB or Simulink, it is possible to generate stand-alone executables and go directly to production without a language-translation step. This removes a significant barrier to technology transition. The DoD version of bcMPI is freely available through DoD HPC Centers, making the tool accessible from anywhere via the users desktop and standard Internet Kerberized connections.

Enhancements to MatlabMPI: Easier Compilation, Collective Communication, and Profiling

This paper provides a brief overview of several enhancements made to the MatlabMPI suite. MatlabMPI is a pure MATLAB code implementation of the core parts of the MPI specifications. The enhancements provide a more attractive option for HPCMP users to design parallel MATLAB code. Intelligent compiler configuration tools have also been delivered to further isolate MatlabMPI users from the complexities of the UNIX environments on the various HPCMP systems. Users are now able to install and use MatlabMPI with less difficulty, greater flexibility, and increased portability. Collective communication functions were added to MatlabMPI to expand functionality beyond the core implementation. Profiling capabilities, producing TAU (tuning and analysis utility) trace files, are now offered to support parallel code optimization. All of these enhancements have been tested and documented on a variety of HPCMP systems. All material, including commented example code to demonstrate the usefulness of MatlabMPI, is available by contacting the authors

Web Interface for Querying/Searching RDF Database

The resource description framework (RDF) is a language for representing information about resources on the web. However, RDF can also be used to describe other data and relationships between objects in the data. Many applications in the signal/image processing (SIP) community (such as radar imaging, electromagnetics, etc.) generate large amounts of data. Researchers would like to have online access to this data as well as the ability to easily explore and mine the data. Our applications RDF metadata representation is similar to that of a conventional database, and users can use forms to search the database, or use the standard RDF query language SPARQL, to create queries. In most cases, all the data as well as the RDF description of the data resides on secure Department of Defense (DoD) major shared resource center (MSRC) resources. In order to provide a web interface for exploring this data, we need a secure way to access the user data. Towards this goal, we use the user interface toolkit (UIT) to provide a web application that allows users to browse and search the RDF metadata of large SIP databases securely and conveniently on their desktop. The UIT uses the same Kerberos technology and Secure ID cards that are used to access all MSRC machines and provides an application programming interface (API) for building clients to access computing resources in the DoD high performance computing and modernization program (HPCMP).

Applications in Parallel MATLAB

The parallel MATLAB implementations used for this project are MatlabMPI and pMATLAB, both developed by Dr. Jeremy Kepner at MIT-LL. MatlabMPI is based on the message passing interface standard, in which processes coordinate their work and communicate by passing messages among themselves. The pMATLAB library supports parallel array programming in MATLAB. The user program defines arrays that are distributed among the available processes. Although communication between processes is actually done through message passing, the details are hidden from the user. The objective of this PET project was to develop parallel MATLAB code for selected algorithms that are of interest to the Department of Defense (DoD) signal/image processing (SIP) community and to run the code on the HPCMP systems. The algorithms selected for parallel MATLAB implementation were a support vector machine (SVM) classifier, metropolis-Hastings Markov chain Monte Carlo (MCMC) simulation, and content-based image compression (CBIC)