コード例 #1
0
ファイル: glStencilViewer.cpp プロジェクト: AiYong/OpenSubdiv
//------------------------------------------------------------------------------
static void
display() {

    Stopwatch s;
    s.Start();

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glViewport(0, 0, g_width, g_height);
    g_hud.FillBackground();

    double aspect = g_width/(double)g_height;
    identity(g_transformData.ModelViewMatrix);
    translate(g_transformData.ModelViewMatrix, -g_pan[0], -g_pan[1], -g_dolly);
    rotate(g_transformData.ModelViewMatrix, g_rotate[1], 1, 0, 0);
    rotate(g_transformData.ModelViewMatrix, g_rotate[0], 0, 1, 0);
    rotate(g_transformData.ModelViewMatrix, -90, 1, 0, 0);
    translate(g_transformData.ModelViewMatrix,
              -g_center[0], -g_center[1], -g_center[2]);
    perspective(g_transformData.ProjectionMatrix,
                45.0f, (float)aspect, 0.01f, 500.0f);
    multMatrix(g_transformData.ModelViewProjectionMatrix,
               g_transformData.ModelViewMatrix,
               g_transformData.ProjectionMatrix);

    glEnable(GL_DEPTH_TEST);

    drawStencils();

    // draw the control mesh
    g_controlMeshDisplay.Draw(g_stencilOutput->BindSrcBuffer(), 3*sizeof(float),
                              g_transformData.ModelViewProjectionMatrix);

    s.Stop();
    float drawCpuTime = float(s.GetElapsed() * 1000.0f);
    s.Start();
    glFinish();
    s.Stop();
    float drawGpuTime = float(s.GetElapsed() * 1000.0f);

    if (g_hud.IsVisible()) {
        g_fpsTimer.Stop();
        double fps = 1.0/g_fpsTimer.GetElapsed();
        g_fpsTimer.Start();

        g_hud.DrawString(10, -100,  "# stencils   : %d", g_nsamplesDrawn);
        g_hud.DrawString(10, -80,  "EvalStencils : %.3f ms", g_evalTime);
        g_hud.DrawString(10, -60,  "GPU Draw     : %.3f ms", drawGpuTime);
        g_hud.DrawString(10, -40,  "CPU Draw     : %.3f ms", drawCpuTime);
        g_hud.DrawString(10, -20,  "FPS          : %3.1f", fps);

        g_hud.Flush();
    }
    glFinish();

    //checkGLErrors("display leave");
}
コード例 #2
0
ファイル: viewer.cpp プロジェクト: mbdriscoll/OpenSubdiv
//------------------------------------------------------------------------------
void
updateGeom() {

    int nverts = (int)g_orgPositions.size() / 3;

    std::vector<float> vertex;
    vertex.reserve(nverts*6);

    const float *p = &g_orgPositions[0];
    const float *n = &g_normals[0];

    float r = sin(g_frame*0.001f) * g_moveScale;
    for (int i = 0; i < nverts; ++i) {
        float move = 0.05f*cosf(p[0]*20+g_frame*0.01f);
        float ct = cos(p[2] * r);
        float st = sin(p[2] * r);
        g_positions[i*3+0] = p[0]*ct + p[1]*st;
        g_positions[i*3+1] = -p[0]*st + p[1]*ct;
        g_positions[i*3+2] = p[2];
        
        p += 3;
    }

    p = &g_positions[0];
    for (int i = 0; i < nverts; ++i) {
        vertex.push_back(p[0]);
        vertex.push_back(p[1]);
        vertex.push_back(p[2]);
        vertex.push_back(n[0]);
        vertex.push_back(n[1]);
        vertex.push_back(n[2]);
        
        p += 3;
        n += 3;
    }

    if (!g_vertexBuffer)
        g_vertexBuffer = g_osdmesh->InitializeVertexBuffer(6);
    g_vertexBuffer->UpdateData(&vertex[0], nverts);

    Stopwatch s;
    s.Start();

    g_osdmesh->Subdivide(g_vertexBuffer, NULL);

    s.Stop();
    g_cpuTime = float(s.GetElapsed() * 1000.0f);
    s.Start();
    g_osdmesh->Synchronize();
    s.Stop();
    g_gpuTime = float(s.GetElapsed() * 1000.0f);

    glBindBuffer(GL_ARRAY_BUFFER, g_vertexBuffer->GetGpuBuffer());
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}
コード例 #3
0
static void do_parallel_map(Stopwatch& sw) {
  // Create a bunch of subcontexts from here and put them in a map
  auto all = create();
  ::ContextMap<size_t> mp;
  for (size_t i = N; i < all.size(); i++)
    mp.Add(i, all[i]);

  // Now the threads that will make progress hard:
  auto proceed = std::make_shared<bool>(true);
  for (size_t i = N; i--;)
    std::thread([proceed, mp] {
      while (*proceed)
        for (const auto& cur : mp)
          ;
    }).detach();
  auto cleanup = MakeAtExit([&] { *proceed = false; });

  std::this_thread::sleep_for(std::chrono::milliseconds(100));

  // Enumerate the map while iteration is underway
  sw.Start();
  for (auto& cur : mp)
    ;
  sw.Stop(n);
}
コード例 #4
0
ファイル: main.cpp プロジェクト: alxmglk/jacobi-method
int main(int argc, char* argv[])
{
	LinearEquationSystemFactory factory;
	LinearEquationSystemSolver solver;

	for (; n <= nLimit; n *= multiplier)
	{
		float minTime = FLT_MAX;
		for (int attempt = 0; attempt < repeatsNumber; ++attempt)
		{
			LinearEquationSystem* system = factory.Create(n);
			NUMBER* solution = new NUMBER[n];

			stopwatch.Start();			
			solver.Solve(system, solution);
			stopwatch.Stop();

			float elapsedSeconds = stopwatch.GetElapsedSeconds();
			if (elapsedSeconds < minTime)
			{
				minTime = elapsedSeconds;
			}

			bool result = checker.IsCorrectSolution(system, solution);
			printf("Correct: %s \n", result ? "yes" : "no");

			delete system;
			delete []solution;
		}

		printf("N = %d, Elapsed seconds: %f\n", n, minTime);
	}
}
コード例 #5
0
ファイル: glStencilViewer.cpp プロジェクト: AiYong/OpenSubdiv
static void
updateGeom() {

    int nverts = (int)g_orgPositions.size() / 3;

    const float *p = &g_orgPositions[0];

    float r = sin(g_frame*0.001f) * g_moveScale;

    g_positions.resize(nverts*3);

    for (int i = 0; i < nverts; ++i) {
        //float move = 0.05f*cosf(p[0]*20+g_frame*0.01f);
        float ct = cos(p[2] * r);
        float st = sin(p[2] * r);
        g_positions[i*3+0] = p[0]*ct + p[1]*st;
        g_positions[i*3+1] = -p[0]*st + p[1]*ct;
        g_positions[i*3+2] = p[2];
        p+=3;
    }

    Stopwatch s;
    s.Start();

    // update control points
    g_stencilOutput->UpdateData(&g_positions[0], 0, nverts);

    // Update random points by applying point & tangent stencils
    g_stencilOutput->EvalStencils();


    s.Stop();
    g_evalTime = float(s.GetElapsed() * 1000.0f);
}
コード例 #6
0
ファイル: main.cpp プロジェクト: hunduan2018/GPU-Gems
/**
 * @fn Keyboard(unsigned char key, int x, int y)
 * @brief GLUT keyboard callback.
 */ 
