based on Python 2.7.13 (see original README)
© 2011-2017 CSC - IT Center for Science Ltd.
authors: Jussi Enkovaara & Martti Louhivuori
Special Python interpreter intended for massively parallel HPC systems.
When using Python for parallel applications, standard Python puts a lot of pressure on the filesystem with multiple processes accessing several small files during import statements. With thousands of processes the startup time of a Python application can be more than 30 minutes.
Scalable Python performs the I/O operations used e.g. by import statements in a single process and uses MPI to transmit data to/from all other processes. Please see the inherent limitation of this approach.
Use --enable-mpi
option for configure, e.g.
./configure --enable-mpi
Build and install normal Python interpreter (python
) as well as standard
modules etc.
make
make install
Build and install the special Python interpreter (python_mpi
)
make mpi
make install-mpi
By default, the MPI related parts are build using mpicc
, but an alternative
MPI compiler can be specified using the environment variable MPICC (e.g.
export MPICC=cc
).
Installation creates two executables:
- python is the standard Python interpreter, which can be used for normal serial applications and e.g. for software installations.
- python_mpi is the special Python interpreter that wraps I/O calls and
uses MPI for communication, and thus has to be started with
mpirun
(or an equivalent MPI launch command), e.g.
mpirun -np 16384 python_mpi my_application.py
It is possible to disable the special I/O wrappers on-the-fly and revert to
the standard POSIX calls by using the built-in function wrapoff()
in a
Python script. For example:
wrapoff()
from numpy import array
Similarly, they can be turned back on with the built-in function wrapon()
.
All MPI processes have to perform the same I/O operations (e.g. import statements). For example, a code like this
if rank == 0:
import mymodule
is NOT allowed. If you need to do it, please use the wrapoff()
and
wrapon()
functions to disable the special I/O wrappers temporarily.
If you experience an unexpected deadlock while using Scalable Python, it is most likely due to triggering this limitation. Unfortunately, even some standard modules use in-function import statements, so the root cause may turn out to be an innocent looking function call within an if statement. If needed, you can try to turn off the special I/O wrappers e.g. after the initial module imports.