# Poisson benchmark

## Parallel ISF solver

This benchmark measures the speed-up of the parallel ISF poisson solver for 1, 2, and 4 processors on a dual dual-core machine of the AMD64 cluster at FU Berlin. The measurement is done with an all-electron calculation of a Li-H-chain on a large mesh (more than one million points, see input file below).

The following table lists the total time spent in the dpoisson_solve (POISSON_SOLVE-tag) routine and the overall runtime of the calculation (COMPLETE_DATASET-tag). The last column shows the percentage of time spent solving Poisson's equation. It is remarkable that it almost keeps constant. This means that the ISF's speed-up is roughly comparable to the domain parallelisation's speed-up, at least up to four processors.

Processors Poisson Overall Poisson/Overall
1 913 s 2494 s 37 %
2 654 s 1789 s 37 %
4 485 s 1420 s 34 %

The speed-up with several processes running on different nodes is actually a speed-down, at least on a Gigabit ethernet cluster. So, I neither put the numbers here nor recommend using it that way.

The following input file was used for the benchmarking:

```ProfilingMode = yes

SystemName = "LiH"
CalculationMode = gs
Units = "eVA"
FromScratch = yes

FlushMessages = yes

ndimers=4
bl=1.68058568860
bl2=1.68058568860/2.0

delta = bl2/7

%Coordinates
"Li_a" | -bl2 - 3*bl | 0 | 0 | yes
"H_a"  | -bl2 - 2*bl | 0 | 0 | yes
"Li_a" | -bl2 - bl   | 0 | 0 | yes
"H_a"  | -bl2        | 0 | 0 | yes
"Li_a" |  bl2        | 0 | 0 | yes
"H_a"  |  bl2 + bl   | 0 | 0 | yes
"Li_a" |  bl2 + 2*bl | 0 | 0 | yes
"H_a"  |  bl2 + 3*bl | 0 | 0 | yes
%

%Species
"Li_a" | 6.9410000 | spec_all_e | 3
"H_a"  | 1.0079400 | spec_all_e | 1
%

BoxShape = cylinder
xlength = bl2 + (ndimers-1)*bl + 4.0
Spacing = delta

XCFunctional = oep_x
OEP_Level = oep_kli

MaximumIter = 200
ConvAbsDens = 1e-6

LCAOStart = no

EigenSolver = cg
EigenSolverInitTolerance = 1e-2
EigenSolverFinalTolerance = 1e-5
EigenSolverFinalToleranceIteration = 6
EigenSolverMaxIter = 25

TypeOfMixing = broyden
What2Mix = potential

ConvRelDens = 1.0e-6

PoissonSolver = isf

NumberUnoccStates = 10
```

Lorenzen 17:56, 22 January 2007 (WET)

## Old benchmark

This is benchmark comparing the different poisson solvers in octopus, the run is the calculation of ground state for N_2. Each run was repeated 3 times, there were no significative differences in time between them.

The system test is a K8 CPU, 2.5 GHz, 1 Gb RAM DDR500.

• The differences are quite significative.
• FFT is the fastest solver
• Multigrid is the fastest in real space
• CG's show a very strange behaviour
• Making the same benchmark for other kinds of run would be interesting.

This is the input file (Spacing and PoissonSolver are passed as environment variables):

```
CalculationMode = gs

fromScratch = yes

LCAOStart = no

UnitsOuput = "eVA"

UnitsInput = "eVA"

%Coordinates
"Na" | 0 | 0 | -1.54 | no
"Na" | 0 | 0 |  1.54 | no
%

```

And this is the script used:

```#!/bin/bash

#PARAMETERS

octopuscmd=octopus
starth=0.14
endh=0.4
steps=12
power=(-3.0)
reps=3
outfile=benchmark.dat
timecmd=/usr/bin/time

##########################################################################

echo "#points fft multigrid cg cg_corrected" > \$outfile

xi=`echo \$starth\*\*\(\$power\) | octave -q | cut -d = -f 2`
xf=`echo \$endh\*\*\(\$power\) | octave -q | cut -d = -f 2`
dx=`echo \( \$xf - \$xi \)/\$steps | bc -l`

for x in `seq \$xi \$dx \$xf`
do

OCT_Spacing=`echo \$x\*\*\(1.0/\(\$power\)\) | octave -q | cut -d = -f 2`

echo \$OCT_Spacing

for OCT_PoissonSolver in fft multigrid cg cg_corrected
do

export OCT_PARSE_ENV=1
export OCT_PoissonSolver
export OCT_Spacing

echo -n "*" \$OCT_PoissonSolver" "
totaltime=0.0
for t in `seq 1 \$reps`
do
rm -fr tmp/
\$timecmd -f "%U" --output=time.log \$octopuscmd > out
if [ \$? -ne  0 ]
then
echo
echo "Octopus exit with non zero error code"
exit
fi
thistime=`cat time.log`
totaltime=`echo \$thistime + \$totaltime | bc -l`
echo -n " ""\$thistime""s"
done
echo -n " tot: "\$totaltime"s"
totaltime=`echo scale=2 \; \$totaltime/\$reps | bc -l`
echo " av: "\$totaltime"s"

#read the number of points in the grid from octopus output and
#put it in the output file

if [ \$OCT_PoissonSolver == "fft" ]
then
npoints=`grep inner static/info | cut -f 2 -d '='`
echo -n \$npoints >> \$outfile
fi

echo -n " ""\$totaltime" >> \$outfile
done
echo >> \$outfile
done
```

--Xavier 16:37, 21 November 2005 (WET)