int main() { int i; double libc, fire; struct firedns_state state, *s = &state; firedns_init(s); firedns_add_servers_from_resolv_conf(s); printf("Testing %d firedns_resolveip4list(\"%s\"):\n",TESTS,TEST_HOST); start_time(); for (i = 0; i < TESTS; i++) firedns_resolveip4list(s, TEST_HOST); fire = end_time(); printf("Testing %d gethostbyname(\"%s\"):\n",TESTS,TEST_HOST); start_time(); for (i = 0; i < TESTS; i++) gethostbyname(TEST_HOST); libc = end_time(); if (libc > fire) printf("Speedup: %d%%\n",(int) (((libc - fire) / libc) * 100.0)); else printf("Slowdown: %d%%\n",(int) (((fire - libc) / libc) * 100.0)); return 0; }
/** Return the run start time as given by the 'start_time' or 'run_start' * property. * 'start_time' is tried first, falling back to 'run_start' if the former isn't * found. * @returns The start time of the run * @throws std::runtime_error if neither property is defined */ const Kernel::DateAndTime LogManager::startTime() const { const std::string start_prop("start_time"); if (hasProperty(start_prop)) { try { DateAndTime start_time(getProperty(start_prop)->value()); if (start_time != DateAndTimeHelpers::GPS_EPOCH) { return start_time; } } catch (std::invalid_argument &) { /*Swallow and move on*/ } } const std::string run_start_prop("run_start"); if (hasProperty(run_start_prop)) { try { DateAndTime start_time(getProperty(run_start_prop)->value()); if (start_time != DateAndTimeHelpers::GPS_EPOCH) { return start_time; } } catch (std::invalid_argument &) { /*Swallow and move on*/ } } throw std::runtime_error("No valid start time has been set for this run."); }
void prolongate( int level ) { int i,j; const int prolongation_vars[1] = { VAR_POTENTIAL }; int icell; int num_level_cells; int *level_cells; cart_assert( level >= min_level+1 ); start_time( WORK_TIMER ); select_level( level-1, CELL_TYPE_LOCAL | CELL_TYPE_REFINED, &num_level_cells, &level_cells ); #pragma omp parallel for default(none), private(i,icell,j), shared(num_level_cells,level_cells,cell_vars,cell_child_oct) for ( i = 0; i < num_level_cells; i++ ) { icell = level_cells[i]; for ( j = 0; j < num_children; j++ ) { cell_potential( cell_child(icell,j) ) = cell_interpolate( icell, j, VAR_POTENTIAL ); } } cart_free( level_cells ); end_time( WORK_TIMER ); /* update buffers */ start_time( PROLONGATE_UPDATE_TIMER ); update_buffer_level( level, prolongation_vars, 1 ); end_time( PROLONGATE_UPDATE_TIMER ); }
/* * the main method * receives a Flow message and prints out its associated information * If the message belongs to another class, an exception is thrown. */ virtual void _receive_msg(std::shared_ptr<const Msg>&& m, int /* index */) { if ( m->type() == MSG_ID(Flow) ) { auto flow = static_cast<const Flow *>(m.get()); std::stringstream ss; const FlowKey& fk = flow->key(); int duration = flow->end_time() - flow->start_time(); ss<<"packets="<<flow->packets() << ","; ss<<"bytes="<<flow->bytes() << ","; ss<<"start="<<flow->start_time() << ","; ss<<"end="<<flow->end_time() << ","; ss<<"duration.us="<<duration<< ","; ss<<"source.ip4="<<ip_to_string(fk.src_ip4)<< ","; ss<<"source.port="<<fk.src_port<< ","; ss<<"destination.ip4="<<ip_to_string(fk.dst_ip4)<< ","; ss<<"destination.port="<<fk.dst_port; /* ss<<"Flow of "<< flow->packets() << " packets and "<<flow->bytes()<<" bytes begin at "<<flow->start_time()<<" end at "<<flow->end_time()<< "duration (ms.) "<<duration <<std::endl; ss<<"SRC IP "<<ip_to_string(fk.src_ip4)<<" SRC port "<<fk.src_port<<std::endl; ss<<"DST IP "<<ip_to_string(fk.dst_ip4)<<" DST port "<<fk.dst_port<<std::endl; //ss<<"protocol "<<fk.proto<<std::endl; */ blocklog(ss.str(),log_info); } else { throw std::runtime_error("Flowprinter: wrong message type"); } }
int main(int argc,char *argv[]) { FILE *fp; int nnn[] = { 8, 10, 12, 15, 16, 18, 20, 24, 25, 27, 30, 32, 36, 40, 45, 48, 50, 54, 60, 64, 72, 75, 80, 81, 90, 100 }; #define NNN asize(nnn) int *niter; int i,j,n,nit,ntot,n3; double t,nflop; double *rt,*ct; t_complex ***g; real ***h; snew(rt,NNN); snew(ct,NNN); snew(niter,NNN); for(i=0; (i<NNN); i++) { n = nnn[i]; fprintf(stderr,"\rReal %d ",n); if (n < 16) niter[i] = 100; else if (n < 26) niter[i] = 50; else if (n < 51) niter[i] = 10; else niter[i] = 5; nit = niter[i]; h = mk_rgrid(n+2,n,n); start_time(); for(j=0; (j<nit); j++) { testrft(stdout,h,n,n,n,(j==0)); } update_time(); rt[i] = node_time(); free_rgrid(h,n,n); fprintf(stderr,"\rComplex %d ",n); g = mk_cgrid(n,n,n); start_time(); for(j=0; (j<nit); j++) { testfft(stdout,g,n,n,n,(j==0)); } update_time(); ct[i] = node_time(); free_cgrid(g,n,n); } fprintf(stderr,"\n"); fp=xvgropen("timing.xvg","FFT timings per grid point","n","t (s)"); for(i=0; (i<NNN); i++) { n3 = 2*niter[i]*nnn[i]*nnn[i]*nnn[i]; fprintf(fp,"%10d %10g %10g\n",nnn[i],rt[i]/n3,ct[i]/n3); } gmx_fio_fclose(fp); return 0; }
void compute_accelerations_particles( int level ) { int i, j; double a2half; const int accel_vars[nDim] = { VAR_ACCEL, VAR_ACCEL+1, VAR_ACCEL+2 }; int neighbors[num_neighbors]; int L1, R1; double phi_l, phi_r; int icell; int num_level_cells; int *level_cells; start_time( GRAVITY_TIMER ); start_time( PARTICLE_ACCEL_TIMER ); start_time( WORK_TIMER ); #ifdef COSMOLOGY a2half = -0.5*abox[level]*abox[level]*cell_size_inverse[level]; #else a2half = -0.5 * cell_size_inverse[level]; #endif select_level( level, CELL_TYPE_LOCAL, &num_level_cells, &level_cells ); #pragma omp parallel for default(none), private(icell,j,neighbors,L1,R1,phi_l,phi_r), shared(num_level_cells,level_cells,level,cell_vars,a2half) for ( i = 0; i < num_level_cells; i++ ) { icell = level_cells[i]; cell_all_neighbors( icell, neighbors ); for ( j = 0; j < nDim; j++ ) { L1 = neighbors[2*j]; R1 = neighbors[2*j+1]; if ( cell_level(L1) < level ) { phi_l = 0.8*cell_potential(L1) + 0.2*cell_potential(icell); } else { phi_l = cell_potential(L1); } if ( cell_level(R1) < level ) { phi_r = 0.8*cell_potential(R1)+0.2*cell_potential(icell); } else { phi_r = cell_potential(R1); } cell_accel( icell, j ) = (float)(a2half * ( phi_r - phi_l ) ); } } cart_free( level_cells ); end_time( WORK_TIMER ); /* update accelerations */ start_time( PARTICLE_ACCEL_UPDATE_TIMER ); update_buffer_level( level, accel_vars, nDim ); end_time( PARTICLE_ACCEL_UPDATE_TIMER ); end_time( PARTICLE_ACCEL_TIMER ); end_time( GRAVITY_TIMER ); }
void draw_main() #endif { debugmessage("draw_main",""); start_time(); draw_nodes(); stop_time("draw_main draw_nodes"); start_time(); draw_edges(); stop_time("draw_main draw_edges"); }
void rtOtvetSingleSourceEddingtonTensor(int level) { int i, j, l, index, cell; int num_level_cells, *level_cells; double eps1, eps2, dr2, pos[nDim]; start_time(WORK_TIMER); eps1 = 0.01*cell_size[rtSingleSourceLevel]*cell_size[rtSingleSourceLevel]; eps2 = 9*cell_size[rtSingleSourceLevel]*cell_size[rtSingleSourceLevel]; select_level(level,CELL_TYPE_LOCAL,&num_level_cells,&level_cells); #pragma omp parallel for default(none), private(index,cell,pos,dr2,i,j,l), shared(level,num_level_cells,level_cells,rtSingleSourceValue,rtSingleSourcePos,eps1,eps2,cell_vars) for(index=0; index<num_level_cells; index++) { cell = level_cells[index]; cell_center_position(cell,pos); dr2 = eps1; for(i=0; i<nDim; i++) { pos[i] -= rtSingleSourcePos[i]; if(pos[i] > 0.5*num_grid) pos[i] -= num_grid; if(pos[i] < -0.5*num_grid) pos[i] += num_grid; dr2 += pos[i]*pos[i]; } cell_var(cell,RT_VAR_OT_FIELD) = rtSingleSourceValue/(4*M_PI*dr2); dr2 += nDim*eps2; for(l=j=0; j<nDim; j++) { for(i=0; i<j; i++) { cell_var(cell,rt_et_offset+l++) = pos[i]*pos[j]/dr2; } cell_var(cell,rt_et_offset+l++) = (eps2+pos[j]*pos[j])/dr2; } } cart_free(level_cells); end_time(WORK_TIMER); start_time(RT_SINGLE_SOURCE_UPDATE_TIMER); update_buffer_level(level,rtOtvetETVars,rtNumOtvetETVars); end_time(RT_SINGLE_SOURCE_UPDATE_TIMER); }
// Returns 1 if OK to trash current mine. int SafetyCheck() { int x; if (mine_changed) { stop_time(); x = nm_messagebox( "Warning!", 2, "Cancel", "OK", "You are about to lose work." ); if (x<1) { start_time(); return 0; } start_time(); } return 1; }
void rtInitRun() { #ifdef RT_TEST frt_real Yp = 1.0e-10; #else frt_real Yp = constants->Yp; #endif frt_real Tmin = gas_temperature_floor; frt_real D2GminH2 = rt_dust_to_gas_floor*(constants->Dsun/constants->Zsun); frt_real CluFacH2 = rt_clumping_factor; frt_real CohLenH2 = rt_coherence_length; frt_real fGal = rt_uv_emissivity_stars; frt_real fQSO = rt_uv_emissivity_quasars; frt_intg IPOP = rt_stellar_pop; frt_intg IREC = 0; frt_intg IOUNIT = 81; start_time(WORK_TIMER); frtCall(initrun2)(&Yp,&Tmin,&D2GminH2,&CluFacH2,&CohLenH2,&fGal,&fQSO,&IPOP,&IREC,&IOUNIT); end_time(WORK_TIMER); #ifdef RT_TRANSFER rtInitRunTransfer(); #endif }
void do_mergesort_words(char *w[], int n) { printf("\nmergesort_words:\n"); start_time(); mergesort_words(w, n); print_time(); }
int writeFile(int use, int dsize) { int p; if (largeFile) start_time(); if (useCache) { handle = open(testFile, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); } else { handle = open(testFile, O_WRONLY | O_CREAT | O_TRUNC | O_DIRECT | O_SYNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP| S_IROTH | S_IWOTH); // O_DIRECT | O_SYNC } if (handle == -1) { sprintf(resultchars, " Cannot open %s for writing\n", testFile); return 0; } for (p=0; p<use; p++) { if (write(handle, dataOut, dsize) != dsize ) { sprintf(resultchars," Error writing file %s block %d\n", testFile, p+1); return 0; } } close(handle); if (largeFile) end_time(); return 1; }
int readFile(int use, int dsize) { int p; if (largeFile) start_time(); handle = open(testFile, O_RDONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); if (handle == -1) { sprintf(resultchars, " Cannot open %s for reading\n", testFile); return 0; } for (p=0; p<use; p++) { if (read(handle, dataIn, dsize) == -1) { sprintf(resultchars," Error reading file %s block %d\n", testFile, p+1); return 0; } } close(handle); if (largeFile) end_time(); return 1; }
// update_rate() is called from select_task() while holding a compile queue lock. void AdvancedThresholdPolicy::update_rate(jlong t, methodOop m) { if (is_old(m)) { // We don't remove old methods from the queue, // so we can just zero the rate. m->set_rate(0); return; } // We don't update the rate if we've just came out of a safepoint. // delta_s is the time since last safepoint in milliseconds. jlong delta_s = t - SafepointSynchronize::end_of_last_safepoint(); jlong delta_t = t - (m->prev_time() != 0 ? m->prev_time() : start_time()); // milliseconds since the last measurement // How many events were there since the last time? int event_count = m->invocation_count() + m->backedge_count(); int delta_e = event_count - m->prev_event_count(); // We should be running for at least 1ms. if (delta_s >= TieredRateUpdateMinTime) { // And we must've taken the previous point at least 1ms before. if (delta_t >= TieredRateUpdateMinTime && delta_e > 0) { m->set_prev_time(t); m->set_prev_event_count(event_count); m->set_rate((float)delta_e / (float)delta_t); // Rate is events per millisecond } else if (delta_t > TieredRateUpdateMaxTime && delta_e == 0) { // If nothing happened for 25ms, zero the rate. Don't modify prev values. m->set_rate(0); } } }
bool UpperBodyPlanner::checkTrajectory(const moveit_msgs::RobotTrajectory& input_trajectory, moveit_msgs::RobotTrajectory& output_trajectory) { moveit_msgs::RobotTrajectory check_trajectory = input_trajectory; int input_traj_size = input_trajectory.joint_trajectory.points.size(); if (input_traj_size == 0) { ROS_ERROR("No points in the trajectory."); singularity_check = true; return false; } else if (input_traj_size == 1) { ROS_INFO("1 point in the trajectory."); output_trajectory = check_trajectory; singularity_check = true; return true; } int i = 0; singularity_check = true; while (i < (check_trajectory.joint_trajectory.points.size() - 1)) { //std::cout << "Checking point number is: " << i << std::endl; Eigen::VectorXd front = stdVec2EigenXd(check_trajectory.joint_trajectory.points[i].positions); Eigen::VectorXd back = stdVec2EigenXd(check_trajectory.joint_trajectory.points[i + 1].positions); Eigen::VectorXd difference = front - back; if (difference.norm() == 0) { //std::cout << "The point " << i << " and " << i + 1 << " is too close." << std::endl; //std::cout << "Erase point " << i + 1 << " points" << std::endl; check_trajectory.joint_trajectory.points.erase(check_trajectory.joint_trajectory.points.begin() + (i + 1)); } else { if (difference.norm() >= 0.5) { ROS_WARN("Hit singularity"); singularity_check = false; } i++; } } //double fix_time = check_trajectory.joint_trajectory.points[0].time_from_start.toSec(); double fix_time = path_step / move_velocity; Eigen::VectorXd velocity_cmd = Eigen::VectorXd::Zero(7); double start_t = 0; for (int j = 0; j < check_trajectory.joint_trajectory.points.size(); j++) { if (j == 0) { start_t = start_t + 2 * fix_time; velocity_cmd = Eigen::VectorXd::Zero(7); } else if (j == (check_trajectory.joint_trajectory.points.size() - 1)) { start_t = start_t + 2 * fix_time; velocity_cmd = Eigen::VectorXd::Zero(7); } else { Eigen::VectorXd current_joint_angle = stdVec2EigenXd(check_trajectory.joint_trajectory.points[j + 1].positions); Eigen::VectorXd last_joint_angle = stdVec2EigenXd(check_trajectory.joint_trajectory.points[j].positions); velocity_cmd = (current_joint_angle - last_joint_angle) / fix_time; } start_t = start_t + fix_time; ros::Duration start_time((start_t)); check_trajectory.joint_trajectory.points[j].time_from_start = start_time; check_trajectory.joint_trajectory.points[j].velocities = EigenXd2stdVec(velocity_cmd); } output_trajectory = check_trajectory; return true; }
void HeaderManipulation::inputCB(const topic_tools::ShapeShifter::ConstPtr &input) { ROS_DEBUG("HeaderManipulation inputCB"); ros::Time start_time(ros::Time::now()); // Initialize. if (!output_advertised_) { ROS_INFO("Output not advertised. Setting up publisher now."); ros::AdvertiseOptions opts("output", 1, input->getMD5Sum(), input->getDataType(), input->getMessageDefinition()); boost::mutex::scoped_lock pub_lock(pub_mutex_); generic_pub_ = private_nh_.advertise(opts); output_advertised_ = true; } // Copy shape shifter data to array. uint8_t msg_buffer[input->size()]; ros::serialization::OStream o_stream(msg_buffer, input->size()); input->write(o_stream); // Manipulate (header) data. manipulateRawData(msg_buffer); // Read data from array to StampedMsg boost::shared_ptr<StampedMsg> stamped_msg(new StampedMsg()); stamped_msg->second = start_time; ros::serialization::IStream i_stream(msg_buffer, input->size()); stamped_msg->first.read(i_stream); // Push StampedMsg to Buffer for multithreaded publishing. boost::mutex::scoped_lock buffer_lock(buffer_mutex_); stamped_msg_buffer_.push(stamped_msg); ROS_DEBUG("all done"); }
void init_ga(int num_circles) { char *end_time_str; struct timespec tp1, tp2; int idx; if(_is_initialized) return; printfl(IA_INFO, "initializing for genetic algorithm, this may take some time...."); _is_initialized = true; circle_pool = calloc(GEN_SIZE, sizeof(struct ia_circles *)); start_time(&tp1); for(idx = 0; idx < GEN_SIZE; idx++) { circle_pool[idx] = calloc(1, sizeof(struct ia_circles)); init_circles(circle_pool[idx], num_circles); } for(idx = 0; idx < GEN_SIZE; idx++) { //for(jdx = 0; jdx < 2; jdx++) { // _seed_mutate(&circle_pool[idx]); //} refresh_circles(circle_pool[idx]); sort_circles(circle_pool[idx]); } end_time_str = end_time(&tp1, &tp2, "time"); printfi("%s\nsee, that didn't take too long, did it?\n", end_time_str); free(end_time_str); }
void redbook_first_song_func() { stop_time(); Song_playing = -1; // Playing Redbook tracks will not modify Song_playing. To repeat we must reset this so songs_play_level_song does not think we want to re-play the same song again. songs_play_level_song(1, 0); start_time(); }
int GotoGameScreen() { stop_time(); //@@ init_player_stats(); //@@ //@@ Player_init.pos = Player->pos; //@@ Player_init.orient = Player->orient; //@@ Player_init.segnum = Player->segnum; // -- must always save gamesave.sav because the restore-objects code relies on it // -- that code could be made smarter and use the original file, if appropriate. // if (mine_changed) if (gamestate_not_restored == 0) { gamestate_not_restored = 1; save_level("GAMESAVE.LVL"); editor_status("Gamestate saved.\n"); } ai_reset_all_paths(); start_time(); ModeFlag = 3; return 1; }
void save_screen_shot(int automap_flag) { static int savenum=0; char savename[13+sizeof(SCRNS_DIR)]; unsigned char *buf; if (!GameArg.DbgGlReadPixelsOk){ if (!automap_flag) HUD_init_message_literal(HM_DEFAULT, "glReadPixels not supported on your configuration"); return; } stop_time(); if (!PHYSFSX_exists(SCRNS_DIR,0)) PHYSFS_mkdir(SCRNS_DIR); //try making directory do { sprintf(savename, "%sscrn%04d.tga",SCRNS_DIR, savenum++); } while (PHYSFSX_exists(savename,0)); if (!automap_flag) HUD_init_message(HM_DEFAULT, "%s 'scrn%04d.tga'", TXT_DUMPING_SCREEN, savenum-1 ); #ifndef OGLES glReadBuffer(GL_FRONT); #endif buf = d_malloc(grd_curscreen->sc_w*grd_curscreen->sc_h*3); write_bmp(savename,grd_curscreen->sc_w,grd_curscreen->sc_h,buf); d_free(buf); start_time(); }
static int handle_call_after(struct task *task, struct breakpoint *bp) { struct timespec start; (void)bp; if (!task->breakpoint) return 0; if (unlikely(options.verbose > 1)) start_time(&start); #if HW_BREAKPOINTS > 0 disable_scratch_hw_bp(task, bp); #endif if (task->libsym->func->report_out) task->libsym->func->report_out(task, task->libsym); if (unlikely(options.verbose > 1)) set_timer(&start, &report_out_time); task->breakpoint = NULL; task->libsym = NULL; return 0; }
int state_save_all(int between_levels) { char filename[128], desc[DESC_LENGTH+1]; if ( Game_mode & GM_MULTI ) { #ifdef MULTI_SAVE if ( FindArg( "-multisave" ) ) multi_initiate_save_game(); else #endif HUD_init_message( "Can't save in a multiplayer game!" ); return 0; } mprintf(( 0, "CL=%d, NL=%d\n", Current_level_num, Next_level_num )); stop_time(); if (!state_get_save_file(filename,desc,0)) { start_time(); return 0; } return state_save_all_sub(filename, desc, between_levels); }
void writeGeotiff() { ros::Time start_time (ros::Time::now()); std::stringstream ssStream; nav_msgs::GetMap srv_map; if (map_service_client_.call(srv_map)) { ROS_INFO("GeotiffNode: Map service called successfully"); const nav_msgs::OccupancyGrid& map (srv_map.response.map); std::string map_file_name = p_map_file_base_name_; std::string competition_name; std::string team_name; std::string mission_name; std::string postfix; if (n_.getParamCached("/competition", competition_name) && !competition_name.empty()) map_file_name = map_file_name + "_" + competition_name; if (n_.getParamCached("/team", team_name) && !team_name.empty()) map_file_name = map_file_name + "_" + team_name; if (n_.getParamCached("/mission", mission_name) && !mission_name.empty()) map_file_name = map_file_name + "_" + mission_name; if (pn_.getParamCached("map_file_postfix", postfix) && !postfix.empty()) map_file_name = map_file_name + "_" + postfix; if (map_file_name.substr(0, 1) == "_") map_file_name = map_file_name.substr(1); if (map_file_name.empty()) map_file_name = "GeoTiffMap"; geotiff_writer_.setMapFileName(map_file_name); bool transformSuccess = geotiff_writer_.setupTransforms(map); if(!transformSuccess){ ROS_INFO("Couldn't set map transform"); return; } geotiff_writer_.setupImageSize(); if (p_draw_background_checkerboard_){ geotiff_writer_.drawBackgroundCheckerboard(); } geotiff_writer_.drawMap(map, p_draw_free_space_grid_); geotiff_writer_.drawCoords(); //ROS_INFO("Sum: %ld", (long int)srv.response.sum); } else { ROS_ERROR("Failed to call map service"); return; } for (size_t i = 0; i < plugin_vector_.size(); ++i){ plugin_vector_[i]->draw(&geotiff_writer_); } geotiff_writer_.writeGeotiffImage(); running_saved_map_num_++; ros::Duration elapsed_time (ros::Time::now() - start_time); ROS_INFO("GeoTiff created in %f seconds", elapsed_time.toSec()); }
void rtInitStep(double dt) { frt_real uDen = units->number_density; frt_real uLen = units->length; frt_real uTime = units->time; frt_real dtCode = dt; #ifdef COSMOLOGY frt_real aExp = abox[min_level]; frt_real daExp = abox_from_tcode(tl[min_level]+dt) - abox[min_level]; frt_real HExp = Hubble(aExp)/units->time; #else frt_real aExp = 1.0; frt_real daExp = 0.0; frt_real HExp = 0.0; #endif start_time(WORK_TIMER); frtCall(stepbegin)(&uDen,&uLen,&uTime,&aExp,&HExp,&daExp,&dtCode); end_time(WORK_TIMER); #ifdef RT_TRANSFER rtInitStepTransfer(); #endif rtUpdateTables(); #ifdef RT_DEBUG switch(rt_debug.Mode) { case 1: { int i, cell; cell = cell_find_position(rt_debug.Pos); cart_debug("In cell-level debug for cell %d/%d",cell,cell_level(cell)); cart_debug("RT_HVAR_OFFSET: %d",RT_HVAR_OFFSET); #ifdef RT_VAR_SOURCE cart_debug("RT_VAR_SOURCE: %d",RT_VAR_SOURCE); #endif cart_debug("rt_grav_vars_offset: %d",rt_grav_vars_offset); #ifdef RT_TRANSFER cart_debug("rt_num_vars: %d",rt_num_vars); #if (RT_TRANSFER_METHOD == RT_METHOD_OTVET) cart_debug("RT_VAR_OT_FIELD: %d",RT_VAR_OT_FIELD); cart_debug("rt_et_offset: %d",rt_et_offset); cart_debug("rt_field_offset: %d",rt_field_offset); #endif #endif for(i=0; i<num_vars; i++) { cart_debug("Var[%d] = %g",i,cell_var(cell,i)); } break; } } #endif /* RT_DEBUG */ }
TEST_F(SemaphoreTest, timedwait) { semaphore->post(); ASSERT_TRUE(semaphore->timedwait(0.1)); Time start_time(Time::now()); semaphore->timedwait(0.1); Time elapsed_time(Time::now() - start_time); ASSERT_GE(elapsed_time, Time(0.1)); }
void timer_start(int np) { int n = np; start_time(n) = RCCE_wtime(); return; }
void Control::initTime() { QSqlQuery query; QDateTime start_date_time; query.exec("select min(DATE),min(TIME) from DATAS"); if(query.next()){ int min_date = query.value(0).toInt(); int min_time = query.value(1).toInt(); int year = min_date / 10000; int month = min_date % 10000 / 100; int day = min_date % 100; int h = min_time / 10000; QTime start_time(h,0); QDate start_date(2000 +year,month,day); start_date_time = QDateTime(start_date,start_time); } query.exec("select max(DATE),max(TIME) from DATAS"); QDateTime end_date_time; if(query.next()){ int max_date = query.value(0).toInt(); int max_time = query.value(1).toInt(); int year = max_date / 10000; int month = max_date % 10000 / 100; int day = max_date % 100; int h = max_time / 10000; QTime end_time(h,0); QDate end_date(2000 +year,month,day); end_date_time = QDateTime(end_date,end_time); } ui->startDateTimeEdit->setDisplayFormat("yyyy-M-d HH"); ui->endDateTimeEdit->setDisplayFormat("yyyy-M-d HH"); ui->startDateTimeEdit->setMinimumDateTime(start_date_time); ui->startDateTimeEdit->setMaximumDateTime(end_date_time); ui->endDateTimeEdit->setMinimumDateTime(start_date_time); ui->endDateTimeEdit->setMaximumDateTime(end_date_time); ui->startDateTimeEdit_2->setDisplayFormat("yyyy-M-d HH"); ui->endDateTimeEdit_2->setDisplayFormat("yyyy-M-d HH"); ui->startDateTimeEdit_2->setMinimumDateTime(start_date_time); ui->startDateTimeEdit_2->setMaximumDateTime(end_date_time); ui->endDateTimeEdit_2->setMinimumDateTime(start_date_time); ui->endDateTimeEdit_2->setMaximumDateTime(end_date_time); ui->startDateTimeEdit_3->setDisplayFormat("yyyy-M-d HH"); ui->endDateTimeEdit_3->setDisplayFormat("yyyy-M-d HH"); ui->startDateTimeEdit_3->setMinimumDateTime(start_date_time); ui->startDateTimeEdit_3->setMaximumDateTime(end_date_time); ui->endDateTimeEdit_3->setMinimumDateTime(start_date_time); ui->endDateTimeEdit_3->setMaximumDateTime(end_date_time); ui->startDateTimeEdit_4->setDisplayFormat("yyyy-M-d HH"); ui->endDateTimeEdit_4->setDisplayFormat("yyyy-M-d HH"); ui->startDateTimeEdit_4->setMinimumDateTime(start_date_time); ui->startDateTimeEdit_4->setMaximumDateTime(end_date_time); ui->endDateTimeEdit_4->setMinimumDateTime(start_date_time); ui->endDateTimeEdit_4->setMaximumDateTime(end_date_time); }
void joy_delay() { stop_time(); // timer_delay(.25); delay(250); // changed by allender because 1) more portable // 2) was totally broken on PC joy_flush(); start_time(); }
void rtAfterAssignDensity2(int level, int num_level_cells, int *level_cells) { start_time(RT_AFTER_DENSITY_TIMER); #ifdef RT_TRANSFER rtAfterAssignDensityTransfer(level,num_level_cells,level_cells); #endif end_time(RT_AFTER_DENSITY_TIMER); }
void sort(int **a, int n_piv) { int i; start_time(); printf("Quicksorting ...\n"); for (i = 0; i < N_ARR; ++i) { quicksort(a[i], a[i] + N_ELEM - 1, n_piv); } print_time(); }