This is an old revision of the document!


Running Molpro on parallel computers

Molpro will run on distributed-memory multiprocessor systems, including workstation clusters, under the control of the Global Arrays parallel toolkit or the MPI-2 library. There are also some parts of the code that can take advantage of shared memory parallelism through the OpenMP protocol, although these are somewhat limited, and this facility is not at present recommended. It should be noted that there remain some parts of the code that are not, or only partly, parallelized, and therefore run with replicated work. Additionally, some of those parts which have been parallelized rely on fast inter-node communications, and can be very inefficient across ordinary networks. Therefore some caution and experimentation is needed to avoid waste of resources in a multiuser environment.

Molpro effects interprocess cooperation through MPI and the ppidd library, which, depending on how it was configured and built, draws on either the GlobalArrays (GA) parallel toolkit or pure MPI. ppidd is described in Comp. Phys. Commun. 180, 2673-2679 (2009). The use of GlobalArrays (GAs) is recommended for performances considerations. There are different GA implementation options (runtimes), and there are advantages and disadvantages for using one or the other implementation (see GA Installation).

The Molpro binary is built with the –with-sockets GA runtime, which requires pre-allocation of GA memory in some large calculations. Failing to pre-allocate sufficient amount of GAs may lead to crashes or incorrect results, unless the disk option is used. It is therefore very important to read and understand memory specifications before trying to run large scale parallel calculations with Molpro.

The following additional options for the molpro command may be used to specify and control parallel execution. In addition, appropriate memory specifications (-m, -M, -G) are important, see section memory specifications.

  • -n $|$ --tasks tasks/tasks_per_node:smp_threads tasks specifies the number of parallel processes to be set up, and defaults to 1. tasks_per_node sets the number of GA(or MPI-2) processes to run on each node, where appropriate. The default is installation dependent. In some environments (e.g., IBM running under Loadleveler; PBS batch job), the value given by -n is capped to the maximum allowed by the environment; in such circumstances it can be useful to give a very large number as the value for -n so that the control of the number of processes is by the batch job specification. smp_threads relates to the use of OpenMP shared-memory parallelism, and specifies the maximum number of OpenMP threads that will be opened, and defaults to 1. Any of these three components may be omitted, and appropriate combinations will allow GA(or MPI-2)-only, OpenMP-only, or mixed parallelism.
  • -N $|$ --task-specification user1:node1:tasks1,user2:node2:tasks2$\dots$ node1, node2 etc. specify the host names of the nodes on which to run. On most parallel systems, node1 defaults to the local host name, and there is no default for node2 and higher. On Cray T3E and IBM SP systems, and on systems running under the PBS batch system, if -N is not specified, nodes are obtained from the system in the standard way. tasks1, tasks2 etc. may be used to control the number of tasks on each node as a more flexible alternative to -n / tasks_per_node. If omitted, they are each set equal to -n / tasks_per_node. user1, user2 etc. give the username under which processes are to be created. Most of these parameters may be omitted in favour of the usually sensible default values.
  • -t $|$ --omp-num-threads n Specify the number of OpenMP threads, as if the environment variable OMP_NUM_THREADS were set to n.
  • --ga-impl method specifies the method by which large data structure are held in parallel. Available options are GA (GlobalArrays, default) for disk (MPI Files, see disk option). This option is most relevant on the more recent programs such as Hartree-Fock, DFT, MCSCF/CASSCF, and the PNO programs.

Large scale parallel Molpro calculations may involve significant amount of global data structure. This concerns in particular PNO-LCCSD calculations, and, to a lesser extent, also Hartree-Fock, DFT, and MCSCF/CASSCF calculations. For these calculations, it may be necessary to share the available memory of the machine between molpro “stack” memory (determined by the -m command line option or the memory card in the input file) and the GA memory (determined by the -G command line option):

  1. If the disk option is disabled (the default) and one of the older GA runtimes (sockets, openib, etc.) is used (including when using the Molpro binary release): Sufficient amount of GA memory must be specified by the -G or -M option (see below) and pre-allocated by Molpro in the beginning of a calculation, otherwise the calculation may crash or yields incorrect results.
  2. If the disk option is disabled and one of the comex-based GA runtimes (e.g. mpi-pr) is used, or if the disk option is enabled but the scratch is in a tmpfs: the -G or -M option is not mandatory, but sufficient physical memory shall be left for the global data structure.
  3. If the disk option is enabled and the scratch directory is located on a physical disk: the GA usage should be negligible and the -G or -M options should not be given.

Both the -m and -G options are by default given in megawords (m) but unit gigaword (g) can also be used (e.g. -m1000 is equivalent to -m1000m and to -m1g). The total memory $M$ per node allocated by molpro amounts to $(n \cdot m+G)/N$, where $n$ is the total number of processes (-n option), $m$ is the stack memory per process (-m option), $G$ the GA memory (-G option), and $N$ the number of nodes. In addition, at least 200 MW per process should be added for the program itself. In total, a calculation needs about $8\cdot[n\cdot(m+0.3)+G]/N$ GB (gigabytes) of memory ($n,m,G$ in gw), and this should not exceed the physical memory of the machine(s) used. We do note that in many calculations leaving some memory for the system to buffer I/O operations may improve the performance significantly.

A proper ratio for the splitting between “stack” and GA memory depends on the calculation and the system. Some experiments are usually required to obtain optimal performance. As a rule of thumb, the following choice can be used as a starting point:

  • Density fitting and PNO calculations: divide the memory into equal parts for GA and stack memory.
  • HF, DFT, and MCSCF calculations: 80% for the stack and 20% for GA.
  • Canonical MRCI or CCSD(T) calculations on one-node: no GA space is needed.

