コード例 #1
0
int main()
{
    std::system("rm -rf timing.txt");
    std::ofstream outfile;
    outfile.open("timing.txt",std::ios::app);

    double *matrixArray=new double[9]; //Transformation Matrix array
    for(int i=0; i<9; i++)
    {
        *(matrixArray+i)=2.5;
    }
//Creating a Matrix using Blaze
    DynamicMatrix<double,rowMajor> A(3,3,matrixArray);
    std::cout<<A<<std::endl;
//Creating Matrix using Sandro's Library
    FastTransformationMatrix Av;
    Av.SetRotation(matrixArray);

//Actual Benchmarking stuff (doing transformation of dense Vector of N dimension using transformation matrix)
    int n=10000,N=0;
    int iter=20;
    int store=1,doValidation=1;
    int scalar=0.001;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


    for(int i=1; i<=iter; i++)
    {
        time_t t;
        time(&t);
        srand((double)t);

        N=n*i;
        double *testArray=new double[N*3];
        double *Vector3DFastArray=new double[N*3];
        double *BlazeArray=new double[N*3];
//double *denseBlazeArray=new double[N*3];
        for(int k=0 ; k<3*N ; k++)
        {
//testArray[k]=1.2;
            testArray[k]=rand()%100; //Assigning random number between 0 and 100   // previous giving 1.2
        }

        StopWatch tmr;
        double Tacc=0.0;

        double sum=0;
        int ent=10;
//for(int s=0 ; s<ent ; s++)

        {
            tmr.getOverhead(100);
            Tacc=0.0;
            tmr.Start();
            for(int j=0; j<N; j++)
            {
                Vector3DFast av(testArray+(3*j));
                Vector3DFast bv;
                Av.MasterToLocal<0,1>(av,bv); //Multiplying Matrix with Vector
                if(store)
                {
                    *(Vector3DFastArray+(3*j)+0)=bv.GetX();
                    *(Vector3DFastArray+(3*j)+1)=bv.GetY();
                    *(Vector3DFastArray+(3*j)+2)=bv.GetZ();
                }
            }
            tmr.Stop();
            Tacc=tmr.getDeltaSecs();
//sum+=Tacc;
        }
        std::cout<<"Execution Time N="<<N<<"  :  "<<Tacc<< " :::: ";
//outfile<<N*3<<"\t"<<sum/ent<<"\t";
        outfile<<N<<"\t"<<Tacc<<"\t";

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Below code uses Blaze and utilizing its 3D vectors to do dense vector addition
        sum=0;
//for(int s=0 ; s<ent ; s++)
        {
            tmr.getOverhead(100);
            Tacc=0.0;
            tmr.Start();
            for(int j=0; j<N; j++)
            {
//DynamicVector<double> a( 3 ), b( 3 ), c( 3 );
                StaticVector<double,3UL> a(3UL, testArray+(3*j));
//DynamicVector<double,rowVector> a(3UL, testArray+(3*j));
//StaticVector<double,3UL> a( 0, 0, 0 );
                StaticVector<double,3UL> b( 0, 0, 0 );
                b = A * a;
                if(store)
                {
                    *(BlazeArray+(3*j)+0)=b[0];
                    *(BlazeArray+(3*j)+1)=b[1];
                    *(BlazeArray+(3*j)+2)=b[2];
                }
            }
            tmr.Stop();
            Tacc=tmr.getDeltaSecs();
//sum+=Tacc;
        }
//std::cout<<Tacc<<std::endl;
        std::cout<<Tacc<<" :::: "<<std::endl;
//std::cout<<sumv<<"  ::  "<<sv;//<<std::endl;
//outfile<<sum/ent<<std::endl;
        outfile<<Tacc<<std::endl;



//Validating the results.
        if(doValidation)
        {
            for(int k=0 ; k<3*N ; k++)
            {
                if( (Vector3DFastArray[k]-BlazeArray[k]) )
                    std::cout<<"Value Differs"<<std::endl;
            }
        }

    }

    outfile.close();
    std::cout<<"******* Finished ********"<<std::endl;

}
コード例 #2
0
int main()
{
std::system("rm -rf timingVectorAddition.txt");
std::ofstream outfile;
outfile.open("timingVectorAddition.txt",std::ios::app);

int n=10000,N=0;
int iter=20;
int store=1,doValidation=1;

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

for(int i=1;i<=iter;i++)
{
//-------------------------------
//For generating random numbers
time_t t;
time(&t);
srand((double)t);
//-------------------------------
N=n*i;
double *testArray=new double[N*3];
double *Vector3DFastArray=new double[N*3];
double *BlazeArray=new double[N*3];

for(int k=0 ; k<3*N ; k++)
{
 testArray[k]=rand()%100; //Assigning random number between 0 and 100   // previous giving 1.2
 Vector3DFastArray[k]=0.0;
 BlazeArray[k]=0.0;
}

StopWatch tmr;
double Tacc=0.0;
tmr.getOverhead(100);
Tacc=0.0;
tmr.Start();
for(int j=0;j<N;j++)
{
//For testing purpose filling same array in both av and bv
Vector3DFast av(testArray+(3*j));
Vector3DFast bv(testArray+(3*j));
Vector3DFast cv;
cv=av+bv;
if(store)  //requires for data Validation
{
*(Vector3DFastArray+(3*j)+0)=cv.GetX();
*(Vector3DFastArray+(3*j)+1)=cv.GetY();
*(Vector3DFastArray+(3*j)+2)=cv.GetZ();
}
//sumv+=cv;
}
tmr.Stop();
Tacc=tmr.getDeltaSecs();
std::cout<<"Execution Time N="<<N*3<<"  :  "<<Tacc<< " :::: ";
outfile<<N<<"\t"<<Tacc<<"\t";

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Below code uses Blaze and utilizing its 3D vectors to do dense vector addition
Tacc=0.0;
tmr.getOverhead(100);
Tacc=0.0;
tmr.Start();
for(int j=0;j<N;j++)
{
//DynamicVector<double> a( 3 ), b( 3 ), c( 3 );
StaticVector<double,3UL,rowVector> a(3UL, testArray+(3*j));

//StaticVector<double,3UL> b( 2, 5, -3 );
StaticVector<double,3UL,rowVector> b( 3UL, testArray+(3*j) );

StaticVector<double,3UL,rowVector> c;
c=a+b;
//sv+=c;
if(store)  //requires for data Validation
{
*(BlazeArray+(3*j)+0)=c[0];
*(BlazeArray+(3*j)+1)=c[1];
*(BlazeArray+(3*j)+2)=c[2];
}
}
tmr.Stop();
Tacc=tmr.getDeltaSecs();
std::cout<<Tacc<<" :::: "<<std::endl;
outfile<<Tacc<<std::endl;

//Validating the results.
if(doValidation)
for(int k=0 ; k<3*N ; k++)
  {
	if( (Vector3DFastArray[k]-BlazeArray[k]) )
	    std::cout<<"Value Differs"<<std::endl;
  }
}

outfile.close();
std::cout<<"******* Finished ********"<<std::endl;


}
コード例 #3
0
int main(int argc, char * argv[])
{
   bool iterative=true;
   if(argc>1) iterative=false;
   Vectors3DSOA points, dirs, intermediatepoints, intermediatedirs;

   int np=1024;
   int NREPS = 1000;

   points.alloc(np);
   dirs.alloc(np);

   // generate benchmark cases
   TransformationMatrix const * identity = new TransformationMatrix(0,0,0,0,0,0);

   double L = 10.;
   double Lz = 10.;
   const double Sqrt2 = sqrt(2.);

   BoxParameters *   worldp =  new BoxParameters(L, L, Lz );
   PhysicalVolume * world = GeoManager::MakePlacedBox( worldp , identity );
   double volworld = worldp->GetVolume();

   BoxParameters * boxlevel2 = new BoxParameters( Sqrt2*L/2./2., Sqrt2*L/2./2., Lz );
   BoxParameters * boxlevel3 = new BoxParameters( L/2./2. ,L/2./2., Lz);
   BoxParameters * boxlevel1 = new BoxParameters( L/2., L/2., Lz );

   PhysicalVolume * box2 = GeoManager::MakePlacedBox(boxlevel2, new TransformationMatrix(0,0,0,0,0,45));
   PhysicalVolume * box3 = GeoManager::MakePlacedBox( boxlevel3, new TransformationMatrix(0,0,0,0,0,-45));
   box2->AddDaughter( box3 ); // rotated 45 degree around z axis

   PhysicalVolume * box1 = GeoManager::MakePlacedBox(boxlevel1, identity);
   box1->AddDaughter( box2 );

   PhysicalVolume const * box1left  = world->PlaceDaughter(GeoManager::MakePlacedBox(boxlevel1, new TransformationMatrix(-L/2.,0.,0.,0.,0.,0)), box1->GetDaughters());
   PhysicalVolume const * box1right = world->PlaceDaughter(GeoManager::MakePlacedBox(boxlevel1, new TransformationMatrix(+L/2.,0.,0.,0.,0.,0)), box1->GetDaughters());


    // perform basic tests
   SimpleVecNavigator nav(1, world);

   StopWatch timer;
   // some object which are expensive to create
   FastTransformationMatrix * m = new FastTransformationMatrix();
   VolumePath path(4);
   VolumePath newpath(4);

   timer.Start();
   int stepsdone=0;
   for(int n=0;n<1000;n++)
     {
   for(int i=0;i<100000;i++)
   // testing the NavigationAndStepInterface
   {
      int localstepsdone=0;
      double distancetravelled=0.;
      Vector3DFast p;
      PhysicalVolume::samplePoint( p, worldp->GetDX(), worldp->GetDY(), worldp->GetDZ(), 1. );
#ifdef DEBUG
      std::cerr << p << " " << worldp->GetDX()-p.GetX() << " ";
#endif

      // setup point in world
      Vector3DFast d(1,0,0);
      Vector3DFast resultpoint;

      m->SetToIdentity();
      PhysicalVolume const * vol;
#ifdef ITERATIVE
         vol = nav.LocatePoint_iterative( world, p, resultpoint, path, m );
#else
         vol = nav.LocatePoint( world, p, resultpoint, path, m );
#endif
         while( vol!=NULL )
      {
         localstepsdone++;
         // do one step
         double step;
#ifdef ITERATIVE
         nav.FindNextBoundaryAndStep_iterative(m, p, d, path, newpath, resultpoint, step);
#else
         nav.FindNextBoundaryAndStep(m, p, d, path, newpath, resultpoint, step);
#endif
         distancetravelled+=step;
#ifdef DEBUG
         std::cerr << "  proposed step: " << step << std::endl;
         std::cerr << "  next point " << resultpoint << std::endl;
         std::cerr << "  in vol " << newpath.Top() << std::endl;
#endif

         // go on with navigation
         p = resultpoint;
         path=newpath;
         vol=path.Top();
      }
#ifdef DEBUG
         std::cerr << localstepsdone << " " << distancetravelled << std::endl;
#endif
         stepsdone+=localstepsdone;
   }
     }
   timer.Stop();
   std::cout << " time for 100000 particles " << timer.getDeltaSecs( ) << std::endl;
   std::cout << " average steps done " << stepsdone / 100000. << std::endl;
   std::cout << " time per step " << timer.getDeltaSecs()/stepsdone << std::endl;

   delete m;
}