void Keyboard(unsigned char key, int x, int y)
{
  switch(key) 
  {
  case 'q':
  case 'Q':
  case 27:
    Shutdown();
    exit(0);
  	break;
  case '.':
    g_bSingleStep = true;
    break;
  case 'p':
    g_bPause = !g_bPause;
    break;
  case 'a':
    g_bArbitraryBC = !g_bArbitraryBC;
    g_pFlo->EnableArbitraryBC(g_bArbitraryBC);
    break;
  case 'c':
    g_bClearPressure = !g_bClearPressure;
    g_pFlo->EnablePressureClear(g_bClearPressure);
    break;
  case 'r':
    g_pFlo->Reset();
    break;
  case 'R':
    g_pFlo->Reset(true);
    break;
  case 'v':
    g_bComputeVorticity = !g_bComputeVorticity;
    g_pFlo->EnableVCForce(g_bComputeVorticity);
    break;
  case '~':
  case '`':
    g_bDisplaySliders = !g_bDisplaySliders;
    break;
  case 't':
    g_displayMode = static_cast<Flo::DisplayMode>(((g_displayMode + 1) 
												  % Flo::DISPLAY_COUNT));
    break;
  case 'T':
	g_bDisplayFluid = !g_bDisplayFluid;
	break;
  case 'b':
    g_bBilerp = !g_bBilerp;
    break;
  case 'm':
    g_bMakeTex = !g_bMakeTex;
    break;
  case 'L':
      g_perfTimer.Stop();
      g_perfTimer.Reset();
      g_bTiming = true;
      break;
  default:
    break;
  }
}
コード例 #7
0
ファイル: Application.cpp プロジェクト: horatii/MPF
void Application::Run()
{
	Stopwatch watch;

	// 理想状况 60 帧每秒
	const DWORD desiredDelta = 1000 / 30;
	// 上一次每帧用时
	DWORD lastDelta = desiredDelta;
	while (true)
	{
		try
		{
			watch.Restart();
			if (DoFrame()) break;
			// 本帧用时
			lastDelta = static_cast<DWORD>(watch.Stop() * 1000);
			// Sleep 剩余时间
			if (lastDelta < desiredDelta)
				Sleep(desiredDelta - lastDelta);
		}
		catch (...)
		{
			bool handled = false;
			OnUncaughtException(handled);
			// 异常未处理
			if (!handled)
				throw;
		}
	}
}
コード例 #8
0
ファイル: ABBoxBenchmark.cpp プロジェクト: amadio/vecgeom
int benchNoCachingNoVector(Vector3D<Precision> const &point, Vector3D<Precision> const &dir,
                           std::vector<Vector3D<Precision>> const &corners
#ifdef SORTHITBOXES
                           ,
                           Container_t &hitlist
#endif
                           )
{
#ifdef INNERTIMER
  Stopwatch timer;
  timer.Start();
#endif
  int vecsize  = corners.size() / 2;
  int hitcount = 0;
  for (auto box = 0; box < vecsize; ++box) {
    double distance = BoxImplementation<translation::kIdentity, rotation::kIdentity>::Intersect(
        &corners[2 * box], point, dir, 0, vecgeom::kInfLength);
    if (distance < vecgeom::kInfLength) {
      hitcount++;
#ifdef SORTHITBOXES
      hitlist.push_back(BoxIdDistancePair_t(box, distance));
#endif
    }
  }
#ifdef INNERTIMER
  timer.Stop();
  std::cerr << "# ORDINARY hitting " << hitcount << "\n";
  std::cerr << "# ORDINARY timer " << timer.Elapsed() << "\n";
#endif
  return hitcount;
}
コード例 #9
0
__attribute__((noinline)) void benchNavigatorNoReloc(VNavigator const *se, SOA3D<Precision> const &points,
                                                     SOA3D<Precision> const &dirs, NavStatePool const &inpool,
                                                     NavStatePool &outpool)
{
  Precision *steps = new Precision[points.size()];
  Precision *safeties;
  if (WithSafety) safeties = new Precision[points.size()];
  Stopwatch timer;
  size_t hittargetchecksum = 0L;
  timer.Start();
  for (decltype(points.size()) i = 0; i < points.size(); ++i) {
    if (WithSafety) {
      steps[i] = se->ComputeStepAndSafety(points[i], dirs[i], vecgeom::kInfLength, *inpool[i], true, safeties[i]);
    } else {
      steps[i] = se->ComputeStep(points[i], dirs[i], vecgeom::kInfLength, *inpool[i], *outpool[i]);
    }
  }
  timer.Stop();
  std::cerr << timer.Elapsed() << "\n";
  double accum(0.), saccum(0.);
  for (decltype(points.size()) i = 0; i < points.size(); ++i) {
    accum += steps[i];
    if (WithSafety) {
      saccum += safeties[i];
    }
    if (outpool[i]->Top()) hittargetchecksum += (size_t)outpool[i]->Top()->id();
  }
  delete[] steps;
  std::cerr << "accum  " << se->GetName() << " " << accum << " target checksum " << hittargetchecksum << "\n";
  if (WithSafety) {
    std::cerr << "saccum  " << se->GetName() << " " << saccum << "\n";
  }
}
コード例 #10
0
void Test1()
{
    DIVIDING_LINE_1('-');

    constexpr int Count = 2001001;

#if HAS_BOOST
    boost::recursive_mutex osMutex;
    ostream_t os(std::cout, osMutex);
#else
    ostream_t &os = std::cout;
#endif

    Stopwatch sw;
    sw.Start();

    ProducerConsumerContext context(os, Count, Count / 10, ENABLE_LOGGING);

    Producer p1(context, 0, Count / 2, 200);
    Producer p2(context, Count / 2, Count - Count / 2, 200);

    Consumer c1(context, Count / 3, 200);
    Consumer c2(context, Count / 3, 200);
    Consumer c3(context, Count - Count / 3 - Count / 3, 200);

    std::vector<std::thread> threads;
    threads.push_back(p1.Create());
    threads.push_back(p2.Create());
    threads.push_back(c1.Create());
    threads.push_back(c2.Create());
    threads.push_back(c3.Create());

    for (auto &t : threads)
        t.join();

    sw.Stop();
    std::cout << "Ellapsed time: " << sw.GetElapsedMilliseconds() << "ms" << std::endl;

    std::cout << "Checking if test is passed...\n";

    sw.Restart();
    bool ok = context.IsTestPassed();
    sw.Stop();

    std::cout << "It takes " << sw.GetElapsedMilliseconds() << "ms to figure out if test is passed." << std::endl;
    std::cout << "Is test passed? " << std::boolalpha << ok << std::endl;
}
コード例 #11
0
//-------------------------------------------------------------------------------------------------
void Benchmark::DoAll(std::vector<string> vExpr, long num)
{
   printf("\n\n\n");

   PreprocessExpr(vExpr);

   char outstr[400], file[400];
   time_t t = time(NULL);

   #ifdef _DEBUG
   sprintf(outstr, "Bench_%s_%%Y%%m%%d_%%H%%M%%S_dbg.txt", GetShortName().c_str());
   #else
   sprintf(outstr, "Bench_%s_%%Y%%m%%d_%%H%%M%%S_rel.txt", GetShortName().c_str());
   #endif

   strftime(file, sizeof(file), outstr, localtime(&t));

   FILE *pRes = fopen(file, "w");
   assert(pRes);

   fprintf(pRes,  "# Benchmark results\n");
   fprintf(pRes,  "#   Parser:  %s\n", GetName().c_str());
   fprintf(pRes,  "#   Evals per expr:  %ld\n", num);
   fprintf(pRes,  "#\"ms per eval [ms]\", \"evals per sec\", \"Result\", \"expr_len\", \"Expression\"\n");

   std::string sExpr;

   Stopwatch timer;
   timer.Start();
   for (std::size_t i = 0; i < vExpr.size(); ++i)
   {
      try
      {
         DoBenchmark(vExpr[i], num);
         fprintf(pRes, "%4.6lf, %4.6lf, %4.6lf, %d, %s, %s\n", m_fTime1, 1000.0/m_fTime1, m_fResult, (int)vExpr[i].length(), vExpr[i].c_str(), m_sInfo.c_str());
         printf(       "%4.6lf, %4.6lf, %4.6lf, %d, %s, %s\n", m_fTime1, 1000.0/m_fTime1, m_fResult, (int)vExpr[i].length(), vExpr[i].c_str(), m_sInfo.c_str());
      }
      catch(...)
      {
         fprintf(pRes, "fail: %s\n", vExpr[i].c_str());
         printf(       "fail: %s\n", vExpr[i].c_str());
      }

      fflush(pRes);
   }
   double dt = timer.Stop() / ((double)vExpr.size() * num);

   fprintf(pRes,  "# avg. time per expr.: %lf ms;  avg. eval per sec: %lf; total bytecode size: %d",
           dt,
           1000.0 / dt,
           m_nTotalBytecodeSize);

   printf("\n#\n# avg. time per expr.: %lf ms;  avg. eval per sec: %lf; total bytecode size: %d",
          dt,
          1000.0 / dt,
          m_nTotalBytecodeSize);

   fclose(pRes);
}
コード例 #12
0
ファイル: playback_cupspoon.cpp プロジェクト: panjia1983/APDL
	void playback_exact_CSpace_R3()
	{
		C2A_Model* P = NULL;
		C2A_Model* Q = NULL;
		readObjFile(P, "../data/models/CupSpoon/Cup.obj");
		readObjFile(Q, "../data/models/CupSpoon/Spoon.obj");

		P->ComputeRadius();
		Q->ComputeRadius();

		Collider3D collider(P, Q);

		C2A_Model* CSpace;
		readObjFile(CSpace, "../data/cupspoon.obj");

		std::vector<ContactSpaceSampleData> contactspace_samples;
		std::ifstream in("space_test_3d.txt");
		asciiReader(in, contactspace_samples);

		std::ofstream timing_file("timing_exact_R3.txt");
		std::ofstream PD_file("PD_exact_R3.txt");

		for(std::size_t i = 0; i < contactspace_samples.size(); ++i)
		{
			std::cout << i << std::endl;
			DataVector q_col(6);
			DataVector q(3);
			for(std::size_t j = 0; j < 3; ++j)
				q[j] = contactspace_samples[i].v[j];

			for(std::size_t j = 0; j < 6; ++j)
				q_col[j] = contactspace_samples[i].v[j];


			boost::timer t;
			//aTimer.Reset();
			aTimer.Start();
			std::pair<DataVector, double> pd_result;
			if(!collider.isCollide(q_col)) 
			{
				pd_result.second = 0;
			}
			else
			{
				pd_result = Minkowski_Cspace_3D::Exact_PD_R3(q, CSpace);
			}
			aTimer.Stop();
			PD_file << pd_result.second << " ";	
			//timing_file << t.elapsed() << " ";
			timing_file << aTimer.GetTime() * 1000 << " ";

			
			timing_file.flush();
			PD_file.flush();
		}
	}
