Better speed test with indirect addressing.

applications/test/speed/Make/files

-speedTest.C
-
-EXE = $(FOAM_USER_APPBIN)/speedTest

applications/test/speed/Make/options

-EXE_INC = /* -ffast-math -mtune=core2 */

applications/test/speed/scalarSpeedTest/Make/files

+scalarSpeedTest.C
+
+EXE = $(FOAM_USER_APPBIN)/scalarSpeedTest

applications/test/speed/scalarSpeedTest/scalarSpeedTest.C

+#include "primitiveFields.H"
+#include "Random.H"
+#include "cpuTime.H"
+#include "IOstreams.H"
+#include "OFstream.H"
+
+using namespace Foam;
+
+int main()
+{
+    Info<< "Initialising fields" << endl;
+
+    const label nIter = 100;
+    const label size = 10000000;
+    const label rndAddrSkip = 40;
+    const label redFac = 6;
+    const label redSize = size/redFac;
+    Random genAddr(100);
+
+    double* f1 = new double[size];
+    double* f2 = new double[size];
+    double* f3 = new double[size];
+    double* f4 = new double[size];
+    double* fr = new double[redSize];
+    label*  addr = new label[size];
+    label*  redAddr = new label[size];
+    label*  redAddr2 = new label[size];
+
+    for (register label i=0; i<size; i++)
+    {
+        f1[i] = 1.0;
+        f2[i] = 1.0;
+        f3[i] = 1.0;
+        addr[i] = i;
+        redAddr[i] = i/redFac;
+        redAddr2[i] = (size - i - 1)/redFac;
+    }
+
+    for (register label i=0; i<size; i+=rndAddrSkip)
+    {
+        addr[i] = genAddr.integer(0, size-1);
+    }
+
+    for (register label i=0; i<redSize; i++)
+    {
+        fr[i] = 1.0;
+    }
+
+    Info<< "Done\n" <<endl;
+
+    {
+        Info<< "Single loop combined operation (expression templates)"
+            << endl;
+
+        cpuTime executionTime;
+
+        for (int j=0; j<nIter; j++)
+        {
+            for (register label i=0; i<size; i++)
+            {
+                f4[i] = f1[i] + f2[i] - f3[i];
+            }
+        }
+
+        Info<< "ExecutionTime = "
+            << executionTime.elapsedCpuTime()
+            << " s\n" << endl;
+
+        Snull<< f4[1] << endl << endl;
+    }
+
+    {
+        Info<< "Single loop combined operation with indirect addressing"
+            << endl;
+
+        cpuTime executionTime;
+
+        for (int j=0; j<nIter; j++)
+        {
+            for (register label i=0; i<size; i++)
+            {
+                f4[addr[i]] = f1[addr[i]] + f2[addr[i]] - f3[addr[i]];
+            }
+        }
+
+        Info<< "ExecutionTime = "
+            << executionTime.elapsedCpuTime()
+            << " s\n" << endl;
+
+        Snull<< f4[1] << endl << endl;
+    }
+
+    {
+        Info<< "Single loop reduction operation"
+            << endl;
+
+        cpuTime executionTime;
+        label redOffset = (size - 1)/redFac;
+
+        for (int j=0; j<nIter; j++)
+        {
+            for (register label i=0; i<size; i++)
+            {
+                label j = i/redFac;
+                fr[j] += f1[i];
+                fr[redOffset - j] -= f2[i];
+            }
+        }
+
+        Info<< "ExecutionTime = "
+            << executionTime.elapsedCpuTime()
+            << " s\n" << endl;
+
+        Snull<< fr[1] << endl << endl;
+    }
+
+    {
+        Info<< "Single loop reduction operation with indirect addressing"
+            << endl;
+
+        cpuTime executionTime;
+
+        for (int j=0; j<nIter; j++)
+        {
+            for (register label i=0; i<size; i++)
+            {
+                fr[redAddr[i]] += f1[i];
+                fr[redAddr2[i]] -= f2[i];
+            }
+        }
+
+        Info<< "ExecutionTime = "
+            << executionTime.elapsedCpuTime()
+            << " s\n" << endl;
+
+        Snull<< fr[1] << endl << endl;
+    }
+
+    {
+        Info<< "Separate loops ?= operations" << endl;
+
+        cpuTime executionTime;
+
+        for (int j=0; j<nIter; j++)
+        {
+            for (register label i=0; i<size; i++)
+            {
+                f4[i] = f1[i];
+            }
+            for (register label i=0; i<size; i++)
+            {
+                f4[i] += f2[i];
+            }
+            for (register label i=0; i<size; i++)
+            {
+                f4[i] -= f3[i];
+            }
+        }
+
+        Info<< "ExecutionTime = "
+            << executionTime.elapsedCpuTime()
+            << " s\n" << endl;
+
+        Snull<< f4[1] << endl << endl;
+    }
+
+    {
+        Info<< "OpenFOAM field algebra" << endl;
+
+        scalarField
+            sf1(size, 1.0),
+            sf2(size, 1.0),
+            sf3(size, 1.0),
+            sf4(size);
+
+        cpuTime executionTime;
+
+        for (int j=0; j<nIter; j++)
+        {
+            //sf4 = sf1 + sf2 - sf3;
+            sf4 = sf1;
+            sf4 += sf2;
+            sf4 -= sf3;
+        }
+
+        Info<< "ExecutionTime = "
+            << executionTime.elapsedCpuTime()
+            << " s\n" << endl;
+
+        Snull<< sf4[1] << endl << endl;
+    }
+}

