You should read this paper if you’re tasked with parallelizing an existing Java application or building a new parallel application with Java and performance is important to you. If you have previously developed with message passing interface (MPI), that’s an advantage because the implementation provided in this paper will feel familiar in many aspects and you will hit the ground running. That being said, the choice of Java as a development language is still a questionable decision because the original C library will always outperform the Java version and you don’t get the advantage of using high-level abstractions despite using Java.

The main idea behind the implementation described in this paper is the use of a thin wrapper around the native Open MPI binaries. This comes at the cost of portability, which is one of the main advantages of Java over C. However, the authors base their choice on the fact that C implementation is mature and fast and using it eliminates the need for developing all of the MPI functionality from scratch in Java.

Most Java ports of the MPI library have built the underlying implementations of functions in Java itself. This has been shown to be inefficient; performance losses are great when compared to the native C code. This is the main argument behind the implementation choices described in this paper. In other words: the less Java code there is to run, the better.

The paper describes the Java implementation of the MPI interface built on top of Open MPI. The authors have used the Java Native Interface (JNI) to propagate application programming interface (API) calls to the underlying pre-compiled binaries. The implementation was built with the Java philosophy in mind and provides useful abstractions to ease the process of application development.

The authors aimed to create an efficient Java implementation of MPI and have succeeded in doing so. Some of the benchmark applications show the same level of scalability on the Java version as the C version. However, overall native implementation always prevails in terms of performance and sometimes substantially, especially in the case of applications where low latency is important. The authors claim this inefficiency comes from the Java virtual machine (JVM) and not from the Java bindings. This guide will be ideal as a reference for someone planning to build MPI applications with Java since it provides both an overview of the API and useful suggestions of design decisions.