In order to facilitate the memory splitting, the -M option is provided (in the following, its value is denoted $M$). With this, the total memory allocatable by Molpro can be specified, and the memory is split 50-50 for stack and GA in DF/PNO calculations, and 80-20 in other calculations. Thus, unless specified otherwise, in DF/PNO calculations the stack memory per process is $m=M\cdot N/(2\cdot n)$ and the total GA memory is $G=N\cdot M/2$. It is recommended to provide a default -M value in .molprorc (except for disk-based calculation that does not use GA, see disk option), e.g. -M=25g for a dedicated machine with 256 GB of memory and 20 cores (.molprorc can be in the home directory and/or in the submission directory, the latter having preference). Then each Molpro run would be able to use the whole memory of the machine with reasonable splitting between stack and GA. The default can be overwritten or modified by molpro command line options -m and/or -G, or by input options (cf. section memory allocation), the latter having preference over command line options.

If the -G or -M options are given, some programs check at early stages if the GA space is sufficient. If not, an error exit occurs and the estimated amount of required GA is printed. In this case the calculation should be repeated, specifying (at least) the printed amount of GA space with the -G option. If crashes without such message occur, the calculation should also be repeated with more GA space or with the disk option, but care should be taken that the total memory per node does not get too large.

The behavior of various option combinations is as follows:

  • -M As described above.
  • -M and -m The specified amount $m$ is allocated for each core, the the remaining memory for GA.
  • -M and -G The specified amount $G$ is allocated for GA, and the remaining amount is split equally for stack memory of each process.
  • -M and -G and -m The specified amounts of $m$ and $G$ are allocated, and the $M$ value is ignored.
  • -G and -m The specified amounts of $m$ and $G$ are allocated.
  • -m The specified amount of $m$ is allocated. An infinite amount of GA space is assumed, but nothing is preallocated or checked.
  • -G The specified amount of $G$ is allocated, and the same total amount for stack memory (i.e. $M=2G$).
  • nothing Same as -m32m.

If the -G or -M are present, the GA space is preallocated unless GA is using helper processes (i.e., a comix-based runtime is used and preallocation of GA is not necessary). If neither -G nor -M are given, no preallocation and no checks of GA space are performed.

Since version 2021.1, Molpro can use MPI files instead of GlobalArrays to store large global data. This option can be enabled globally by setting the environment variable MOLPRO_GA_IMPL to DISK, or by passing the –ga-impl disk command-line option. Some programs in Molpro (DF-HF, DF-KS, DF-MULTI, DF-TDDFT, PNO-LCCSD) also support an input option implementation=disk to enable the disk option. This file system for these MPI files must be accessible by all processors. If the path is different from the default Molpro scratch directory (which is supposedly shared by processors on each node), the -D command line option or the MOLPRO_GLOBAL_SCRATCH environment variable can be used. The directory can be tmpfs (e.g., -D /dev/shm) in single-node calculations.

With the disk option one can avoids the problems associated with GA pre-allocation. Please use only -m or the memory card to specify Molpro scratch memory for each processor, and do not provide -M or -G to avoid GA preallocation. Please also make sure -M and -G are not present in .molprorc, etc.

The performance of the disk option varies depending on the I/O capacity, available system memory, the MPI software, and the nature of the calculation. Usually, the best practice is to reserve some system memory for the system to buffer I/O operations (i.e., not to allocate all available memory to Molpro with -m or the memory input card). When this is done the performance of single-node disk-based calculations can be very comparable to GA-based ones in many cases.

The numerical computation of gradients or Hessians, or the automatic generation of potential energy surfaces, requires many similar calculations at different (displaced) geometries. An automatic parallel computation of the energy and/or gradients at different geometries is implemented for the gradient, hessian, and surf programs. In this so-called mppx-mode, each processing core runs an independent calculation in serial mode. This happens automatically using the -n available cores. The automatic mppx processing can be switched off by setting option mppx=0 on the OPTG, FREQ, or HESSIAN command lines. In this case, the program will process each displacement in the standard parallel mode.

This section is not applicable if the Molpro binary release is used, or when Molpro is built using the GlobalArrays toolkit (which we recommend).

In the case of the pure MPI implementation of PPIDD, there is a choice of using either MPI-2 one-sided memory access, or devoting some of the processes to act as data “helpers”. It is generally found that performance is significantly better if at least one dedicated helper is used, and in some cases it is advisable to specify more. The scalable limit is to devote one core on each node in a typical multi-core cluster machine, but in most cases it is possible to manage with fewer, thereby making more cores available for computation. The options below

  • --multiple-helper-server nprocs_per_server enables the multiple helper servers, and nprocs_per_server sets how many processes own one helper server. For example, when total number of processes is specified as $32$ and $nprocs\_per\_server=8$, then every $8$ processes(including helper server) will own one helper server, and there are $4$ helper servers in total. For any unreasonable value of $nprocs\_per\_server$ (i.e., any integer less than 2), it will be reset to a very large number automatically, and this will be equivalent to option --single-helper-server.
  • --node-helper-server specifies one helper server on every node if all the nodes are symmetric and have reasonable processes (i.e., every node has the same number of processes, and the number should be greater than 1), and this is the default behaviour. Otherwise, only one single helper server for all processes/nodes will be used, and this will be equivalent to option --single-helper-server
  • --single-helper-server specifies only one single helper server for all processes.
  • --no-helper-server disables the helper server.

In the cases of one or more helper servers enabled, one or more processes act as data helper servers, and the rest processes are used for computation. Even so, it is quite competitive in performance when it is run with a large number of processes. In the case of helper server disabled, all processes are used for computation; however, the performance may not be good because of the poor performance of some existing implementations of the MPI-2 standard for one-sided operations.