コード例 #13
0
void MyPerformanceReporter::ReportTestFinish(UnitTest::TestDetails const& test, float secondsElapsed)
{
    Counter.Stop();

    if (lastsuitename != test.suiteName) {
        outputFile << endl << endl << test.suiteName <<endl;
        lastsuitename = test.suiteName;
    }
    outputFile << test.testName << ";" << (secondsElapsed*1000) << "ms" << endl;

}
コード例 #14
0
ファイル: mesh.cpp プロジェクト: mbdriscoll/OpenSubdiv
double
OsdMesh::Synchronize() {

    Stopwatch s;
    s.Start();
    {
        _dispatcher->Synchronize();
    }
    s.Stop();

    return s.GetElapsed();
}
コード例 #15
0
int main()
{
    // Stopwatch object used to measure time intervals
    Stopwatch sw;   

    // Record start time
    sw.Start();
    
    // Portion of code to be timed
    ::Sleep(1000);  // Just wait for 1,000 ms (1 second)
    
    // Record end time
    sw.Stop();

    // Print timing results
    cout << "Elapsed time: " << sw.ElapsedMilliseconds() << " ms\n";
}
コード例 #16
0
void StorageDeleteFileChunkJob::Execute()
{
    Stopwatch   sw;
    Buffer      filename;
    
    Log_Message("Deleting file chunk %U from disk", chunk->GetChunkID());
    sw.Start();
    
    filename.Write(chunk->GetFilename());
    delete chunk;
    chunk = NULL;

    StorageFileDeleter::Delete(filename.GetBuffer());

    sw.Stop();
    Log_Debug("Deleted, elapsed: %U", (uint64_t) sw.Elapsed());
}
コード例 #17
0
void Test0()
{
    DIVIDING_LINE_1('-');

#if !PRODUCER_DO_MY_BEST && !CONSUMER_DO_MY_BEST
# error You are in danger of deadlock!
#endif

    constexpr int Count = 2000;

#if HAS_BOOST
    boost::recursive_mutex osMutex;
    ostream_t os(std::cout, osMutex);
#else
    ostream_t &os = std::cout;
#endif

    Stopwatch sw;
    sw.Start();

    ProducerConsumerContext context(os, Count, Count / 10, ENABLE_LOGGING);

    Producer p1(context, 0, Count / 2, 200);
    Producer p2(context, Count / 2, Count - Count / 2, 200);

    Consumer c1(context, Count / 3, 200);
    Consumer c2(context, Count / 3, 200);
    Consumer c3(context, Count - Count / 3 - Count / 3, 200);

    std::vector<std::thread> threads;
    threads.push_back(p1.Create());
    threads.push_back(p2.Create());
    threads.push_back(c1.Create());
    threads.push_back(c2.Create());
    threads.push_back(c3.Create());

    for (auto &t : threads)
        t.join();

    sw.Stop();

    std::cout << "Test Done: " << context.IsTestPassed() << ". Ellapsed time: " << sw.GetElapsedMilliseconds() << "ms\n";
}
コード例 #18
0
ファイル: mesh.cpp プロジェクト: mbdriscoll/OpenSubdiv
double
OsdMesh::Subdivide(OsdVertexBuffer *vertex, OsdVertexBuffer *varying) {

    _dispatcher->BindVertexBuffer(vertex, varying);

    Stopwatch s;
    s.Start();
    {
        _dispatcher->OnKernelLaunch();

        _farMesh->Subdivide(_level+1, _exact);

        _dispatcher->OnKernelFinish();
    }
    s.Stop();

    _dispatcher->UnbindVertexBuffer();

    return s.GetElapsed();
}
コード例 #19
0
static void do_parallel_enum(Stopwatch& sw) {
  AutoCurrentContext ctxt;
  auto all = create();

  // Create threads which will cause contention:
  auto proceed = std::make_shared<bool>(true);
  for (size_t nParallel = N; nParallel--;) {
    std::thread([proceed, all, ctxt] {
      while (*proceed)
        for (auto cur : ContextEnumerator(ctxt))
          ;
    }).detach();
  }
  auto cleanup = MakeAtExit([&] { *proceed = false; });

  std::this_thread::sleep_for(std::chrono::milliseconds(100));

  // Perform parallel enumeration
  sw.Start();
  for (auto cur : ContextEnumerator(ctxt))
    ;
  sw.Stop(n);
}
コード例 #20
0
ファイル: Benchmark.cpp プロジェクト: phi-psi/bashmark
Benchmark::Test_Re_Type Benchmark::Calculation_Test()
{
    Stopwatch watch;
    double Comp_Time(0);
    
    if( !::Force_No_Threads )
    {
	bool Blocker( true );
        
	Smart_Array_Pointer< ThreadHandle > Threads_Mem( Thread_Number );
	if( !Threads_Mem )
	{
	    m_Error = Mem_Alloc;
	    return 0;
	}
	ThreadHandle* Threads = Threads_Mem.Get_Mem();

	    uint8_t i( 0 );
	
	    //Preallocates us the memory needed..
	    Smart_Array_Pointer< Thread_Helper< Type, Loops > > Thread_Helpers_Mem( Thread_Number );
	    if( !Thread_Helpers_Mem )
	    {
		m_Error = Mem_Alloc;
		return 0;
	    } 
	    Thread_Helper< Type, Loops >* Thread_Helpers = Thread_Helpers_Mem.Get_Mem();
	    for( ; i < Thread_Number; ++i )
		 Thread_Helpers[i].m_Blocker = &Blocker; //That isn't that nice...but needed
	        
	
	    for( i=0; i < Thread_Number; ++i )
		ThreadCreate( Threads[i], Calculation_Test_Thread< Type, Loops >, &Thread_Helpers[i] );

	    //Now it's starts!
	    //Maybe we should wait a moment, so every
	    //watch.Start();
	    const double Start_Time = Stopwatch::Get_Time();
	    Blocker = false;
	    ThreadWaitFor( Threads, Thread_Number );
	    
	    for( i=0; i < Thread_Number; ++i )
		if( Comp_Time < Thread_Helpers[i].m_Needed_Time - Start_Time )
		    Comp_Time = Thread_Helpers[i].m_Needed_Time - Start_Time;
		
	
	    double Score = static_cast< double > (  ((Loops-1)*(Loops-1)*Thread_Number) / Comp_Time);
	    return Score / 1000; //A little score modi :)
	}
	else
	{ 
	    Smart_Array_Pointer< Type > Buffer_Mem( Loops );
	    if( !Buffer_Mem )
	    {
		m_Error = Mem_Alloc;
		return 0;
	    }
	    Type* Buffer = Buffer_Mem.Get_Mem(); //Does we need some extra to prevent for buffer over/under flows?
	
	    watch.Start();
	    Intern_Calculation_Test< Type, Loops-1 > ( Buffer );
	    watch.Stop( &Comp_Time );
	
	
	    double Score = static_cast< double > (  ((Loops-1)*(Loops-1)) / Comp_Time);
	    return Score / 1000; //Little score modi!
	}
}
コード例 #21
0
ファイル: Benchmark.cpp プロジェクト: phi-psi/bashmark
Benchmark::Test_Re_Type Benchmark::Memory_RW_Test()
{
    Stopwatch watch;
    double Comp_Time( 0 );
    static const uint32_t Half_Buf_Size( Buf_Size>>1 );
	
    if( !::Force_No_Threads )
    {
	bool Blocker( true );
        
	Smart_Array_Pointer< ThreadHandle > Thread_Mem( Thread_Number );
	if( !Thread_Mem )
	{
	    m_Error = Mem_Alloc;
	    return 0;
	}
	
        ThreadHandle* Threads = Thread_Mem;

	uint8_t i( 0 );
	
	
	Smart_Array_Pointer< Thread_Helper< uint8_t, Buf_Size > > Thread_Helper_Mem( Thread_Number );
	if( !Thread_Helper_Mem  || !Thread_Helper_Mem.Get_Mem()->m_Mem.Is_Allocated()  ) //uah...evil line :x
	{
	    m_Error = Mem_Alloc;
	    return 0;
	}
	Thread_Helper< uint8_t, Buf_Size >* Thread_Helpers = Thread_Helper_Mem.Get_Mem();
	for( ; i < Thread_Number; ++i )
	    Thread_Helpers[i].m_Blocker = &Blocker; //That isn't that nice...but needed
	        
	
	for( i=0; i < Thread_Number; ++i )
	    ThreadCreate( Threads[i], Memory_RW_Test_Thread< Half_Buf_Size, Loops >, &Thread_Helpers[i] );


	//Now it's starts!
	//Maybe we should wait a moment, so every
	//watch.Start();
	const double Start_Time = Stopwatch::Get_Time();
	Blocker = false;
	ThreadWaitFor( Threads, Thread_Number );
	
	//watch.Stop( &Comp_Time );
	for( i=0; i < Thread_Number; ++i )
	    if( Comp_Time < Thread_Helpers[i].m_Needed_Time - Start_Time )
	        Comp_Time = Thread_Helpers[i].m_Needed_Time - Start_Time;
	
	
	return ((Loops*Thread_Number) / Comp_Time)/1000;
    }
    else
    {	
	Smart_Array_Pointer< uint8_t > a( Half_Buf_Size );
	Smart_Array_Pointer< uint8_t > b( Half_Buf_Size );
	if( !a  ||  !b )
	{
	    m_Error = Mem_Alloc;
	    return 0;
	}
	
	watch.Start();
	Intern_Memory_RW_Test< Half_Buf_Size, Loops > ( a.Get_Mem(), b.Get_Mem() );
	watch.Stop( &Comp_Time );
		
	
	return (Loops / Comp_Time)/1000;
    }
}
コード例 #22
0
ファイル: Benchmark.cpp プロジェクト: phi-psi/bashmark
Benchmark::Test_Re_Type Benchmark::MultiT_MLuL_Test()
{
    Stopwatch watch;
    double Comp_Time( 0 );

    if( !::Force_No_Threads )
    {
	bool Blocker( true );
	uint8_t i( 0 );

	Smart_Array_Pointer< ThreadHandle > Thread_Mem( Thread_Number );
	ThreadHandle*const Threads = Thread_Mem.Get_Mem();
    #if IsLin
	Smart_Array_Pointer< Little_Mutex_Helper > Mutex_Mem( Thread_Number );
	if( !Thread_Mem.Is_Allocated()   ||   !Mutex_Mem.Is_Allocated()  )
	{
	    m_Error = Mem_Alloc;
	    return 0;
	}
	Little_Mutex_Helper*const Mutex = Mutex_Mem.Get_Mem();
	
    #elif IsWin
    	Smart_Array_Pointer< CRITICAL_SECTION > CS_Mem( Thread_Number );
        CRITICAL_SECTION*const CS = CS_Mem.Get_Mem();
	for( ; i < Thread_Number; ++i )
	    InitializeCriticalSection( &CS[i] );
    #endif
	
	//Preallocates us the memory needed...
	Smart_Array_Pointer< Special_Thread_Helper > Thread_Helpers_Mem( Thread_Number );
	if( !Thread_Helpers_Mem )
	{
	    m_Error = Mem_Alloc;
	    return 0;
	}
	Special_Thread_Helper* Thread_Helpers = Thread_Helpers_Mem.Get_Mem();
	
	for( i =0; i < Thread_Number; ++i )
	{
	    Thread_Helpers[i].m_Blocker = &Blocker; //That isn't that nice...but needed
	    Thread_Helpers[i].m_Mutex =
	    #if IsLin
	        &Mutex[i].m_Mutex
	    #elif IsWin
		&CS[i]
	    #endif
		;
	}
	        
	
	for( i=0; i < Thread_Number; ++i )
	    ThreadCreate( Threads[i], MultiT_MLuL_Test_Thread< Loops >, &Thread_Helpers[i] );


	//Now it's starts!
	//Maybe we should wait a moment, so every
	double Start_Time = Stopwatch::Get_Time();
	Blocker = false;
	ThreadWaitFor( Threads, Thread_Number );

	for( i=0; i < Thread_Number; ++i )
	    if( Comp_Time < Thread_Helpers[i].m_Needed_Time - Start_Time )
	        Comp_Time = Thread_Helpers[i].m_Needed_Time - Start_Time;
	
	
	return ((Loops*Thread_Number) / Comp_Time)/1000;
    }
    else
    { 
    #if IsLin
	Little_Mutex_Helper Mutex;
	
	watch.Start();
	Intern_MultiT_MLuL_Test< Loops > ( &Mutex.m_Mutex );
    #elif IsWin
	CRITICAL_SECTION CS; //Is critical section relly the right choice?
	InitializeCriticalSection( &CS );
    
	watch.Start();
	Intern_MultiT_MLuL_Test< Loops > ( &CS );
    #endif
    
	watch.Stop( &Comp_Time );	
	
	return (Loops / Comp_Time)/1000;
    }
}
コード例 #23
0
ファイル: Benchmark.cpp プロジェクト: phi-psi/bashmark
Benchmark::Test_Re_Type Benchmark::Memory_DA_Test()
{
    Stopwatch watch;
    double Comp_Time(0);
  
    if( !::Force_No_Threads )
    {
	bool Blocker( true );
        
	Smart_Array_Pointer< ThreadHandle > Thread_Mem( Thread_Number );
	if( !Thread_Mem )
	{
	    m_Error = Mem_Alloc;
	    return 0;
	}
        ThreadHandle* Threads = Thread_Mem.Get_Mem();

	uint8_t i( 0 );
	
	Smart_Array_Pointer< Little_Thread_Helper > Thread_Helper_Mem( Thread_Number );
	if( !Thread_Helper_Mem )
	{
	    m_Error = Mem_Alloc;
	    return 0;
	}
	Little_Thread_Helper* Thread_Helpers = Thread_Helper_Mem.Get_Mem();
	for( ; i < Thread_Number; ++i )
	    Thread_Helpers[i].m_Blocker = &Blocker; //That isn't that nice...but needed
	        
	
	for( i=0; i < Thread_Number; ++i )
	     ThreadCreate( Threads[i], Memory_DA_Test_Thread<Buf_Size,Loops>, &Thread_Helpers[i]  );


	//Now it's starts!
	const double Start_Time = Stopwatch::Get_Time();
	Blocker = false;
	ThreadWaitFor( Threads, Thread_Number );
	
	if( m_Error )
	    return 0;
	for( i=0; i < Thread_Number; ++i )
	    if( Comp_Time < Thread_Helpers[i].m_Needed_Time - Start_Time )
	        Comp_Time = Thread_Helpers[i].m_Needed_Time - Start_Time;
	
	
	return ((Loops*Thread_Number) / Comp_Time)/1000;
    }
    else
    {
	watch.Start();
	
	if( !Intern_Mem_DA_Test< Buf_Size, Loops > () )
	{
	    m_Error = Benchmark::Mem_Alloc; 
	    return 0;
	}

	watch.Stop( &Comp_Time );
	return (Loops / Comp_Time)/1000;
    }
}
コード例 #24
0
ファイル: viewer.cpp プロジェクト: Len3d/OpenSubdiv
//------------------------------------------------------------------------------
static void
display() {

    // set effect
    g_effect.displayStyle = g_displayStyle;
    g_effect.screenSpaceTess = (g_screenSpaceTess != 0);
    g_effect.displayPatchColor = (g_displayPatchColor != 0);

    // prepare view matrix
    float aspect = g_width/(float)g_height;
    float modelview[16], projection[16];
    identity(modelview);
    translate(modelview, -g_pan[0], -g_pan[1], -g_dolly);
    rotate(modelview, g_rotate[1], 1, 0, 0);
    rotate(modelview, g_rotate[0], 0, 1, 0);
    rotate(modelview, -90, 1, 0, 0);
    translate(modelview, -g_center[0], -g_center[1], -g_center[2]);
    perspective(projection, 45.0f, aspect, 0.01f, 500.0f);

    g_effect.SetMatrix(modelview, projection);
    g_effect.SetTessLevel((float)(1 << g_tessLevel));
    g_effect.SetLighting();

    // -----------------------------------------------------------------------
    // prepare draw items

    Stopwatch s;
    s.Start();

    OpenSubdiv::OsdUtilDrawItem<MyDrawDelegate::EffectHandle, MyDrawContext>::Collection items;
    OpenSubdiv::OsdUtilDrawItem<MyDrawDelegate::EffectHandle, MyDrawContext>::Collection cachedDrawItems;

    int numModels = g_modelCount*g_modelCount;
    items.reserve(numModels);

    for (int i = 0; i < numModels; ++i) {
        // Here, client can pack arbitrary mesh and effect into drawItems.

        items.push_back(OpenSubdiv::OsdUtilDrawItem<MyDrawDelegate::EffectHandle, MyDrawContext>(
                            g_batch, &g_effect, g_batch->GetPatchArrays(i)));
    }

    if (g_batching) {
        // create cached draw items
        OpenSubdiv::OsdUtil::OptimizeDrawItem(items, cachedDrawItems, &g_drawDelegate);
    }

    s.Stop();
    float prepCpuTime = float(s.GetElapsed() * 1000.0f);

    // -----------------------------------------------------------------------
    // draw items
    s.Start();

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glViewport(0, 0, g_width, g_height);

    // primitive counting
    glBeginQuery(GL_PRIMITIVES_GENERATED, g_queries[0]);
#if defined(GL_VERSION_3_3)
    glBeginQuery(GL_TIME_ELAPSED, g_queries[1]);
#endif
    g_drawDelegate.ResetNumDrawCalls();

    if (g_displayStyle == kWire) glDisable(GL_CULL_FACE);

    if (g_batching) {
        OpenSubdiv::OsdUtil::DrawCollection(cachedDrawItems, &g_drawDelegate);
    } else {
        OpenSubdiv::OsdUtil::DrawCollection(items, &g_drawDelegate);
    }

    if (g_displayStyle == kWire) glEnable(GL_CULL_FACE);

    glEndQuery(GL_PRIMITIVES_GENERATED);
#if defined(GL_VERSION_3_3)
    glEndQuery(GL_TIME_ELAPSED);
#endif

    s.Stop();
    float drawCpuTime = float(s.GetElapsed() * 1000.0f);

    // -----------------------------------------------------------------------

    GLuint numPrimsGenerated = 0;
    GLuint timeElapsed = 0;
    glGetQueryObjectuiv(g_queries[0], GL_QUERY_RESULT, &numPrimsGenerated);
#if defined(GL_VERSION_3_3)
    glGetQueryObjectuiv(g_queries[1], GL_QUERY_RESULT, &timeElapsed);
#endif
    float drawGpuTime = timeElapsed / 1000.0f / 1000.0f;

    if (g_hud.IsVisible()) {
        g_fpsTimer.Stop();
        g_totalTime += g_fpsTimer.GetElapsed();
        double fps = 1.0/g_fpsTimer.GetElapsed();
        g_fpsTimer.Start();
        g_hud.DrawString(10, -200, "Draw Calls : %d", g_drawDelegate.GetNumDrawCalls());
        g_hud.DrawString(10, -180, "Tess level : %d", g_tessLevel);
        g_hud.DrawString(10, -160, "Primitives : %d", numPrimsGenerated);
        g_hud.DrawString(10, -120, "GPU Kernel : %.3f ms", g_gpuTime);
        g_hud.DrawString(10, -100, "CPU Kernel : %.3f ms", g_cpuTime);
        g_hud.DrawString(10, -80,  "GPU Draw   : %.3f ms", drawGpuTime);
        g_hud.DrawString(10, -60,  "CPU Draw   : %.3f ms", drawCpuTime);
        g_hud.DrawString(10, -40,  "CPU Prep   : %.3f ms", prepCpuTime);
        g_hud.DrawString(10, -20,  "FPS        : %3.1f", fps);

        g_hud.Flush();
    }

    checkGLErrors("display leave");
    glFinish();
}
コード例 #25
0
ファイル: viewer.cpp プロジェクト: Len3d/OpenSubdiv
static void
updateGeom(bool forceAll) {

    float r = (float)sin(g_totalTime);

    for (int j = 0; j < g_modelCount * g_modelCount; ++j) {
        if (forceAll == false && j >= g_moveModels) break;
        int nverts = (int)g_positions[j].size()/3;

        std::vector<float> vertex, varying;
        vertex.reserve(nverts * 3);

        if (g_displayStyle == kVaryingColor)
            varying.reserve(nverts * 3);

        const float *p = &g_positions[j][0];
        for (int i = 0; i < nverts; ++i) {
            float ct = cos(p[2] * r);
            float st = sin(p[2] * r);
            float v[4];
            v[0] = p[0]*ct + p[1]*st;
            v[1] = -p[0]*st + p[1]*ct;
            v[2] = p[2];
            v[3] = 1;
            apply(v, g_transforms[j].value);
            vertex.push_back(v[0]);
            vertex.push_back(v[1]);
            vertex.push_back(v[2]);

            if (g_displayStyle == kVaryingColor) {
                varying.push_back(p[2]);
                varying.push_back(p[1]);
                varying.push_back(p[0]);
            }

            p += 3;
        }
        
        g_batch->UpdateCoarseVertices(j, &vertex[0], nverts);

        if (g_displayStyle == kVaryingColor) {
            g_batch->UpdateCoarseVaryings(j, &varying[0], nverts);
        }
    }

    Stopwatch s;
    s.Start();

    g_batch->FinalizeUpdate();

    s.Stop();
    g_cpuTime = float(s.GetElapsed() * 1000.0f);
    s.Start();

    if (g_kernel == kCPU) Controller<OpenSubdiv::OsdCpuComputeController>::GetInstance()->Synchronize();
#ifdef OPENSUBDIV_HAS_OPENMP
    else if (g_kernel == kOPENMP) Controller<OpenSubdiv::OsdOmpComputeController>::GetInstance()->Synchronize();
#endif
#ifdef OPENSUBDIV_HAS_OPENCL
    else if (g_kernel == kCL) Controller<OpenSubdiv::OsdCLComputeController>::GetInstance()->Synchronize();
#endif
#ifdef OPENSUBDIV_HAS_CUDA
    else if (g_kernel == kCUDA) Controller<OpenSubdiv::OsdCudaComputeController>::GetInstance()->Synchronize();
#endif
#ifdef OPENSUBDIV_HAS_GLSL_TRANSFORM_FEEDBACK
    else if (g_kernel == kGLSL) Controller<OpenSubdiv::OsdGLSLTransformFeedbackComputeController>::GetInstance()->Synchronize();
#endif

    s.Stop();
    g_gpuTime = float(s.GetElapsed() * 1000.0f);
}
コード例 #26
0
ファイル: main.cpp プロジェクト: DanLinder/crisscross
void TestTree(T _tree, DArray<ktype_t> *dataset, unsigned long _size)
{
	console->Write("%10lu ", _size);
	
	// fill tree
	Stopwatch sw;
	sw.Start();
	for (size_t i = 0; i < _size; i++) {
		ktype_t item = dataset->get(i);
		_tree->insert(item, item);
	}
	sw.Stop();
	console->Write("%9.5lfs ", sw.Elapsed());
	
	DArray<ktype_t> searchItems;
	
	// create valid item list
	searchItems.empty();
	while (searchItems.used() < MaxSearches) {
		unsigned long idx = RandomNumber() % _size;
		searchItems.insert(dataset->get(idx));
	}
	
	// successful searches
	sw.Start();
	for (size_t i = 0; i < MaxSearches; i++) {
		_tree->find(searchItems[i], 0);
	}
	sw.Stop();
	console->Write("%9.5lfs ", sw.Elapsed());
	
	// create mixed item list
	searchItems.empty();
	while (searchItems.used() < MaxSearches) {
		unsigned long idx;
		
		idx = RandomNumber() % _size;
		searchItems.insert(dataset->get(idx));
		
		idx = _size + (RandomNumber() % _size);
		searchItems.insert(dataset->get(idx));
	}
	
	// mixed success searches
	sw.Start();
	for (size_t i = 0; i < MaxSearches; i++) {
		_tree->find(searchItems[i], 0);
	}
	sw.Stop();
	console->Write("%9.5lfs ", sw.Elapsed());
	
	// create invalid item list
	searchItems.empty();
	while (searchItems.used() < MaxSearches) {
		unsigned long idx = _size + (RandomNumber() % _size);
		searchItems.insert(dataset->get(idx));
	}
	
	// invalid searches
	sw.Start();
	for (size_t i = 0; i < MaxSearches; i++) {
		_tree->find(searchItems[i], 0);
	}
	sw.Stop();
	console->Write("%9.5lfs ", sw.Elapsed());

	// empty tree
	sw.Start();
	_tree->empty();
	sw.Stop();
	console->WriteLine("%9.5lfs", sw.Elapsed());
}
コード例 #27
0
__attribute__((noinline)) void benchmarkROOTNavigator(SOA3D<Precision> const &points, SOA3D<Precision> const &dirs)
{

  TGeoNavigator *rootnav      = ::gGeoManager->GetCurrentNavigator();
  auto nPoints                = points.size();
  TGeoBranchArray **instates  = new TGeoBranchArray *[nPoints];
  TGeoBranchArray **outstates = new TGeoBranchArray *[nPoints];
  Precision *steps            = new Precision[points.size()];
  Precision *safeties;
  if (WithSafety) {
    safeties = new Precision[points.size()];
  }
  // we don't have the input state container in ROOT form
  // we generate them but do not take this into account for the timing measurement
  for (size_t i = 0; i < nPoints; ++i) {
    Vector3D<Precision> const &pos = points[i];
    rootnav->ResetState();
    rootnav->FindNode(pos.x(), pos.y(), pos.z());
    instates[i]  = TGeoBranchArray::MakeInstance(GeoManager::Instance().getMaxDepth());
    outstates[i] = TGeoBranchArray::MakeInstance(GeoManager::Instance().getMaxDepth());
    instates[i]->InitFromNavigator(rootnav);
  }
#ifdef CALLGRIND_ENABLED
  CALLGRIND_START_INSTRUMENTATION;
#endif
  Stopwatch timer;
  timer.Start();
  for (size_t i = 0; i < nPoints; ++i) {
    Vector3D<Precision> const &pos = points[i];
    Vector3D<Precision> const &dir = dirs[i];
    rootnav->ResetState();
    instates[i]->UpdateNavigator(rootnav);

    rootnav->SetCurrentPoint(pos.x(), pos.y(), pos.z());
    rootnav->SetCurrentDirection(dir.x(), dir.y(), dir.z());
    if (WithSafety) {
      safeties[i] = rootnav->Safety(true);
    }
    if (WithReloc) {
      volatile TGeoNode *node = rootnav->FindNextBoundaryAndStep(kInfLength);
      (void)node;
    } else {
      volatile TGeoNode *node = rootnav->FindNextBoundary(kInfLength);
      (void)node;
    }
    steps[i] = rootnav->GetStep();
    if (WithReloc) {
      // save output states ( for fair comparison with VecGeom )
      outstates[i]->InitFromNavigator(rootnav);
    }
  }
  timer.Stop();
#ifdef CALLGRIND_ENABLED
  CALLGRIND_STOP_INSTRUMENTATION;
  CALLGRIND_DUMP_STATS;
#endif
  std::cerr << timer.Elapsed() << "\n";
  double accum(0.);
  double saccum(0.);
  size_t hittargetchecksum = 0L;
  for (decltype(points.size()) i = 0; i < points.size(); ++i) {
    accum += steps[i];
    if (WithSafety) {
      saccum += safeties[i];
    }
    // target checksum via the table held from RootGeoManager
    hittargetchecksum +=
        (size_t)RootGeoManager::Instance().Lookup(outstates[i]->GetNode(outstates[i]->GetLevel()))->id();
  }
  delete[] steps;
  if (WithSafety) {
    delete safeties;
  }

  // cleanup states
  for (decltype(points.size()) i = 0; i < points.size(); ++i) {
    delete instates[i];
    delete outstates[i];
  }
  delete[] instates;
  delete[] outstates;

  std::cerr << "accum  TGeo " << accum << " target checksum " << hittargetchecksum << "\n";
  if (WithSafety) {
    std::cerr << "safety accum  TGeo " << saccum << "\n";
  }
}
コード例 #28
0
ファイル: MessageConnection.cpp プロジェクト: crnt/scaliendb
void MessageConnection::OnRead()
{
    bool            yield, closed;
    unsigned        pos, msglength, nread, msgbegin, msgend, required;
    uint64_t        start;
    Stopwatch       sw;
    ReadBuffer      msg;

    if (!readActive)
    {
        if (resumeRead.IsActive())
            STOP_FAIL(1, "Program bug: resumeRead.IsActive() should be false.");
        EventLoop::Add(&resumeRead);
        return;
    }

    sw.Start();

    Log_Trace("Read buffer: %B", tcpread.buffer);

    tcpread.requested = IO_READ_ANY;
    pos = 0;
    start = NowClock();
    yield = false;

    while(true)
    {
        msglength = BufferToUInt64(tcpread.buffer->GetBuffer() + pos,
                                   tcpread.buffer->GetLength() - pos, &nread);

        if (msglength > tcpread.buffer->GetSize() - NumDigits(msglength) - 1)
        {
            Log_Trace();
            required = msglength + NumDigits(msglength) + 1;
            if (required > MESSAGING_MAX_SIZE)
            {
                Log_Trace();
                OnClose();
                return;
            }
            tcpread.buffer->Allocate(required);
            break;
        }

        if (nread == 0 || (unsigned) tcpread.buffer->GetLength() - pos <= nread)
            break;

        if (tcpread.buffer->GetCharAt(pos + nread) != ':')
        {
            Log_Trace("Message protocol error");
            OnClose();
            return;
        }

        msgbegin = pos + nread + 1;
        msgend = pos + nread + 1 + msglength;

        if ((unsigned) tcpread.buffer->GetLength() < msgend)
        {
            // read more
            //tcpread.requested = msgend - pos;
            break;
        }

        msg.SetBuffer(tcpread.buffer->GetBuffer() + msgbegin);
        msg.SetLength(msglength);
        closed = OnMessage(msg);
        if (closed)
            return;

        pos = msgend;

        // if the user called Close() in OnMessageRead()
        if (state != CONNECTED)
            return;

        if (tcpread.buffer->GetLength() == msgend)
            break;

        if (NowClock() - start >= YIELD_TIME || !readActive)
        {
            // let other code run every YIELD_TIME msec
            yield = true;
            if (resumeRead.IsActive())
                STOP_FAIL(1, "Program bug: resumeRead.IsActive() should be false.");
            EventLoop::Add(&resumeRead);
            break;
        }
    }

    if (pos > 0)
    {
        memmove(tcpread.buffer->GetBuffer(), tcpread.buffer->GetBuffer() + pos,
                tcpread.buffer->GetLength() - pos);
        tcpread.buffer->Shorten(pos);
    }

    if (state == CONNECTED
            && !tcpread.active && !yield)
        IOProcessor::Add(&tcpread);

    sw.Stop();
    Log_Trace("time spent in OnRead(): %U", sw.Elapsed());
}
コード例 #29
0
        Awaitable<void> ReplicatorPerfTest::Run(
            __in wstring const & testFolder,
            __in int concurrentTransactions,
            __in int totalTransactions,
            __in Data::Log::LogManager & logManager)
        {
#ifndef PERF_TEST
            UNREFERENCED_PARAMETER(testFolder);
            UNREFERENCED_PARAMETER(concurrentTransactions);
            UNREFERENCED_PARAMETER(totalTransactions);
            UNREFERENCED_PARAMETER(logManager);
#else
            Replica::SPtr replica = Replica::Create(
                pId_,
                rId_,
                testFolder,
                logManager,
                underlyingSystem_->PagedAllocator());

            co_await replica->OpenAsync();

            FABRIC_EPOCH epoch1; epoch1.DataLossNumber = 1; epoch1.ConfigurationNumber = 1; epoch1.Reserved = nullptr;
            co_await replica->ChangeRoleAsync(epoch1, FABRIC_REPLICA_ROLE_PRIMARY);

            replica->SetReadStatus(FABRIC_SERVICE_PARTITION_ACCESS_STATUS_GRANTED);
            replica->SetWriteStatus(FABRIC_SERVICE_PARTITION_ACCESS_STATUS_GRANTED);

            KUri::CSPtr stateProviderName = GetStateProviderName(0);
            {
                Transaction::SPtr txn;
                replica->TxnReplicator->CreateTransaction(txn);
                KFinally([&] {txn->Dispose(); });

                NTSTATUS status = co_await replica->TxnReplicator->AddAsync(*txn, *stateProviderName, L"ReplicatorPerfTest");
                VERIFY_IS_TRUE(NT_SUCCESS(status));
                co_await txn->CommitAsync();
            }

            {
                IStateProvider2::SPtr stateProvider2;
                NTSTATUS status = replica->TxnReplicator->Get(*stateProviderName, stateProvider2);
                VERIFY_IS_TRUE(NT_SUCCESS(status));
                VERIFY_IS_NOT_NULL(stateProvider2);
                VERIFY_ARE_EQUAL(*stateProviderName, stateProvider2->GetName());

                IStore<int, int>::SPtr store = dynamic_cast<IStore<int, int>*>(stateProvider2.RawPtr());

                Stopwatch s;
                s.Start();

                KArray<Awaitable<void>> tasks(underlyingSystem_->PagedAllocator(), concurrentTransactions, 0);

                for (int i = 0; i < concurrentTransactions; i++)
                {
                    status = tasks.Append(DoWorkOnKey(store, replica, totalTransactions / concurrentTransactions, i));
                    KInvariant(NT_SUCCESS(status));
                }

                co_await TaskUtilities<Awaitable<void>>::WhenAll(tasks);

                s.Stop();

                int64 txPerSec = ((totalTransactions * 1000) / s.ElapsedMilliseconds);

                Trace.WriteInfo(
                    TraceComponent,
                    "{0}: Tx/Sec is {1}",
                    prId_->TraceId,
                    txPerSec);
            }

            replica->SetReadStatus(FABRIC_SERVICE_PARTITION_ACCESS_STATUS_NOT_PRIMARY);
            replica->SetWriteStatus(FABRIC_SERVICE_PARTITION_ACCESS_STATUS_NOT_PRIMARY);

            co_await replica->CloseAsync();
#endif
            co_return;
        }
