int main() { Stopwatch stopwatch; HANDLE hTimer = NULL; // Create an unnamed waitable timer. hTimer = CreateWaitableTimer(NULL, TRUE, NULL); if (NULL == hTimer) { printf("CreateWaitableTimer failed (%d)\n", GetLastError()); return 1; } // With Sleep stopwatch.Start(); DoWait(hTimer, 1000); printf("Wait 1000ms, Elapsed time : %d\n", stopwatch.ElapsedTime()); // With Sleep stopwatch.Start(); DoWait(hTimer, 1234); Sleep(100); printf("Wait 1234ms with Sleep(100), Elapsed time : %d\n", stopwatch.ElapsedTime()); return 0; }
//------------------------------------------------------------------------------ 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"); }
//------------------------------------------------------------------------------ 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); }
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); } }
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); }
__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"; } }
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); }
int main ( ) { using namespace Furrovine; using namespace Furrovine::Audio; using namespace Furrovine::Pipeline; //using namespace Furrovine::Graphics; const static uint32 samplerate = 48000; const static uint32 bitspersample = 16; const static uint32 channelcount = 2; PCMAudioData data = WavAudioLoader( )( "16bit.wav" ); AudioDevice baseaudiodevice( bitspersample, channelcount, samplerate ); RealtimeAudioDevice audiodevice( baseaudiodevice, milliseconds( 10 ) ); audiodevice.AddDSP( PerChannelDelay( audiodevice.PCMDescription( ), { seconds( 0.513 ), seconds( 0.490 ) }, real( 0.25 ) ) ); AudioBuffer buffer( data.Buffer(), 0, 0, 0, 0, 1 ); audiodevice.SubmitBuffer( buffer ); Stopwatch stopwatch; stopwatch.Start( ); while ( true ) { double seconds = stopwatch.ElapsedSeconds( ); if ( seconds < 1 ) continue; //audiodevice.SubmitBuffer( buffer ); stopwatch.Restart( ); } }
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; }
//------------------------------------------------------------------------------------------------- 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); }
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(); } }
double OsdMesh::Synchronize() { Stopwatch s; s.Start(); { _dispatcher->Synchronize(); } s.Stop(); return s.GetElapsed(); }
void Benchmark::Integer8_Test() { double Score ( 0 ), Cur_Time( 0 ); uint32_t loops ( 0 ); Stopwatch watch; watch.Start(); for( ; Cur_Time < Time_Per_Test; ++loops, watch.Look( Cur_Time ), Status_Done( static_cast< uint32_t >( Status_Mul*Cur_Time )) ) Score += Intern_Integer8_Test(); m_Integer8_Score = static_cast< uint32_t >(Score/loops); }
void Benchmark::Integer16_Test() { double tmp(0); double Cur_Time(0); uint32_t loops=0; Stopwatch watch; watch.Start(); for( ; Cur_Time < Time_Per_Test; ++loops, watch.Look( Cur_Time ), Status_Done( static_cast< uint32_t >( Status_Mul*Cur_Time )) ) tmp += Intern_Integer16_Test(); m_Integer16_Score = static_cast< uint32_t >(tmp/loops); }
void Benchmark::Fp128_Test() { if( sizeof( long double ) != 16 ) return; double tmp(0); double Cur_Time(0); uint32_t loops=0; Stopwatch watch; watch.Start(); for( ; Cur_Time < Time_Per_Test; ++loops, watch.Look( Cur_Time ), Status_Done( static_cast< uint32_t >( Status_Mul*Cur_Time )) ) tmp += Intern_Fp128_Test(); m_Fp128_Score = static_cast< uint32_t >(tmp/loops); }
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; }
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"; }
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()); }
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"; }
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(); }
void playback_local_PD_R3() { std::ofstream timing_file("timing_local_PD_R3.txt"); std::ofstream PD_file("PD_local_R3.txt"); std::vector<C2A_Model*> P; std::vector<C2A_Model*> Q; readObjFiles(P, "../data/models/CupSpoon/cup_convex.obj"); readObjFiles(Q, "../data/models/CupSpoon/spoon_convex.obj"); std::vector<ContactSpaceSampleData> contactspace_samples; std::ifstream in("space_test_3d.txt"); asciiReader(in, contactspace_samples); 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(); double pd = Collider3D::PDt(P, Q, q_col); PD_file << pd << " "; // timing_file << t.elapsed() << " "; timing_file << aTimer.GetTime() * 1000 << " "; timing_file.flush(); PD_file.flush(); } }
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); }
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; } }
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! } }
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; } }
//------------------------------------------------------------------------------ int main(int argc, char ** argv) { bool fullscreen = false; std::string str; for (int i = 1; i < argc; ++i) { if (!strcmp(argv[i], "-d")) g_level = atoi(argv[++i]); else if (!strcmp(argv[i], "-c")) g_repeatCount = atoi(argv[++i]); else if (!strcmp(argv[i], "-f")) fullscreen = true; else { std::ifstream ifs(argv[1]); if (ifs) { std::stringstream ss; ss << ifs.rdbuf(); ifs.close(); str = ss.str(); g_defaultShapes.push_back(SimpleShape(str.c_str(), argv[1], kCatmark)); } } } initializeShapes(); OsdSetErrorCallback(callbackError); if (not glfwInit()) { printf("Failed to initialize GLFW\n"); return 1; } static const char windowTitle[] = "OpenSubdiv glBatchViewer"; #define CORE_PROFILE #ifdef CORE_PROFILE setGLCoreProfile(); #endif #if GLFW_VERSION_MAJOR>=3 if (fullscreen) { g_primary = glfwGetPrimaryMonitor(); // apparently glfwGetPrimaryMonitor fails under linux : if no primary, // settle for the first one in the list if (not g_primary) { int count=0; GLFWmonitor ** monitors = glfwGetMonitors(&count); if (count) g_primary = monitors[0]; } if (g_primary) { GLFWvidmode const * vidmode = glfwGetVideoMode(g_primary); g_width = vidmode->width; g_height = vidmode->height; } } if (not (g_window=glfwCreateWindow(g_width, g_height, windowTitle, fullscreen and g_primary ? g_primary : NULL, NULL))) { printf("Failed to open window.\n"); glfwTerminate(); return 1; } glfwMakeContextCurrent(g_window); glfwSetKeyCallback(g_window, keyboard); glfwSetCursorPosCallback(g_window, motion); glfwSetMouseButtonCallback(g_window, mouse); glfwSetWindowSizeCallback(g_window, reshape); #else if (glfwOpenWindow(g_width, g_height, 8, 8, 8, 8, 24, 8, fullscreen ? GLFW_FULLSCREEN : GLFW_WINDOW) == GL_FALSE) { printf("Failed to open window.\n"); glfwTerminate(); return 1; } glfwSetWindowTitle(windowTitle); glfwSetKeyCallback(keyboard); glfwSetMousePosCallback(motion); glfwSetMouseButtonCallback(mouse); glfwSetWindowSizeCallback(reshape); #endif #if defined(OSD_USES_GLEW) #ifdef CORE_PROFILE // this is the only way to initialize glew correctly under core profile context. glewExperimental = true; #endif if (GLenum r = glewInit() != GLEW_OK) { printf("Failed to initialize glew. Error = %s\n", glewGetErrorString(r)); exit(1); } #ifdef CORE_PROFILE // clear GL errors which was generated during glewInit() glGetError(); #endif #endif // activate feature adaptive tessellation if OSD supports it g_adaptive = OpenSubdiv::OsdGLDrawContext::SupportsAdaptiveTessellation(); initGL(); glfwSwapInterval(0); initHUD(); callbackModel(g_currentShape); g_fpsTimer.Start(); while (g_running) { idle(); display(); #if GLFW_VERSION_MAJOR>=3 glfwPollEvents(); glfwSwapBuffers(g_window); #else glfwSwapBuffers(); #endif } uninitGL(); glfwTerminate(); }
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; } }
//todo: Use a typedef for the saving type void Benchmark::Run() { Stopwatch watch; uint32_t tmp_Time; if( ::Just_Mem_Test ) tmp_Time = Time_Per_Test * 5; else if( ::Just_Cpu_Test ) tmp_Time = Time_Per_Test * 7; else if( ::Just_MT_Test ) tmp_Time = Time_Per_Test * 1; else tmp_Time = Time_Per_Test * 13; if( No_Cpu_Test ) tmp_Time -= Time_Per_Test * 7; if( No_Mem_Test ) tmp_Time -= Time_Per_Test * 5; if( No_MT_Test ) tmp_Time -= Time_Per_Test * 1; const uint32_t Time( tmp_Time ); uint32_t Loops(0); double Re8int(0), Re16int(0), Re32int(0), Re64int(0), Re32Fp(0), Re64Fp(0), Re96Fp(0), Re128Fp(0), ReMemRW2(0), ReMemRW4(0), ReMemDA2(0), ReMemDA4(0), ReMemDA8(0), ReMTMLuL(0); double Cur_Time(0); Status_Done(0); watch.Start(); for( ; Cur_Time < Time; ++Loops, watch.Look( Cur_Time ), Status_Done( static_cast< uint32_t >( (100.0/Time)*Cur_Time )) ) { if( !Just_Mem_Test && !Just_MT_Test && !No_Cpu_Test) { Re8int += static_cast< double > (Intern_Integer8_Test() ); if( m_Error ) return; Re16int += static_cast< double > (Intern_Integer16_Test() ); if( m_Error ) return; Re32int += static_cast< double > (Intern_Integer32_Test() ); if( m_Error ) return; Re64int += static_cast< double > (Intern_Integer64_Test() ); Re32Fp += static_cast< double > (Intern_Fp32_Test() ); if( m_Error ) return; Re64Fp += static_cast< double > (Intern_Fp64_Test() ); if( m_Error ) return; if( sizeof( long double ) == 12 ) Re96Fp += static_cast< double > (Intern_Fp96_Test() ); else if( sizeof( long double ) == 16 ) Re128Fp += static_cast< double > (Intern_Fp128_Test() ); if( m_Error ) return; } if( !Just_Cpu_Test && !Just_MT_Test && !No_Mem_Test) { ReMemRW2 += static_cast< double > (Intern_Mem_RW2_Test() ); if( m_Error ) return; ReMemRW4 += static_cast< double > (Intern_Mem_RW4_Test() ); if( m_Error ) return; ReMemDA2 += static_cast< double > (Intern_Mem_DA2_Test() ); if( m_Error ) return; ReMemDA8 += static_cast< double > (Intern_Mem_DA8_Test() ); if( m_Error ) return; ReMemDA4 += static_cast< double > (Intern_Mem_DA4_Test() ); if( m_Error ) return; } if( !Just_Cpu_Test && !Just_Mem_Test && !No_MT_Test ) { ReMTMLuL += static_cast< double > (Intern_MT_MLuL_Test() ); if( m_Error ) return; } } if( !Just_Mem_Test && !Just_MT_Test && !No_Cpu_Test) { //Todo:Change the cast to use the typedef! m_Integer8_Score = static_cast< Benchmark::Score_Type > ( (Re8int / static_cast<double> (Loops) ) ); m_Integer16_Score = static_cast< Benchmark::Score_Type > ( (Re16int / static_cast<double> (Loops) ) ); m_Integer32_Score = static_cast< Benchmark::Score_Type > ( (Re32int / Loops ) ); m_Integer64_Score = static_cast< Benchmark::Score_Type > ( (Re64int / static_cast<double> (Loops) ) ); m_Fp32_Score = static_cast< Benchmark::Score_Type > ( (Re32Fp / static_cast<double> (Loops) ) ); m_Fp64_Score = static_cast< Benchmark::Score_Type > ( (Re64Fp / static_cast<double> (Loops) ) ); m_Fp96_Score = static_cast< Benchmark::Score_Type > ( (Re96Fp / static_cast<double> (Loops) ) ); m_Fp128_Score = static_cast< Benchmark::Score_Type > ( (Re128Fp / static_cast<double>(Loops) ) ); } if( !Just_Cpu_Test && !Just_MT_Test && !No_Mem_Test) { m_Mem_RW2_Score = static_cast< Benchmark::Score_Type > ( ReMemRW2 / Loops ); m_Mem_RW4_Score = static_cast< Benchmark::Score_Type > ( ReMemRW4 / Loops ); m_Mem_DA2_Score = static_cast< Benchmark::Score_Type > ( ReMemDA2 / Loops ); m_Mem_DA4_Score = static_cast< Benchmark::Score_Type > ( ReMemDA4 / Loops ); m_Mem_DA8_Score = static_cast< Benchmark::Score_Type > ( ReMemDA8 / Loops ); } if( !Just_Cpu_Test && ! Just_Mem_Test && !No_MT_Test) { m_MT_MLuL_Score = static_cast< Benchmark::Score_Type > ( ReMTMLuL / Loops ); } }
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; }
//------------------------------------------------------------------------------ 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(); }