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

[Dmitry Olshansky]

01-Feb-2013 20:08, Sparsh Mittal пишет:
Here is the code:

Mine reiteration on it, with a bit of help from std.parallelism.
std.parallelism uses thread pool thus it's somewhat faster then creating 
threads anew.
Still it's instantaneous for me in a range of 30-40ms even with grid 
size of 1024 and 5M of iterations.

Have you enabled all of the optimizations? Correct switches are:

dmd -inline -O -release optimize_me.d

or

rdmd -inline -O -release optimize_me.d

to run after compile


import std.stdio;
import std.parallelism;
import std.datetime;
import std.conv;


immutable int gridSize = 1024;
immutable int MAXSTEPS = 5000_000;       /* 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;
}

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;
    }


    alias MyTask = typeof(task!(SolverSlave)(0, 0, false));
      //This is Phase 1
    {
      MyTask[numberOfThreads] tasks;
      foreach(cc; 0..numberOfThreads)
      {
        tasks[cc] = task!(SolverSlave)(cc, 0, shouldCheck);
        taskPool.put(tasks[cc]);
      }
      foreach(cc; 0..numberOfThreads)
        tasks[cc].yieldForce();
    }

     //This is Phase 2
    {
      MyTask[numberOfThreads] tasks;
      foreach(cc; 0..numberOfThreads)
      {
        tasks[cc] = task!(SolverSlave)(cc, 1, shouldCheck);
        taskPool.put(tasks[cc]);
      }
      foreach(cc; 0..numberOfThreads)
        tasks[cc].yieldForce();

    }

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

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



void SolverSlave(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;
      }

    }
  }

}









--
Dmitry Olshansky