コード例 #30
0
__attribute__((noinline)) void benchmarkG4Navigator(SOA3D<Precision> const &points, SOA3D<Precision> const &dirs)
{
  G4VPhysicalVolume *world(vecgeom::G4GeoManager::Instance().GetG4GeometryFromROOT());
  if (world != nullptr) G4GeoManager::Instance().LoadG4Geometry(world);

  // Note: Vector3D's are expressed in cm, while G4ThreeVectors are expressed in mm
  const Precision cm = 10.; // cm --> mm conversion
  G4Navigator &g4nav = *(G4GeoManager::Instance().GetNavigator());
  // G4TouchableHistory **g4history = new G4TouchableHistory *[nPoints];

  Precision *steps = new Precision[points.size()];

  // get a time estimate to just to locate points
  // (The reason is that the G4Navigator has a huge internal state and it is not foreseen to do
  //  multi-track processing with a basked of G4TouchableHistories as states)
  Stopwatch timer;
  timer.Start();
  for (decltype(points.size()) i = 0; i < points.size(); ++i) {
    G4ThreeVector g4pos(points[i].x() * cm, points[i].y() * cm, points[i].z() * cm);
    G4ThreeVector g4dir(dirs[i].x(), dirs[i].y(), dirs[i].z());
    // false --> locate from top
    g4nav.LocateGlobalPointAndSetup(g4pos, &g4dir, false);
  }
  Precision timeForLocate = (Precision)timer.Stop();

#ifdef CALLGRIND_ENABLED
  CALLGRIND_START_INSTRUMENTATION;
#endif
  timer.Start();
  for (decltype(points.size()) i = 0; i < points.size(); ++i) {
    G4ThreeVector g4pos(points[i].x() * cm, points[i].y() * cm, points[i].z() * cm);
    G4ThreeVector g4dir(dirs[i].x(), dirs[i].y(), dirs[i].z());
    G4double maxStep = kInfLength;

    // false --> locate from top
    G4VPhysicalVolume const *vol = g4nav.LocateGlobalPointAndSetup(g4pos, &g4dir, false);
    (void)vol;
    G4double safety = 0.0;
    steps[i]        = g4nav.ComputeStep(g4pos, g4dir, maxStep, safety);

    G4ThreeVector nextPos = g4pos + (steps[i] + 1.0e-6) * g4dir;
    // TODO: save touchable history array - returnable?  symmetrize with ROOT/VECGEOM benchmark
    g4nav.SetGeometricallyLimitedStep();

    volatile G4VPhysicalVolume const *nextvol = g4nav.LocateGlobalPointAndSetup(nextPos);
    (void)nextvol;
  }
  timer.Stop();
  std::cerr << (Precision)timer.Elapsed() - timeForLocate << "\n";
#ifdef CALLGRIND_ENABLED
  CALLGRIND_STOP_INSTRUMENTATION;
  CALLGRIND_DUMP_STATS;
#endif
  // cleanup
  // delete[] g4history;
  //_mm_free(maxSteps);
  double accum{0.};
  size_t hittargetchecksum{0L};
  for (decltype(points.size()) i = 0; i < points.size(); ++i) {
    accum += steps[i];
    if (WithSafety) {
      // saccum += safeties[i];
    }
    // target checksum via the table held from RootGeoManager
    // hittargetchecksum +=
    //    (size_t)RootGeoManager::Instance().Lookup(outstates[i]->GetNode(outstates[i]->GetLevel()))->id();
  }
  std::cerr << "accum  G4 " << accum / cm << " target checksum " << hittargetchecksum << "\n";
}