applications/test/speed/speedTest.C

-#include "primitiveFields.H"
-#include "cpuTime.H"
-#include "IOstreams.H"
-
-using namespace Foam;
-
-int main()
-{
-    const label nIter = 10;
-    const label size = 10000000;
-
-    double* f1 = new double[size];
-    double* f2 = new double[size];
-    double* f3 = new double[size];
-    double* f4 = new double[size];
-
-    for (register label i=0; i<size; i++)
-    {
-        f1[i] = 1.0;
-        f2[i] = 1.0;
-        f3[i] = 1.0;
-    }
-
-    cpuTime executionTime1;
-
-    for (int j=0; j<nIter; j++)
-    {
-        for (register label i=0; i<size; i++)
-        {
-            f4[i] = f1[i] + f2[i] - f3[i];
-        }
-    }
-
-    Info<< "ExecutionTime = "
-        << executionTime1.elapsedCpuTime()
-        << " s\n" << endl;
-
-    Info << f4[1] << endl << endl;
-
-
-    scalarField sf1(size, 1.0), sf2(size, 1.0), sf3(size, 1.0), sf4(size);
-
-    cpuTime executionTime2;
-
-    for (register int j=0; j<nIter; j++)
-    {
-        sf4 = sf1 + sf2 - sf3;
-        //sf4 = sf1;
-        //sf4 += sf2;
-        //sf4 -= sf3;
-    }
-
-    Info<< "ExecutionTime = "
-        << executionTime2.elapsedCpuTime()
-        << " s\n" << endl;
-
-    Info << sf4[1] << endl << endl;
-
-
-    vectorField 
-        vf1(size, vector::one),
-        vf2(size, vector::one),
-        vf3(size, vector::one),
-        vf4(size);
-
-    cpuTime executionTime3;
-
-    for (register int j=0; j<nIter; j++)
-    {
-        vf4 = vf1 + vf2 - vf3;
-    }
-
-    Info<< "ExecutionTime = "
-        << executionTime3.elapsedCpuTime()
-        << " s\n" << endl;
-
-    Info << vf4[1] << endl << endl;
-
-    cpuTime executionTime4;
-
-    scalarField sf11(size, 1.0), sf12(size, 1.0), sf13(size, 1.0), sf14(size);
-    scalarField sf21(size, 1.0), sf22(size, 1.0), sf23(size, 1.0), sf24(size);
-    scalarField sf31(size, 1.0), sf32(size, 1.0), sf33(size, 1.0), sf34(size);
-
-    for (register int j=0; j<nIter; j++)
-    {
-        sf14 = sf11 + sf12 - sf13;
-        sf24 = sf21 + sf22 - sf23;
-        sf34 = sf31 + sf32 - sf33;
-    }
-
-    Info<< "ExecutionTime = "
-        << executionTime4.elapsedCpuTime()
-        << " s\n" << endl;
-
-    Info << sf14[1] << sf24[1] << sf34[1] << endl << endl;
-
-
-}

applications/test/speed/vectorSpeedTest/Make/files

+vectorSpeedTest.C
+
+EXE = $(FOAM_USER_APPBIN)/vectorSpeedTest

applications/test/speed/vectorSpeedTest/vectorSpeedTest.C

+#include "primitiveFields.H"
+#include "cpuTime.H"
+#include "IOstreams.H"
+#include "OFstream.H"
+
+using namespace Foam;
+
+int main()
+{
+    const label nIter = 100;
+    const label size = 1000000;
+
+    Info<< "Initialising fields" << endl;
+
+    vectorField
+        vf1(size, vector::one),
+        vf2(size, vector::one),
+        vf3(size, vector::one),
+        vf4(size);
+
+    Info<< "Done\n" << endl;
+
+    {
+        cpuTime executionTime;
+
+        Info<< "vectorField algebra" << endl;
+
+        for (register int j=0; j<nIter; j++)
+        {
+            vf4 = vf1 + vf2 - vf3;
+        }
+
+        Info<< "ExecutionTime = "
+            << executionTime.elapsedCpuTime()
+            << " s\n" << endl;
+
+        Snull<< vf4[1] << endl << endl;
+    }
+}