/// <summary> /// wait for the specficed ms until keypressed /// </summary> /// <param name="ms">The ms to wait.</param> /// <returns>The key pressed(ASC-II not guaranteed).</returns> int waitkey(double ms) { int key = -1; double start = get_real_time(); double end = start + ms / 1000; #if defined(__unix__) || defined(__unix) || defined(unix) || (defined(__APPLE__) && defined(__MACH__)) set_conio_terminal_mode(); #endif if (ms <= 0) { // disable timer if ms <= 0 end = DBL_MAX; } while (key == -1) { key = kb_hit(); //printf("%d", (int)get_elapsed_time_ms(start)); if (get_real_time() >= end) { break; } } //std::cin.get(); #if defined(__unix__) || defined(__unix) || defined(unix) || (defined(__APPLE__) && defined(__MACH__)) reset_terminal_mode(); #endif return key; }
double get_time_resolution() { double T0=get_real_time(); for (int k=0; k<1000000; k++) { double t1= get_real_time()-T0; double t2 = get_real_time()-T0; if ( t2-t1 != 0) return (t2-t1); } }
/** * \brief Initializes the basic low-level system. * * Initializes the audio system, the video system, * the data file system, etc. * * \param args Command-line arguments. */ void System::initialize(const Arguments& args) { // initialize SDL SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK); initial_time = get_real_time(); ticks = 0; // files FileTools::initialize(args); // audio Sound::initialize(args); // input InputEvent::initialize(); // random number generator Random::initialize(); // video Video::initialize(args); Color::initialize(); FontResource::initialize(); Sprite::initialize(); }
PackageLinksDirectory::PackageLinksDirectory() : Directory(0), fListener(NULL) // the ID needs to be assigned later, when added to a volume { get_real_time(fModifiedTime); }
void client_main_loop (void) { int quit = 0; int engine_updated = 0; /* Set up the game */ reset_start_time (); update_avail_modules (0); screen_full_refresh (); if (no_init_help == 0) { block_help_exit = 1; help_flag = 1; if (make_dir_ok_flag) { activate_help ("ask-dir.hlp"); make_dir_ok_flag = 0; } else { activate_help ("opening.hlp"); } } /* Set speed */ #if defined (CS_PROFILE) || defined (START_FAST_SPEED) select_fast (); #else select_medium (); #endif /* Main Loop */ do { int key; /* Get timestamp for this iteration */ get_real_time(); /* Process events */ #if defined (LC_X11) call_event (); key = x_key_value; x_key_value = 0; #elif defined (WIN32) call_event (); key = GetKeystroke (); #else mouse_update (); key = vga_getkey (); #endif /* nothing happened if key == 0 XXX: right? */ /* GCS: I'm not sure */ if (key != 0) { process_keystrokes (key); } /* Simulate the timestep */ quit = execute_timestep (); } while (quit == 0); }
void doLincityStep() { /* Get timestamp for this iteration */ get_real_time(); execute_timestep (); // return true; }
int main() { std_setup(); int n = 256; double x0 = ml_pi; double tf = 1.0; double dt = 0.1; grid2D<double,double,double > grid( n,-x0,x0, n,-x0,x0 ),u,v,C2,damp; grid = 0.0; u = grid; v = grid; C2 = grid; C2 = 1.0; u = u_0_func(); sprintf(fname,"/workspace/output/acoustic_propagate_2d/out_dat/C2.dat", n); writeFile(C2,fname); linear_propagator P; P.init( grid, 1, C2 ); double t = 0.0; while (t <= tf) { output(t,u,v); double t1 = get_real_time(); P( dt, u,v,u,v ); double t2 = get_real_time(); cout << t << "\t" << t2-t1 << endl; t += dt; } output(t,u,v); }
void CRefresher::deal(workbench_t &bench) { char * tmp; tmp = create_cp(bench); string new_cp(tmp); bool changed = false; int old_timeout = bench.timeout; #ifndef _TEST //if there is no url=bench.url in our file, we write delete log too if (bench.reply.status.code == 404) { time_t timep; time(&timep); // fprintf(deletelog,"delete url %s %s\n", // bench.url->str().c_str(), ctime(&timep)); return; } #endif if (bench.timeout == 0) { changed = true; //first time crawled time_t timep; time(&timep); // fprintf(newlog,"new url %s %s\n", // bench.url->str().c_str(), ctime(&timep)); } else{ if (new_cp != bench.checkpoint) { //changed changed = true; time_t timep; time(&timep); // fprintf(changelog,"change url %s %s\n", // bench.url->str().c_str(), ctime(&timep)); } } bench.changed = changed; bench.timeout = rconfig.calculate(bench.url.str().c_str(),old_timeout,changed,bench.depth); CTime_struct real_time = get_real_time(bench.timeout); #ifdef _TEST cout << "new real_time = " << real_time.time_to_string() << endl; #endif #ifndef _TEST bench.checkpoint = new_cp; #endif save_to_file(bench,real_time); }
static void test_realtime() { return; real_time_t rt; get_real_time(&rt); s32 y = 550; draw_hex8(rt.rt_year, 650, y + 20*0, color); draw_hex8(rt.rt_month, 650, y + 20*1, color); draw_hex8(rt.rt_day, 650, y + 20*2, color); draw_hex8(rt.rt_hour, 650, y + 20*3, color); draw_hex8(rt.rt_minute, 650, y + 20*4, color); draw_hex8(rt.rt_second, 650, y + 20*5, color); }
double Real_timer::compute_precision() const { // Computes timer precision in seconds dynamically. Note that // the timer system call is probably non-trivial and will show // up in this time here (probably for one call). But that is just // fine that the call to the timer itself if reported as noise // in the precision. double min_res = DBL_MAX; for ( int i = 0; i < 5; ++i) { double current = get_real_time(); if ( m_failed) return -1.0; double next = get_real_time(); while ( current >= next) { // wait until timer increases next = get_real_time(); if ( m_failed) return -1.0; } // Get the minimum timing difference of all runs. if ( min_res > next - current) min_res = next - current; } return min_res; }
long get_msec_real_time (void) { #if 0 struct timezone tz; struct timeval time; gettimeofday (&time, &tz); return ((time.tv_sec * 1000) + (time.tv_usec / 1000)); #endif get_real_time (&time_now); time_now_msec = time_now.to_sec * 1000 + time_now.to_usec / 1000; return approx_msec_real_time (); }
void *threadFunc(void *args) { double T0 = *(double*)args; int tres = *(int*)((char*)args+8); for (int k=0; k<100; k++) { cout << "t\t" << (get_real_time()-T0)*tres << endl; } return NULL; }
int main() { std_setup(); double T0; int tres=0; tres = 1.0/get_time_resolution(); T0=get_real_time(); cout << tres << endl; pthread_t pth; char args[100]; *(double*)args =T0; *(int*)(args+8)=tres; pthread_create( &pth, NULL, threadFunc, (void*)args ); pthread_join(pth, NULL); for (int k=0; k<100; k++) { cout << "m\t" << (get_real_time()-T0)*tres << endl; } std_exit(); }
int main (int argc, char *argv[]) { char* load_filename; /* Initialize some global variables */ initialize_server (); /* Set up the paths to certain files and directories */ init_path_strings (); #ifndef CS_PROFILE #ifdef SEED_RAND srand (time (0)); #endif #endif init_types (); initialize_tax_rates (); reset_start_time (); load_filename = parse_server_args (argc, argv); if (load_filename && file_exists(load_filename)) { printf ("Server is trying to load: %s\n", load_filename); load_city (load_filename); zoom_originx = main_screen_originx; zoom_originy = main_screen_originy; } else { engine_new_city (&zoom_originx, &zoom_originy, 1); } printf ("Server starting main loop!\n"); while (1) { sniff_packets (); engine_do_time_step (); get_real_time (); send_periodic_messages (); if (total_time % 1000 == 0) { debug_print_stats (); } } return 0; }
long approx_msec_real_time (void) { /* return (time_now.to_sec * 1000 + time_now.to_usec / 1000); */ static timeout_t ret; if (boot_time.to_sec == 0) { get_real_time (&boot_time); return 0; } if (time_now.to_usec >= boot_time.to_usec) { ret.to_sec = time_now.to_sec - boot_time.to_sec; ret.to_usec = time_now.to_usec - boot_time.to_usec; } else { ret.to_sec = time_now.to_sec - boot_time.to_sec - 1; ret.to_usec = time_now.to_usec + 1000000 - boot_time.to_usec; } return last_approx_msec_real_time = ret.to_sec * 1000 + (ret.to_usec + 500) / 1000; }
int main() { std_setup(); int n = 256; double x0 = 10; double tf = 10.0; double dt = 0.05; int expansion_order = 7; int hdaf_order = 8; grid2D<double,double,double > grid( n,-10,10.0, n,-10,10.0 ),u,v,C2,damping; grid = 0.0; u = grid; v = grid; C2 = grid; damping = grid; u = u_0_func(); C2 = C2_func(); damping = damping_func(); sprintf(fname,"/workspace/output/acoustic_propagate_2d/out_dat/C2.dat" ); writeFile(C2,fname); void * pdata = 0; method1_init( &pdata, grid.n1, grid.n2, grid.dx1(), grid.dx2(), C2.array, damping.array, 7, hdaf_order, hdaf_order, 0.8, 0.8 ); //acoustic_propagator P; //P.init( grid, 7, C2, damping ); double t = 0.0; cout << "step: " << t << "\t" << L2norm(u) << endl; n=0; double * b_times = new double [ int(tf/dt+5) ]; while (t <= tf) { output(t,u,v); double t1 = get_real_time(); method1_execute( pdata, dt, u.array,v.array,u.array,v.array ); //P( dt, u,v,u,v ); double t2 = get_real_time(); b_times[n] = t2-t1; double mean = 0; for (int j=0; j<n; j++) mean += b_times[j]/n; cout << mean << endl; n++; double mag = L2norm(u); cout << "step: " << t << "\t" << t2-t1 << "\t" << mag << endl; t += dt; if ( mag > 1E10 ) break; } output(t,u,v); }
void si_scroll_text (void) { char s[LC_PATH_MAX], line1[100], line2[100], line3[100], c; int i, t, l1c = 0, l2c = 0, l3c = 0; FILE *inf1, *inf2, *inf3; #ifdef LC_X11 XEvent xev; #endif Fgl_enableclipping (); sprintf (s, "%s%c%s", opening_path, PATH_SLASH, "text1"); if ((inf1 = fopen (s, "rb")) == NULL) do_error ("Can't open opening/text1"); for (i = 0; i < 52; i++) line1[i] = si_next_char (inf1); line1[52] = 0; sprintf (s, "%s%c%s", opening_path, PATH_SLASH, "text2"); if ((inf2 = fopen (s, "rb")) == NULL) do_error ("Can't open opening/text2"); for (i = 0; i < 52; i++) line2[i] = si_next_char (inf2); line2[52] = 0; sprintf (s, "%s%c%s", opening_path, PATH_SLASH, "text3"); if ((inf3 = fopen (s, "rb")) == NULL) do_error ("Can't open opening/text3"); for (i = 0; i < 52; i++) line3[i] = si_next_char (inf3); line3[52] = 0; do { get_real_time (); t = real_time + SPLASH_SCROLL_DELAY; #ifdef LC_X11 if (XPending (display.dpy)) { XNextEvent (display.dpy, &xev); HandleEvent (&xev); } c = x_key_value; #elif defined (WIN32) c = GetKeystroke (); #elif defined LC_SVGA c = vga_getkey (); #endif if (l1c >= 8) { for (i = 0; i < 51; i++) line1[i] = line1[i + 1]; line1[51] = si_next_char (inf1); l1c = 0; } Fgl_setfont (8, 8, start_font1); Fgl_setclippingwindow (120, 30, 520, 40); Fgl_setfontcolors (SI_BLACK, SI_RED); #if defined (LC_X11) || defined (WIN32) open_write (120 - l1c, 31, line1); #else Fgl_write (120 - l1c, 31, line1); #endif l1c++; if (l2c >= 8) { for (i = 0; i < 51; i++) line2[i] = line2[i + 1]; line2[51] = si_next_char (inf2); l2c = 0; } Fgl_setfont (8, 16, start_font2); Fgl_setclippingwindow (120, 55, 520, 73); Fgl_setfontcolors (SI_BLACK, SI_GREEN); #if defined (LC_X11) || defined (WIN32) open_write (120 - l2c, 57, line2); #else Fgl_write (120 - l2c, 57, line2); #endif l2c += 2; if (l3c >= 8) { for (i = 0; i < 51; i++) line3[i] = line3[i + 1]; line3[51] = si_next_char (inf3); l3c = 0; } Fgl_setfont (8, 16, start_font3); Fgl_setclippingwindow (120, 88, 520, 106); Fgl_setfontcolors (SI_BLACK, SI_YELLOW); #if defined (LC_X11) || defined (WIN32) open_write (120 - l3c, 90, line3); #else Fgl_write (120 - l3c, 90, line3); #endif l3c += 2; #if defined (WIN32) /* Scroll a little faster for WIN32 */ if (pix_double) { l1c += 10; l2c += 10; l3c += 10; } else { l1c += 2; l2c += 4; l3c += 4; } #endif while (real_time < t) { lc_usleep (1); get_real_time (); } } while (c == 0); fclose (inf1); fclose (inf2); fclose (inf3); Fgl_disableclipping (); }
unsigned long get_user_time(void) { return get_real_time(); }
//////////////////////////////// Timer class //////////////////////////////////// /// <summary> /// Updates the current timestamp. /// </summary> void Timer::update() { timestamp = get_real_time(); }
/// <summary> /// Get the time elapsed in second since last update. /// </summary> /// <returns>The time elapsed in second</returns> double Timer::get_elapsed_time_s() { return get_real_time() - timestamp; }
/// <summary> /// Get the time elapsed in us since last update. /// </summary> /// <returns>The time elapsed in us</returns> double Timer::get_elapsed_time_us() { return (get_real_time() - timestamp) * 1000000.0; }
/** Write to an AFS file * \par Description: * Write from the given buffer into the given file starting at the given offset for * the given length. First, if the offset is not block aligned, read the first * block/extent, write from the buffer into it starting at offset, and write it back * out. Next, for all the complete blocks/extents, in the range, write to them from * the buffer. Finally, if there is more to write, read the last extent/buffer, * write from the buffer into the beginning of the block/extent, and write it out. * \par Note: Directory data does not appear to be cached. This could be a huge slowdown. * \par Warning: * \param psVolume AFS filesystem pointer * \param psInode AFS Inode to write to * \param pBuffer Buffer to write from * \param nPos Start position in file to write at * \param a_nSize Number of octets to write * \return 0 on success, negative error code on failure * \sa *****************************************************************************/ int afs_do_write( AfsVolume_s * psVolume, AfsInode_s * psInode, const char *pBuffer, off_t nPos, size_t a_nSize ) { const int nBlockSize = psVolume->av_psSuperBlock->as_nBlockSize; int nSize = a_nSize; off_t nFirstBlock = nPos / nBlockSize; off_t nLastBlock =( nPos + nSize + nBlockSize - 1 ) / nBlockSize; off_t nNumBlocks = nLastBlock - nFirstBlock + 1; int nOffset = nPos % nBlockSize; off_t nBlockAddr; char *pBlock = NULL; int nRunLength; int nError; if( ( nPos + nSize ) > ( afs_get_inode_block_count( psInode ) * nBlockSize ) ) { if( S_ISDIR( psInode->ai_nMode ) ) { printk( "Panic: afs_do_write() dir to small!!\n" ); } else { printk( "Panic: afs_do_write() file to small!!\n" ); } return( -ENOSPC ); } if( S_ISDIR( psInode->ai_nMode ) ) { pBlock = afs_alloc_block_buffer( psVolume ); if( pBlock == NULL ) { printk( "Error: afs_do_write() no memory for data buffer\n" ); return( -ENOMEM ); } } nError = afs_get_stream_blocks( psVolume, &psInode->ai_sData, nFirstBlock, nNumBlocks, &nBlockAddr, &nRunLength ); if( nError < 0 ) { printk( "Error: afs_do_write() 1 afs_get_stream_blocks() failed with code %d\n", nError ); } if( nError >= 0 && nOffset != 0 ) { if( S_ISDIR( psInode->ai_nMode ) ) { nError = afs_logged_read( psVolume, pBlock, nBlockAddr ); } else { pBlock =( char * )get_cache_block( psVolume->av_nDevice, nBlockAddr, nBlockSize ); if( pBlock == NULL ) { nError = -EIO; } } if( nError >= 0 ) { off_t nLen = min( nSize, nBlockSize - nOffset ); memcpy( pBlock + nOffset, pBuffer, nLen ); if( S_ISDIR( psInode->ai_nMode ) ) { nError = afs_logged_write( psVolume, pBlock, nBlockAddr ); } else { mark_blocks_dirty( psVolume->av_nDevice, nBlockAddr, 1 ); release_cache_block( psVolume->av_nDevice, nBlockAddr ); } if( nError >= 0 ) { pBuffer += nLen; nSize -= nLen; nBlockAddr++; nFirstBlock++; nRunLength--; nNumBlocks--; } } } while( nSize >= nBlockSize && nError >= 0 ) { off_t nLen; if( nRunLength == 0 ) { nError = afs_get_stream_blocks( psVolume, &psInode->ai_sData, nFirstBlock, nNumBlocks, &nBlockAddr, &nRunLength ); if( nError < 0 ) { printk( "Error: afs_do_write() 2 afs_get_stream_blocks() failed with code %d\n", nError ); } } if( nError >= 0 ) { int i; nLen = min( nSize / nBlockSize, nRunLength ); if( S_ISDIR( psInode->ai_nMode ) ) { nError = 0; for( i = 0; i < nLen; ++i ) { nError = afs_logged_write( psVolume, pBuffer, nBlockAddr ); if( nError < 0 ) { printk( "Error: afs_do_write() failed to write directory data block\n" ); break; } nRunLength--; nNumBlocks--; nFirstBlock++; nBlockAddr++; nSize -= nBlockSize; pBuffer += nBlockSize; kassertw( nRunLength >= 0 ); kassertw( nSize >= 0 ); } } else { nError = cached_write( psVolume->av_nDevice, nBlockAddr, pBuffer, nLen, nBlockSize ); if( nError >= 0 ) { nRunLength -= nLen; nNumBlocks -= nLen; nFirstBlock += nLen; nBlockAddr += nLen; nSize -= nLen * nBlockSize; pBuffer += nLen * nBlockSize; kassertw( nRunLength >= 0 ); kassertw( nSize >= 0 ); } } } } if( nSize > 0 && nError >= 0 ) { if( nRunLength == 0 ) { nError = afs_get_stream_blocks( psVolume, &psInode->ai_sData, nFirstBlock, nNumBlocks, &nBlockAddr, &nRunLength ); if( nError < 0 ) { printk( "Error: afs_do_write() 3 afs_get_stream_blocks() failed with code %d\n", nError ); } } if( nError >= 0 ) { if( S_ISDIR( psInode->ai_nMode ) ) { if( psInode->ai_sData.ds_nSize > ( nPos + a_nSize ) ) { nError = afs_logged_read( psVolume, pBlock, nBlockAddr ); } } else { if( psInode->ai_sData.ds_nSize > ( nPos + a_nSize ) ) { pBlock =( char * )get_cache_block( psVolume->av_nDevice, nBlockAddr, nBlockSize ); } else { pBlock =( char * )get_empty_block( psVolume->av_nDevice, nBlockAddr, nBlockSize ); } if( pBlock == NULL ) { nError = -EIO; } } kassertw( nSize < nBlockSize ); if( nError >= 0 ) { off_t nLen = min( nSize, nBlockSize ); memcpy( pBlock, pBuffer, nSize ); pBuffer += nLen; nSize -= nLen; if( S_ISDIR( psInode->ai_nMode ) ) { nError = afs_logged_write( psVolume, pBlock, nBlockAddr ); if( nError < 0 ) { printk( "Error: afs_do_write() failed to write last partial block to directory\n" ); } } else { mark_blocks_dirty( psVolume->av_nDevice, nBlockAddr, 1 ); release_cache_block( psVolume->av_nDevice, nBlockAddr ); } } } } if( S_ISDIR( psInode->ai_nMode ) ) { afs_free_block_buffer( psVolume, pBlock ); } if( nError >= 0 ) { if( ( nPos + a_nSize ) > psInode->ai_sData.ds_nSize ) { psInode->ai_sData.ds_nSize = nPos + a_nSize; } psInode->ai_nModifiedTime = get_real_time(); psInode->ai_nFlags |= INF_WAS_WRITTEN | INF_STAT_CHANGED; } return( nError ); }
/** Create and insert a new Inode * \par Description: * Create in Inode with the given mode, flags, index type, and name, add it to the * given parent directory, and write it to the given volume. * \par Note: * \par Warning: * \param psVolume AFS filesystem pointer * \param psParent AFS Inode of directory to contain new Inode * \param nMode Type of inode (normal file, directory, etc. S_IF*) * \param nFlags Inode flags (INF_*) * \param nIndexType Key type of index for inode (e_KeyType*) * \param pzName Name of file associated with Inode * \param nNameLen Length of pzName * \param ppsRes Return argument for new Inode * \return 0 on success, negative error code on failure * \sa *****************************************************************************/ int afs_create_inode( AfsVolume_s * psVolume, AfsInode_s * psParent, int nMode, int nFlags, int nIndexType, const char *pzName, int nNameLen, AfsInode_s ** ppsRes ) { AfsSuperBlock_s *const psSuperBlock = psVolume->av_psSuperBlock; const int nBlockSize = psSuperBlock->as_nBlockSize; int nAllocGroup = 0; BIterator_s sIterator; BlockRun_s sInodeNum; off_t nInodeNum; AfsInode_s *psInode; int nError; if( NULL != psParent ) { if( nNameLen <= 0 ) { return( -EINVAL ); } // FIXME: Check if names realy can be B_MAX_KEY_SIZE long(or do we need to subtract 1 like here) if( nNameLen >= B_MAX_KEY_SIZE ) { return( -ENAMETOOLONG ); } if( S_ISDIR( psParent->ai_nMode ) == false ) { printk( "Error: afs_create_inode() parent is not a directory\n" ); return( -ENOTDIR ); } nError = bt_lookup_key( psVolume, psParent, pzName, nNameLen, &sIterator ); if( 1 == nError ) { return( -EEXIST ); } else { if( nError < 0 ) { printk( "Error : afs_create_inode() Failed to search parent for duplicate filenames %d\n", nError ); return( nError ); } } nAllocGroup = psParent->ai_sInodeNum.group + 8; } psInode = kmalloc( nBlockSize, MEMF_KERNEL | MEMF_CLEAR | MEMF_OKTOFAILHACK ); if( psInode == NULL ) { printk( "Error: afs_create_inode() no memory for inode\n" ); return( -ENOMEM ); } nError = afs_alloc_blocks( psVolume, &sInodeNum, NULL, nAllocGroup, 1, 1 ); if( nError < 0 ) { printk( "Error : Failed to alloc space for new inode %d\n", nError ); kfree( psInode ); return( nError ); } nInodeNum = afs_run_to_num( psSuperBlock, &sInodeNum ); memset( psInode, 0, nBlockSize ); psInode->ai_nMagic1 = INODE_MAGIC; psInode->ai_sInodeNum = sInodeNum; psInode->ai_nUID = getfsuid(); psInode->ai_nGID = getfsgid(); psInode->ai_nMode = nMode; psInode->ai_nFlags = nFlags | INF_USED; psInode->ai_nIndexType = nIndexType; atomic_set( &psInode->ai_nLinkCount, 1 ); psInode->ai_nCreateTime = get_real_time(); psInode->ai_nModifiedTime = psInode->ai_nCreateTime; psInode->ai_nInodeSize = nBlockSize; if( psParent != NULL ) { psInode->ai_sParent = psParent->ai_sInodeNum; } if( psParent != NULL ) { nError = bt_insert_key( psVolume, psParent, pzName, nNameLen, nInodeNum ); if( nError < 0 ) { afs_free_blocks( psVolume, &sInodeNum ); printk( "Error : Failed to insert new inode into parent %d\n", nError ); kfree( psInode ); return( nError ); } } nError = afs_logged_write( psVolume, psInode, nInodeNum ); if( nError >= 0 && ppsRes != NULL ) { *ppsRes = psInode; } else { kfree( psInode ); } return( nError ); }