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 require a lot of of GA space. This concerns in particular pno-lccsd calculations (cf. section local correlation methods with pair natural orbitals (PNOs)), and, to a lesser extent, also Hartree-Fock, DFT, and MCSCF/CASSCF calculations with density fitting. If GA/sockets or GA/openib is used this may require to preallocate as much GA space as possible (see GA Installation). Thus, it is necessary to share the available memory of the machine between molpro stack memory (determined by -m) and the GA memory (determined by the -G option). Both 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 0.3 gw 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.

For canonical MRCI or CCSD(T) calculations on one node no GA space is needed and -G does not need to be specified. On the other hand, for PNO-CCSD(T)-F12 calculations on extended molecules, large GAs are needed, and a good rule of thumb is to divide the memory into equal parts for GA and stack memory. In order to facilitate this, the -M option is provided (in the following, its value is denoted $M$). With this, the total memory allocatable by Molpro can be specified. In density fitting (DF) and PNO calculations the memory is split into equal parts for stack and GA, other calculations use 80% for stack and 20% for GA. 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, but in any case 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 except with GA/mpi-pr. 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.