Re: Not able to get scaled performance on increasing number of threads

[Sparsh Mittal]

Here is the code:

#!/usr/bin/env rdmd
import std.stdio;
import std.concurrency;
import core.thread;
import std.datetime;
import std.conv;
import core.sync.barrier;



immutable int gridSize = 256;
immutable int MAXSTEPS = 50000;       /* Maximum number of 
iterations               */
immutable double TOL_VAL =0.00001;         /* Numerical Tolerance 
*/
immutable double omega =  0.376;
immutable double one_minus_omega = 1.0 - 0.376;


immutable int numberOfThreads = 2;


double MAX_FUNC(double a, double b)
{
  return a> b? a: b;
}

double ABS_VAL(double a)
{
  return a> 0? a: -a;
}

__gshared Barrier myLocalBarrier = null;
shared double[gridSize+2][gridSize+2] gridInfo;
shared double maxError = 0.0;

void main(string args[])
{

  for(int i=0; i<gridSize+2; i++)
  {
    for(int j=0; j<gridSize+2; j++)
    {
      if(i==0)
        gridInfo[i][j] = 1.0;
      else
        gridInfo[i][j] = 0.0;
    }
  }

  bool shouldCheck = false;
  bool isConverged = false;
  for(int iter = 1; iter <= MAXSTEPS; iter++)
  {
    shouldCheck = false;
    if(iter % 400 ==0)
    {
      shouldCheck = true;
      maxError = 0.0;
    }

      //This is Phase 1
    {
      myLocalBarrier = new Barrier(numberOfThreads+1);
      for (int cc=0; cc<numberOfThreads; cc++)
      {
        spawn(&SolverSlave, thisTid,cc, 0 ,shouldCheck);
      }


      myLocalBarrier.wait();
    }

     //This is Phase 2
    {
      myLocalBarrier = new Barrier(numberOfThreads+1);
      for (int cc=0; cc<numberOfThreads; cc++)
      {
       spawn(&SolverSlave, thisTid,cc, 1 ,shouldCheck );
      }

      myLocalBarrier.wait();
    }

    if( maxError <  TOL_VAL)
      {
        isConverged = true;
        break;
      }

  }
  if(isConverged)
    writeln("It converged");
  else
    writeln("It did not converge");
}



void SolverSlave(Tid owner, int myNumber, int remainder, bool 
shouldCheckHere)
{

  double sum =0;

  //Divide task among threads
  int iStart = ((myNumber*gridSize)/numberOfThreads) + 1;
  int iEnd =  (((myNumber+1)*gridSize)/numberOfThreads) ;



  for(int i=iStart; i<= iEnd; i++)
  {
    for(int j=1; j< gridSize+1; j++)
    {
      if( ((i+j)%2 ==remainder)) //Phase 1 or 2
      {
        sum = ( gridInfo[i  ][j+1] + gridInfo[i+1][j  ] +
            gridInfo[i-1][j  ] + gridInfo[i  ][j-1] )*0.25;

        //Should not check everytime to reduce synchronization 
overhead
        if(shouldCheckHere)
        {
          maxError = MAX_FUNC(ABS_VAL(omega 
*(sum-gridInfo[i][j])), maxError);
        }
        gridInfo[i][j] = one_minus_omega*gridInfo[i][j] + 
omega*sum;
      }

    }
  }

  myLocalBarrier.wait();
}