int main() { std::cout << "Boost.Statechart StopWatch example\n\n"; std::cout << "s<CR>: Starts/Stops stop watch\n"; std::cout << "r<CR>: Resets stop watch\n"; std::cout << "d<CR>: Displays the elapsed time in seconds\n"; std::cout << "e<CR>: Exits the program\n\n"; std::cout << "You may chain commands, e.g. rs<CR> resets and starts stop watch\n\n"; StopWatch stopWatch; stopWatch.initiate(); char key = GetKey(); while ( key != 'e' ) { switch( key ) { case 'r': { stopWatch.process_event( EvReset() ); } break; case 's': { stopWatch.process_event( EvStartStop() ); } break; case 'd': { double elapsedTime = 0.0; stopWatch.process_event( EvGetElapsedTime( elapsedTime ) ); std::cout << "Elapsed time: " << elapsedTime << "\n"; } break; default: { std::cout << "Invalid key!\n"; } break; } key = GetKey(); } return 0; }
int _tmain(int argc, _TCHAR* argv[]) { uint32_t goalsize = 6144; // 6GB _ASSERTE(create_very_big_file(L"big.txt",goalsize));//목표크기 6GB만큼 파일 생성 StopWatch sw; sw.Start(); _ASSERTE(file_copy_using_read_write(L"big.txt", L"big2.txt")); sw.Stop(); print("info] (Read Write) time elapsed = %f", sw.GetDurationSecond()); LARGE_INTEGER _Filesize; _Filesize.QuadPart = (LONGLONG)(1024*1024)*(LONGLONG)goalsize;//파일의 크기 6GB 설정하기위해 LARGE_INTEGER DWORD bufS = 4096; // read.write에서 buf가 4096이므로 4096설정 PUCHAR buf = (PUCHAR)malloc(bufS); LARGE_INTEGER _Offset; _Offset.QuadPart = 0; //파일을 옮겨주는 계산을 하는데 사용한다. StopWatch sw2; sw2.Start(); FileIoHelper FileHelp; FileHelp.FIOpenForRead(L"big.txt"); FileHelp.FIOCreateFile(L"big3.txt", _Filesize); while(_Filesize.QuadPart > _Offset.QuadPart) { if((_Filesize.QuadPart - _Offset.QuadPart) > (LONGLONG)bufS) bufS = 4096; else bufS = (DWORD)(_Filesize.QuadPart - _Offset.QuadPart); FileHelp.FIOReadFromFile(_Offset, bufS, buf); FileHelp.FIOWriteToFile(_Offset, bufS, buf); _Offset.QuadPart += (LONGLONG)bufS; } sw2.Stop(); print("info] (Memory Map) time elapsed = %f", sw2.GetDurationSecond()); return 0; }
boost::shared_ptr<FMainMemoryBTree> loadOneSSBBinFile( char *buffer, FSignatureSet &signatureFile, const std::string &dataFolder, TableType tableType, int64_t maxSize, const std::string &tblFolder, const std::string &tblName, bool cstore) { boost::shared_ptr<FMainMemoryBTree> btreePtr(new FMainMemoryBTree(tableType, maxSize, false)); FMainMemoryBTree *btree = btreePtr.get(); scoped_array<char> keyBufferPtr(new char[toKeySize(tableType)]); char *keyBuffer = keyBufferPtr.get(); ::memset (keyBuffer, 0, toKeySize(tableType)); ExtractKeyFromTupleFunc extractFunc = toExtractKeyFromTupleFunc(tableType); StopWatch watch; watch.init(); std::string filename = tblFolder + tblName; LOG (INFO) << "reading " << filename << "..."; std::ifstream file(filename.c_str(), std::ios::in | std::ios::binary); if (!file) { LOG (ERROR) << "could not open " << filename; throw std::exception(); } size_t maxBufCount = IO_BUFFER_SIZE / btree->getDataSize(); size_t maxBufSize = maxBufCount * btree->getDataSize(); assert (maxBufSize <= IO_BUFFER_SIZE); int count = 0; while (true) { file.read (buffer, maxBufSize); size_t readSize = file.gcount(); for (size_t pos = 0; pos + btree->getDataSize() <= readSize; pos += btree->getDataSize()) { if (++count % 100000 == 0) { LOG (INFO) << "reading " << count; } extractFunc (buffer + pos, keyBuffer); btree->insert(keyBuffer, buffer + pos); } if (readSize < maxBufSize) break; } LOG(INFO) << "read " << count << " lines"; btree->finishInserts(); file.close(); watch.stop(); LOG(INFO) << "constructred main memory BTree (" << watch.getElapsed() << " micsosec for reading and constructing). writing to disk..."; if (cstore) { LOG (INFO) << "cstore"; signatureFile.dumpToNewCStoreFiles(dataFolder, tblName, *btree); } else { LOG (INFO) << "rowstore"; signatureFile.dumpToNewRowStoreFile(dataFolder, tblName + ".db", *btree); } return btreePtr; }
void MVC_Model::InitLights(void) { #ifdef _DEBUG StopWatch initTimer; initTimer.startTimer(); std::cout << "Loading " << m_lightSONFile << "... "; #endif m_lights = LoadLight(m_lightSONFile); #ifdef _DEBUG std::cout << "Loaded! (" << initTimer.getElapsedTime() << "s)" << std::endl; #endif }
void MVC_Model::InitGameObjects() { #ifdef _DEBUG StopWatch initTimer; initTimer.startTimer(); std::cout << "Loading " << m_goSONFile << "... "; #endif goList = LoadGameObject(m_goSONFile, meshList); #ifdef _DEBUG std::cout << "Loaded! (" << initTimer.getElapsedTime() << "s)" << std::endl; #endif }
int TestLoggingOverhead_SingleThreaded_Synchronisation() { // First initialization, using defaults from Boost logging. BoostLogging::InitAddCommonAttributes(); BoostLogging::InitSetLogLevelToDebug(); BoostLogging::InitLogToDevNullSynchronized(); const int max = 1000000; { // debug messages are processed and written to /dev/null, because min level is debug StopWatch stopWatch; BoostLogging::LogDebugMessageManyTimes(max); std::cout << "Writing debug message to /dev/null synchronized): elapsed time: " << stopWatch.ElapsedSeconds().count() << ", max: " << max << std::endl; } return OutcomeIsOk();
void MVC_Model::InitSounds() { #ifdef _DEBUG StopWatch initTimer; initTimer.startTimer(); std::cout << "Loading " << m_soundSONFile << "... "; #endif soundList = LoadSounds(m_soundSONFile); #ifdef _DEBUG std::cout << "Loaded! (" << initTimer.getElapsedTime() << "s)" << std::endl; #endif }
bool LZ2DataRunner::run(Globals* g, const vector<string>& args) { if(args.size()<2){ cout << "at least two arguments! " <<endl; return false; } _file = args[0].c_str(); int testnum = atoi(args[1].c_str()); cout << "LZ2DataRunner: Running file " << _file << endl; bool success=true; int i=0; for (; i< 30; i++) if (strncmp(_file+i, "dnatest",7) == 0) { break; } char* temp = new char[30]; sprintf(temp, "test%dLZ%s", testnum, (_file+i+8)); char* fn = new char[30]; sprintf(fn, "test2LZ%s", (_file+i+8)); StopWatch stopWatch; stopWatch.start(); NOBDBAM* am = new NOBDBAM( fn, 1); LZDataSource* ds=new LZDataSource(am, false); HashSum* hashAgg = new HashSum((Operator*) ds, 0, (Operator*) ds, 0); hashAgg->setHashFunction(new IdentityHashFunction(200)); hashAgg->setHashTableSize(200); Operator* srcs[1]={hashAgg}; int numCols[1]={2}; char* temp3 = new char[30]; sprintf(temp3, "%s.out", temp); BlockPrinter* bPrint=new BlockPrinter(srcs, numCols, 1, temp3); bPrint->printColumns(); sprintf(temp3, "test%dLZ.dat", testnum); ofstream flStream; flStream.open(temp3, ios::out | ios::app); flStream.seekp(ios::end); flStream << "xval: " << (_file+i+8) << endl; stopWatch.stopToFile(temp3); flStream.close(); return success; }
int main() { using::Journey::Client; using::Journey::ClientError; Client client; ClientError error = client.geterror(); if (error == Journey::CLERR_NOERROR) { uint16_t dpf = 4; uint16_t remain = 0; using::Util::StopWatch; StopWatch swatch; while (client.receive()) { remain += swatch.evaluate(); while (remain > dpf - 1) { client.update(dpf); remain -= dpf; } client.draw(); } } else { switch (error) { case Journey::CLERR_NXFILES: showerror("Error: Could not find valid game files."); break; case Journey::CLERR_CONNECTION: showerror("Error: Could not connect to server."); break; case Journey::CLERR_WINDOW: showerror("Error: Could not initialize graphics."); break; case Journey::CLERR_AUDIO: showerror("Error: Could not initialize audio."); break; } while (true) {} } return 0; }
static double testQueuePop() { StopWatch stopWatch; for(std::size_t iter = 0; iter != testing::STANDARD_SPEED_ITERS; ++iter) { std::queue<std::size_t> queue; for(std::size_t count = 0; count != testing::STANDARD_SPEED_COUNT; ++count) { queue.push(count); } stopWatch.start(); for(std::size_t count = 0; count != testing::STANDARD_SPEED_COUNT; ++count) { queue.pop(); } stopWatch.stop(); } return testing::calcNanosPer(getTimevalAsMicros(stopWatch.elapsed())); }
AJValue JSC_HOST_CALL functionRun(ExecState* exec, AJObject*, AJValue, const ArgList& args) { StopWatch stopWatch; UString fileName = args.at(0).toString(exec); Vector<char> script; if (!fillBufferWithContentsOfFile(fileName, script)) return throwError(exec, GeneralError, "Could not open file."); AJGlobalObject* globalObject = exec->lexicalGlobalObject(); stopWatch.start(); evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName)); stopWatch.stop(); return jsNumber(globalObject->globalExec(), stopWatch.getElapsedMS()); }
/* ????TestFloat 1074.285570 / 10000000 = 0.000107 ????TestFloat2 30.188889 / 10000000 = 0.000003 */ void OtherTest::TestFloat() { const int count=10000000; float f=1.73f; float outi; StopWatch watch; watch.SetRunTimes(count); watch.SetName("TestFloat"); watch.Start(); FOR_EACH_SIZE(i,count) { float r= modf(f,&outi); int ii=(int)outi; }
void PercolationStats::run() { int i; // perform T independent computational experiments on an N-by-N grid StopWatch watch; for (int i = 0; i < m_experimentsNumber; i++) { watch.start(); m_threshold[i] = experiment(); m_time[i] = watch.stop(); m_percolation->reset(); } // Stats m_timeStats = new StatsData(m_time, m_experimentsNumber); m_thresholdStats = new StatsData(m_threshold, m_experimentsNumber); }
// Initialize the application // initialize the state of your app here if needed... static void OnApplicationInit() { // Don't put open GL code here, this func may be called at anytime // even before the API is initialized // (like before a graphics context is obtained) aliases[0].sound.init( "sep" ); aliases[9].sound.init( "sol" ); aliases[8].sound.init( "attack" ); aliases[7].sound.init( "drum" ); snx::SoundInfo si; si.ambient = false; si.datasource = snx::SoundInfo::FILESYSTEM; si.filename = "sep.wav"; aliases[0].sound.configure( si ); si.filename = "sol.wav"; aliases[9].sound.configure( si ); si.filename = "attack.wav"; aliases[8].sound.configure( si ); si.filename = "drum44100.wav"; aliases[7].sound.configure( si ); kevinSound.init( "kevin" ); stopWatch.pulse(); }
bool initLogging(const char* ident, Flags<LogMode> mode, LogLevel level, const Path &file, Flags<LogFileFlag> flags, LogLevel logFileLogLevel) { sStart.start(); sFlags = flags; sLevel = level; if (mode & LogStderr) { std::shared_ptr<StderrOutput> out(new StderrOutput(level)); out->add(); } if (mode & LogSyslog) { std::shared_ptr<SyslogOutput> out(new SyslogOutput(ident, level)); out->add(); } if (!file.isEmpty()) { if (!(flags & (Append|DontRotate)) && file.exists()) { int i = 0; while (true) { const Path rotated = String::format<64>("%s.%d", file.constData(), ++i); if (!rotated.exists()) { if (rename(file.constData(), rotated.constData())) { error() << "Couldn't rotate log file" << file << "to" << rotated << Rct::strerror(); } break; } } } FILE *f = fopen(file.constData(), flags & Append ? "a" : "w"); if (!f) return false; std::shared_ptr<FileOutput> out(new FileOutput(logFileLogLevel, f)); out->add(); } return true; }
// run the plan void Plan::run(bool rosOnly) { if (m_lpRootNode != NULL) { StopWatch stopWatch; stopWatch.start(); m_lpRootNode->run(rosOnly); cout << "Query took: " << stopWatch.stop() << " ms" << endl; } else { cout << "No plan generated" << endl; } }
void testGetInSeconds() { StopWatch sw; // 2 s timespec delay; delay.tv_sec = static_cast<time_t>(2); delay.tv_nsec = static_cast<long>(0*1E9); sw.start(); nanosleep(&delay, NULL); sw.stop(); CPPUNIT_ASSERT_EQUAL( 2, static_cast<int>(round(sw.getInSeconds())) ); }
bool initLogging(const char* ident, int mode, int level, const Path &file, unsigned flags) { sStart.start(); sFlags = flags; sLevel = level; if (mode & LogStderr) new StderrOutput(level); if (mode & LogSyslog) new SyslogOutput(ident, level); if (!file.isEmpty()) { if (!(flags & (Log::Append|Log::DontRotate)) && file.exists()) { int i = 0; while (true) { const Path rotated = String::format<64>("%s.%d", file.constData(), ++i); if (!rotated.exists()) { if (rename(file.constData(), rotated.constData())) { char buf[1025]; if (!strerror_r(errno, buf, 1024)) { error() << "Couldn't rotate log file" << file << "to" << rotated << buf; } } break; } } } FILE *f = fopen(file.constData(), flags & Log::Append ? "a" : "w"); if (!f) return false; new FileOutput(f); } return true; }
EncodedJSValue JSC_HOST_CALL functionRun(ExecState* exec) { UString fileName = exec->argument(0).toString(exec)->value(exec); Vector<char> script; if (!fillBufferWithContentsOfFile(fileName, script)) return JSValue::encode(throwError(exec, createError(exec, "Could not open file."))); GlobalObject* globalObject = GlobalObject::create(exec->globalData(), GlobalObject::createStructure(exec->globalData(), jsNull()), Vector<UString>()); StopWatch stopWatch; stopWatch.start(); evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), jscSource(script.data(), fileName)); stopWatch.stop(); return JSValue::encode(jsNumber(stopWatch.getElapsedMS())); }
JSValue* functionRun(ExecState* exec, JSObject*, JSValue*, const ArgList& args) { StopWatch stopWatch; UString fileName = args.at(exec, 0)->toString(exec); Vector<char> script; if (!fillBufferWithContentsOfFile(fileName, script)) return throwError(exec, GeneralError, "Could not open file."); JSGlobalObject* globalObject = exec->dynamicGlobalObject(); stopWatch.start(); Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), fileName, 1, script.data()); stopWatch.stop(); return jsNumber(globalObject->globalExec(), stopWatch.getElapsedMS()); }
bool LocalClient::connect(const Path& path, int maxTime) { if (!path.isSocket()) return false; StopWatch timer; struct sockaddr_un address; memset(&address, 0, sizeof(struct sockaddr_un)); address.sun_family = AF_UNIX; const int sz = std::min<int>(sizeof(address.sun_path) - 1, path.size()); memcpy(address.sun_path, path.constData(), sz); address.sun_path[sz] = '\0'; while (true) { mFd = ::socket(PF_UNIX, SOCK_STREAM, 0); if (mFd == -1) { Path::rm(path); return false; } int ret; eintrwrap(ret, ::connect(mFd, (struct sockaddr *)&address, sizeof(struct sockaddr_un))); if (!ret) { #ifdef HAVE_NOSIGPIPE ret = 1; ::setsockopt(mFd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&ret, sizeof(int)); #endif break; } eintrwrap(ret, ::close(mFd)); mFd = -1; if (maxTime > 0 && timer.elapsed() >= maxTime) { Path::rm(path); return false; } } assert(mFd != -1); int flags; eintrwrap(flags, fcntl(mFd, F_GETFL, 0)); eintrwrap(flags, fcntl(mFd, F_SETFL, flags | O_NONBLOCK)); unsigned int fdflags = EventLoop::Read; if (!mBuffers.empty()) fdflags |= EventLoop::Write; EventLoop::instance()->addFileDescriptor(mFd, fdflags, dataCallback, this); mConnected(this); return true; }
/** * \brief Program to compute PI using brute force a niave algorithm. */ int main(int argc, const char * argv[]) { std::cout << "Calculating pi by computing the of 1/4 unit-circle." << std::endl; StopWatch PiTimer; PiTimer.StartTimer(); const double areaUnitCircle = CaluculatePiByEstimatingUnitCircleArea(50000); PiTimer.StopTimer(); std::cout << std::setprecision(17) ; std::cout << "Accurate PI = " << pi() << std::endl; std::cout << "Calculated PI = " << areaUnitCircle << std::endl; std::cout << "ERROR = " << areaUnitCircle - pi() << std::endl; std::cout << "Seconds = " << PiTimer.GetElapsedSeconds() << std::endl; return EXIT_SUCCESS; }
// This main loop calls functions to get input, update and render the game // at a specific frame rate void game() { int current = 500; createsnake(3); cls(); map(); g_timer.startTimer(); // Start timer to calculate how long it takes to render this frame while (!gameover) // run this loop until user wants to quit { getInput(); // get keyboard input current = update(g_timer.getElapsedTime()); // update the game render(); // render the graphics output to screen g_timer.waitUntil(current/FPS); // Frame rate limiter. Limits each frame to a specified time in ms. } highscore(); gg(); }
void Dispatcher::dispatchRequest( unsigned int uCommand,PushFramework::LogicalConnection* pClient,IncomingPacket& packet,unsigned int serviceBytes ) { //StopWatch dispatchWatch(m_QPFrequency); serviceMapT::iterator it = serviceMap.find(uCommand); if (it == serviceMap.end()) return; // Service* pHandler = it->second->pService; //wcout << L"Locating Service : " << dispatchWatch.GetElapsedTime(false) << std::endl; //Mark dispatched service : setCurrentService(it->second->serviceName); StopWatch watch; pHandler->handle(pClient, &packet); double duration = watch.GetElapsedTime(); /* wcout << L"Service Time : " << watch.GetElapsedTime() << std::endl; */ //StopWatch statsClock(m_QPFrequency); stats.addToDistribution(ServerStats::PerformanceProcessingTimePerService, it->second->serviceName, duration); //wcout << L"Stat 1 : " << statsClock.GetElapsedTime(false) << std::endl; stats.addToDuration(ServerStats::PerformanceProcessingTime, duration); //wcout << L"Stat 2 : " << statsClock.GetElapsedTime(false) << std::endl; UnsetCurrentService(); //Stats. : stats.addToDistribution(ServerStats::BandwidthInboundVolPerRequest, it->second->serviceName, serviceBytes); //wcout << L"Stat 3 : " << statsClock.GetElapsedTime(false) << std::endl; stats.addToDistribution(ServerStats::PerformanceRequestVolPerRequest, it->second->serviceName, 1); //wcout << L"Stat 4 : " << statsClock.GetElapsedTime(false) << std::endl; //wcout << L"Dispatch Time : " << dispatchWatch.GetElapsedTime() << std::endl; }
void ThreadBoost::SleepFor(millis_t millis, bool ensureSleepForCorrectTime) { if(ensureSleepForCorrectTime){ StopWatch sw; millis_t remain = millis; do{ boost::this_thread::sleep(boost::posix_time::milliseconds(remain)); millis_t remain = millis - sw.Elapsed(false); if(remain <= 0) break; boost::this_thread::yield(); }while(true); }else{ boost::this_thread::sleep(boost::posix_time::milliseconds(millis)); } }
void SceneBase::InitMaterials() { const string MATERIAL_FILE_PATH = "SONs//Materials.son"; StopWatch initTimer; initTimer.startTimer(); std::cout << "Loading " << MATERIAL_FILE_PATH << "... "; matList = LoadMaterial(MATERIAL_FILE_PATH); // Push the default Material to the Material temp; temp.name = "DefaultMaterial"; matList.insert(std::pair<string, Material>(temp.name, temp)); std::cout << "Loaded! (" << initTimer.getElapsedTime() << "s)" << std::endl; }
static double testPriorityQueueAddSequential() { double total(0); StopWatch stopWatch; for(std::size_t iter = 0; iter != testing::STANDARD_SPEED_ITERS; ++iter) { std::priority_queue<FooBar> pq; stopWatch.start(); for(std::size_t count = 0; count != testing::STANDARD_SPEED_COUNT; ++count) { pq.push(FooBar(count)); } stopWatch.stop(); total += getTimevalAsMicros(stopWatch.elapsed()); stopWatch.reset(); } return testing::calcNanosPer(total); }
static double testListPushBack() { double total(0); StopWatch stopWatch; for(std::size_t iter = 0; iter != testing::STANDARD_SPEED_ITERS; ++iter) { std::list<std::size_t> list; stopWatch.start(); for(std::size_t count = 0; count != testing::STANDARD_SPEED_COUNT; ++count) list.push_back(count); stopWatch.stop(); total += getTimevalAsMicros(stopWatch.elapsed()); stopWatch.reset(); } return testing::calcNanosPer(total); }
static double testMapAddSequential() { double total(0); StopWatch stopWatch; for(std::size_t iter = 0; iter != testing::STANDARD_SPEED_ITERS; ++iter) { std::map<std::size_t,std::size_t> map; stopWatch.start(); for(std::size_t count = 0; count != testing::STANDARD_SPEED_COUNT; ++count) { map[count] = count; } stopWatch.stop(); total += getTimevalAsMicros(stopWatch.elapsed()); stopWatch.reset(); } return testing::calcNanosPer(total); }
void FormatTest::TestInt() { const int count=100000; int val = 1000; StopWatch watch; watch.SetRunTimes(count); watch.SetName("TestInt"); watch.Start(); std::string str1; FOR_EACH_SIZE(i, count) { char temp[64]; sprintf_s(temp, "%d", val); str1.assign(temp); }