Conference Paper

High-performance technical computing with erlang

DOI: 10.1145/1411273.1411281 Conference: Proceedings of the 7th ACM SIGPLAN workshop on ERLANG, Victoria, BC, Canada, September 27, 2008
Source: DBLP

ABSTRACT High-performance Technical Computing (HPTC) is a branch of HPC (High-performance Computing) that deals with scientific applications, such as physics simulations. Due to its numerical nature, it has been traditionally based on low-level or mathematically-oriented languages (C, C++, Fortran), extended with libraries that implement remote execution and inter-process communication (like MPI and PVM). But those libraries just provide what Erlang does out-of-the-box: networking, process distribution, concurrency, interprocess communication and fault tolerance. So, is it possible to use Erlang as a foundation for developing HPTC applications? This paper shows our experiences in using Erlang for distributed number-crunching systems. We introduce two extensions: a simple and efficient foreign function interface (FFI), and an Erlang binding for numerical libraries. We use them as a basis for developing a simple mathematically-oriented programming language (in the style of Matlab™) compiled into Core Erlang. These tools are later used for creating a HPTC framework (based on message-passing) and an IDE for distributed applications. The results of this research and development show that Erlang/OTP can be used as a platform for developing large and scalable numerical applications.

Download full-text


Available from: Piero Pili, May 19, 2015
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: This is a (not so short) summary of the MSc thesis defended by Alceste Scalas and Giovanni Casu on April 2011 (coordinator: prof. G. Michele Pinna; advisor: Dr Piero Pili). The complete work (which is written in Italian) can be downloaded as CRS4 Technical Report 11/14 (see [19]). The chapter numbering has been preserved, in order to make it easier to check the original materials (e.g. for additional figures, tables and references). The first part of the thesis (from page 3) describes our work during the RTSim project at CRS4 (Center for Advanced Studies, Research and Development in Sardinia), consisting in the development of an Erlang-based framework for parallel and distributed computing (called FLOW) to be used for combined cycle power plant (CCPP) simulation. A relevant part of the contents appeared in the paper we presented at the ACM ICFP 2008 Erlang Workshop [20] — in which, however, we didn't mention thermoelectric plants: it was not essential, and this little omission simplified the clearance by Ansaldo Energia— (one of the project partners) for sensible information and industrial secrets. The paper will be referenced when necessary. The second part (from page 10) presents a formal model for FLOW-based applications. The model is analysed and translated into two different process algebras (one based on íµí¼‹-calculus, and another on the Linda coordination language); it is finally verified that these translations are "correct", in the sense that they preserve the communication topology of processes.
  • [Show abstract] [Hide abstract]
    ABSTRACT: The trend in processor design is to build more cores on a single chip. Commercial many-core processor is emerging these years. Intel Xeon Phi coprocessor , which is equipped with at least 60 relatively slow cores, is the first commercial many-core product released by Intel. Xeon Phi coprocessor is encapsulated in a PCIe card and communicates with host operating system through a specialized interface library called SCIF. In this paper, we propose a solution that integrates the computing power of multi-core host machine and Xeon Phi many-core coprocessor. The solution is based on the distribution facilities of Erlang. This paper proposes a highly optimized distribution carrier driver based on SCIF. This driver can both exploit the advantage of SCIF to the full and shield the performance gap between host and coprocessor. User applications can make use of the extra computing resources provided by many-core coprocessor without even knowing the existence of it.
    Proceedings of the twelfth ACM SIGPLAN workshop on Erlang; 09/2013