There are different way to get the best parallelization performance from QE. Here are a few tips:

1. If your calculation consists of a large number of k-points, npool can strongly enhance the process. It must be a divisor of the total number of k-points. I personally set it to 4.

2. In combination with npool, you can further improve the performance using the bgrp command. It allows the program to split the KS states across the selected group of processors.

For example, assuming you have 32 cores you can try something like this,

mpirun –np 32 pw.x –npool 4 –bgrp 4 –input pw.in

3. You can also try to parallelize the matrix diagonalization routines, using ndiag command. Choose it such that ndiag

Hi Mohammad,

Thanks for your answer. I tried to implement it and it reduced the runtime by a factor of three. However, I have a few another ancillary questions, which I hope you could help on:

1. Can we judge the amount of parallelization by evaluating the difference between wall time and the cpu time?

I think a good way to know that parallelization happens, is that the difference between them is low. However, sine a lot of that time difference is accounted by MPI communications, I think using too many cores is a bad idea, right ?

2. In the output file, this is shown: Subspace diagonalization in iterative solution of the eigenvalue problem: a serial algorithm will be used

This changes by using ndiag. Is there some criteria to know when to use serial and when to use parallel for this process?

Much thanks for your previous answer, and hoping you could shed some light on these as well.

Dear Nabasindhu Das

Glad to hear you've made some improvements. Regarding your questions:

1. Yes, ideally there should be a linear down-scaling between the wall time and the number of cores (or cpu time). However, due to the lagging happening during the inter-node MPI communications, usually as the number of cores increases you start to notice a rapid deviation from linear scaling. This simply means after reaching a threshold, increasing cores is not going to help you (or in some cases actually can slow down the whole calculation). For small systems, I usually use only 16 to 32 cores and for big ones I personally have never gone beyond 128 cores (mind that this is just a personal preference due to my system settings).

2. QE used to do parallel subspace diagonalization in its earlier versions by default. The recent versions however do not do this by default, as it does not necessarily perform better than the serial one. As you already found out, you can explicitly turn this option on with the command-ine "-ndiag N". There's no clear criterion When you should choose one over another. Usually, if you're dealing with large matrices parallel subspace diagonalization works better, provided that your inter-node connections are fast.

Hope this information helps and good luck with your parallelizations.