Poisson benchmark

From OctopusWiki
Jump to: navigation, search

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
Radius  = 6
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)

Ground state calculation of an hydrogen atom

Poisson benchmark h.png


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.

Poisson benchmark.png

  • 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)