void JobInfoCommunicator::startUpdateTimer( void ) { if( m_periodic_job_update_tid >= 0 ) { // already registered the timer... return; } Timeslice interval; // default interval is 5 minutes, with 8 seconds as the initial value. interval.setDefaultInterval( param_integer( "STARTER_UPDATE_INTERVAL", 300, 0 ) ); interval.setTimeslice( param_double( "STARTER_UPDATE_INTERVAL_TIMESLICE", 0.1, 0, 1 ) ); interval.setInitialInterval( param_integer( "STARTER_INITIAL_UPDATE_INTERVAL", 8 ) ); if( interval.getDefaultInterval() < interval.getInitialInterval() ) { interval.setInitialInterval( interval.getDefaultInterval() ); } m_periodic_job_update_tid = daemonCore-> Register_Timer(interval, (TimerHandlercpp)&JobInfoCommunicator::periodicJobUpdateTimerHandler, "JobInfoCommunicator::periodicJobUpdateTimerHandler", this); if( m_periodic_job_update_tid < 0 ) { EXCEPT( "Can't register DC Timer!" ); } }
void AvailStats::compute( amask_t how_much ) { if( !compute_avail_stats ) return; if( IS_STATIC(how_much) && IS_SHARED(how_much) ) { as_avail_confidence = param_double("STARTD_AVAIL_CONFIDENCE", as_avail_confidence, 0, 1); as_max_avail_periods = param_integer("STARTD_MAX_AVAIL_PERIOD_SAMPLES", as_max_avail_periods); } if( IS_UPDATE(how_much) && IS_SHARED(how_much) ) { time_t current_time = time(0); // only compute avail time estimate if we're in non-owner state if( as_start_avail ) { // first, skip over intervals less than our idle time so far int current_idle_time = current_time - as_start_avail; int num_intervals = as_num_avail_periods; as_avail_periods.Rewind(); int item = 0; as_avail_periods.Next(item); while( num_intervals && item < current_idle_time ) { as_avail_periods.Next(item); num_intervals--; } if( !num_intervals ) { // If this is the longest we've ever been idle, our // historical data isn't too useful to us, so give an // estimate based on how long we've been idle so far. as_avail_estimate = (int)floor(current_idle_time*(2.0-as_avail_confidence)); } else { // Otherwise, find the record in our history at the // requested confidence level. int idx = (int)floor(num_intervals*(1.0-as_avail_confidence)); while( idx ) { as_avail_periods.Next(item); idx--; } as_avail_estimate = item; } as_avail_time = float(as_tot_avail_time + current_idle_time) / float(current_time - as_birthdate); } else { as_avail_time = float(as_tot_avail_time) / float(current_time - as_birthdate); } } }
void BaseShadow::config() { reconnect_ceiling = param_integer( "RECONNECT_BACKOFF_CEILING", 300 ); reconnect_e_factor = 0.0; reconnect_e_factor = param_double( "RECONNECT_BACKOFF_FACTOR", 2.0, 0.0 ); if( reconnect_e_factor < -1e-4 || reconnect_e_factor > 1e-4) { reconnect_e_factor = 2.0; } m_cleanup_retry_tid = -1; m_num_cleanup_retries = 0; // NOTE: these config knobs are very similar to // LOCAL_UNIVERSE_MAX_JOB_CLEANUP_RETRIES and // LOCAL_UNIVERSE_JOB_CLEANUP_RETRY_DELAY in the local starter. m_max_cleanup_retries = param_integer("SHADOW_MAX_JOB_CLEANUP_RETRIES", 5); m_cleanup_retry_delay = param_integer("SHADOW_JOB_CLEANUP_RETRY_DELAY", 30); m_lazy_queue_update = param_boolean("SHADOW_LAZY_QUEUE_UPDATE", true); }
void BaseShadow::config() { if (spool) free(spool); spool = param("SPOOL"); if (!spool) { EXCEPT("SPOOL not specified in config file."); } if (fsDomain) free(fsDomain); fsDomain = param( "FILESYSTEM_DOMAIN" ); if (!fsDomain) { EXCEPT("FILESYSTEM_DOMAIN not specified in config file."); } if (uidDomain) free(uidDomain); uidDomain = param( "UID_DOMAIN" ); if (!uidDomain) { EXCEPT("UID_DOMAIN not specified in config file."); } reconnect_ceiling = param_integer( "RECONNECT_BACKOFF_CEILING", 300 ); reconnect_e_factor = 0.0; reconnect_e_factor = param_double( "RECONNECT_BACKOFF_FACTOR", 2.0, 0.0 ); if( reconnect_e_factor < -1e-4 || reconnect_e_factor > 1e-4) { reconnect_e_factor = 2.0; } m_cleanup_retry_tid = -1; m_num_cleanup_retries = 0; // NOTE: these config knobs are very similar to // LOCAL_UNIVERSE_MAX_JOB_CLEANUP_RETRIES and // LOCAL_UNIVERSE_JOB_CLEANUP_RETRY_DELAY in the local starter. m_max_cleanup_retries = param_integer("SHADOW_MAX_JOB_CLEANUP_RETRIES", 5); m_cleanup_retry_delay = param_integer("SHADOW_JOB_CLEANUP_RETRY_DELAY", 30); m_lazy_queue_update = param_boolean("SHADOW_LAZY_QUEUE_UPDATE", true); }
void Defrag::config() { ASSERT( param(m_state_file,"DEFRAG_STATE_FILE") ); if( m_last_poll==0 ) { loadState(); } int old_polling_interval = m_polling_interval; m_polling_interval = param_integer("DEFRAG_INTERVAL",600); if( m_polling_interval <= 0 ) { dprintf(D_ALWAYS, "DEFRAG_INTERVAL=%d, so no pool defragmentation " "will be done.\n", m_polling_interval); if( m_polling_timer != -1 ) { daemonCore->Cancel_Timer(m_polling_timer); m_polling_timer = -1; } } else if( m_polling_timer >= 0 ) { if( old_polling_interval != m_polling_interval ) { daemonCore->Reset_Timer_Period( m_polling_timer, m_polling_interval); } } else { time_t now = time(NULL); int first_time = 0; if( m_last_poll != 0 && now-m_last_poll < m_polling_interval && m_last_poll <= now ) { first_time = m_polling_interval - (now-m_last_poll); } m_polling_timer = daemonCore->Register_Timer( first_time, m_polling_interval, (TimerHandlercpp)&Defrag::poll, "Defrag::poll", this ); } if( old_polling_interval != m_polling_interval && m_polling_interval > 0 ) { dprintf(D_ALWAYS, "Will evaluate defragmentation policy every DEFRAG_INTERVAL=" "%d seconds.\n", m_polling_interval); } m_draining_per_hour = param_double("DEFRAG_DRAINING_MACHINES_PER_HOUR",0,0); double rate = m_draining_per_hour/3600.0*m_polling_interval; m_draining_per_poll = (int)floor(rate + 0.00001); if( m_draining_per_poll < 0 ) m_draining_per_poll = 0; double error_per_hour = (rate - m_draining_per_poll)/m_polling_interval*3600.0; m_draining_per_poll_hour = (int)floor(error_per_hour + 0.00001); if( m_draining_per_hour < 0 || m_polling_interval > 3600 ) { m_draining_per_hour = 0; } double error_per_day = (error_per_hour - m_draining_per_poll_hour)*24.0; m_draining_per_poll_day = (int)floor(error_per_day + 0.5); if( m_draining_per_poll_day < 0 || m_polling_interval > 3600*24 ) { m_draining_per_poll_day = 0; } dprintf(D_ALWAYS,"polling interval %ds, DEFRAG_DRAINING_MACHINES_PER_HOUR = %f/hour = %d/interval + %d/hour + %d/day\n", m_polling_interval,m_draining_per_hour,m_draining_per_poll, m_draining_per_poll_hour,m_draining_per_poll_day); m_max_draining = param_integer("DEFRAG_MAX_CONCURRENT_DRAINING",-1,-1); m_max_whole_machines = param_integer("DEFRAG_MAX_WHOLE_MACHINES",-1,-1); ASSERT( param(m_defrag_requirements,"DEFRAG_REQUIREMENTS") ); validateExpr( m_defrag_requirements.c_str(), "DEFRAG_REQUIREMENTS" ); ASSERT( param(m_whole_machine_expr,"DEFRAG_WHOLE_MACHINE_EXPR") ); validateExpr( m_whole_machine_expr.c_str(), "DEFRAG_WHOLE_MACHINE_EXPR" ); ASSERT( param(m_draining_schedule_str,"DEFRAG_DRAINING_SCHEDULE") ); if( m_draining_schedule_str.empty() ) { m_draining_schedule = DRAIN_GRACEFUL; m_draining_schedule_str = "graceful"; } else { m_draining_schedule = getDrainingScheduleNum(m_draining_schedule_str.c_str()); if( m_draining_schedule < 0 ) { EXCEPT("Invalid draining schedule: %s\n",m_draining_schedule_str.c_str()); } } MyString rank; param(rank,"DEFRAG_RANK"); if( rank.IsEmpty() ) { m_rank_ad.Delete(ATTR_RANK); } else { if( !m_rank_ad.AssignExpr(ATTR_RANK,rank.Value()) ) { EXCEPT("Invalid expression for DEFRAG_RANK: %s\n", rank.Value()); } } int update_interval = param_integer("DEFRAG_UPDATE_INTERVAL", 600); if(m_public_ad_update_interval != update_interval) { m_public_ad_update_interval = update_interval; dprintf(D_FULLDEBUG, "Setting update interval to %d\n", m_public_ad_update_interval); if(m_public_ad_update_timer >= 0) { daemonCore->Reset_Timer_Period( m_public_ad_update_timer, m_public_ad_update_interval); } else { m_public_ad_update_timer = daemonCore->Register_Timer( 0, m_public_ad_update_interval, (TimerHandlercpp)&Defrag::updateCollector, "Defrag::updateCollector", this); } } if (param(m_cancel_requirements, "DEFRAG_CANCEL_REQUIREMENTS")) { validateExpr( m_cancel_requirements.c_str(), "DEFRAG_CANCEL_REQUIREMENTS" ); } else { m_cancel_requirements = ""; } param(m_defrag_name,"DEFRAG_NAME"); int stats_quantum = m_polling_interval; int stats_window = 10*stats_quantum; m_stats.SetWindowSize(stats_window,stats_quantum); }
void init_params() { char *tmp; static int master_name_in_config = 0; if( ! master_name_in_config ) { // First time, or we know it's not in the config file. if( ! MasterName ) { // Not set on command line tmp = param( "MASTER_NAME" ); if( tmp ) { MasterName = build_valid_daemon_name( tmp ); master_name_in_config = 1; free( tmp ); } } } else { delete [] MasterName; tmp = param( "MASTER_NAME" ); MasterName = build_valid_daemon_name( tmp ); free( tmp ); } if( MasterName ) { dprintf( D_FULLDEBUG, "Using name: %s\n", MasterName ); } if (!param_boolean_crufty("START_MASTER", true)) { dprintf( D_ALWAYS, "START_MASTER was set to FALSE, shutting down.\n" ); StartDaemons = FALSE; main_shutdown_graceful(); } StartDaemons = TRUE; if (!param_boolean_crufty("START_DAEMONS", true)) { dprintf( D_ALWAYS, "START_DAEMONS flag was set to FALSE. Not starting daemons.\n" ); StartDaemons = FALSE; } // If we were sent the daemons_off command, don't forget that // here. if( GotDaemonsOff ) { StartDaemons = FALSE; } PublishObituaries = param_boolean_crufty("PUBLISH_OBITUARIES", true) ? TRUE : FALSE; Lines = param_integer("OBITUARY_LOG_LENGTH",20); master_backoff_constant = param_integer( "MASTER_BACKOFF_CONSTANT", 9, 1 ); master_backoff_ceiling = param_integer( "MASTER_BACKOFF_CEILING", 3600,1 ); master_backoff_factor = param_double( "MASTER_BACKOFF_FACTOR", 2.0, 0 ); if( master_backoff_factor <= 0.0 ) { master_backoff_factor = 2.0; } master_recover_time = param_integer( "MASTER_RECOVER_FACTOR", 300, 1 ); update_interval = param_integer( "MASTER_UPDATE_INTERVAL", 5 * MINUTE, 1 ); check_new_exec_interval = param_integer( "MASTER_CHECK_NEW_EXEC_INTERVAL", 5*MINUTE ); new_bin_delay = param_integer( "MASTER_NEW_BINARY_DELAY", 2*MINUTE, 1 ); new_bin_restart_mode = GRACEFUL; char * restart_mode = param("MASTER_NEW_BINARY_RESTART"); if (restart_mode) { #if 1 StopStateT mode = StringToStopState(restart_mode); #else static const struct { const char * text; StopStateT mode; } modes[] = { { "GRACEFUL", GRACEFUL }, { "PEACEFUL", PEACEFUL }, { "NEVER", NONE }, { "NONE", NONE }, { "NO", NONE }, // { "FAST", FAST }, // { "KILL", KILL }, }; StopStateT mode = (StopStateT)-1; // prime with -1 so we can detect bad input. for (int ii = 0; ii < (int)COUNTOF(modes); ++ii) { if (MATCH == strcasecmp(restart_mode, modes[ii].text)) { mode = modes[ii].mode; break; } } #endif if (mode == (StopStateT)-1) { dprintf(D_ALWAYS, "%s is not a valid value for MASTER_NEW_BINARY_RESTART. using GRACEFUL\n", restart_mode); } if (mode >= 0 && mode <= NONE) new_bin_restart_mode = mode; free(restart_mode); } preen_interval = param_integer( "PREEN_INTERVAL", 24*HOUR, 0 ); if(preen_interval == 0) { EXCEPT("PREEN_INTERVAL in the condor configuration is too low (0). Please set it to an integer in the range 1 to %d (default %d). To disable condor_preen entirely, comment out PREEN.", INT_MAX, 24*HOUR); } shutdown_fast_timeout = param_integer( "SHUTDOWN_FAST_TIMEOUT", 5*MINUTE, 1 ); shutdown_graceful_timeout = param_integer( "SHUTDOWN_GRACEFUL_TIMEOUT", 30*MINUTE, 1 ); AllowAdminCommands = param_boolean( "ALLOW_ADMIN_COMMANDS", true ); if( FS_Preen ) { free( FS_Preen ); } FS_Preen = param( "PREEN" ); }
void CCBServer::InitAndReconfig() { // construct the CCB address to be advertised by CCB listeners Sinful sinful(daemonCore->publicNetworkIpAddr()); // strip out <>'s, private address, and CCB listener info sinful.setPrivateAddr(NULL); sinful.setCCBContact(NULL); ASSERT( sinful.getSinful() && sinful.getSinful()[0] == '<' ); m_address.formatstr("%s",sinful.getSinful()+1); if( m_address[m_address.Length()-1] == '>' ) { m_address.setChar(m_address.Length()-1,'\0'); } m_read_buffer_size = param_integer("CCB_SERVER_READ_BUFFER",2*1024); m_write_buffer_size = param_integer("CCB_SERVER_WRITE_BUFFER",2*1024); m_last_reconnect_info_sweep = time(NULL); m_reconnect_info_sweep_interval = param_integer("CCB_SWEEP_INTERVAL",1200); CloseReconnectFile(); MyString old_reconnect_fname = m_reconnect_fname; char *fname = param("CCB_RECONNECT_FILE"); if( fname ) { m_reconnect_fname = fname; if( m_reconnect_fname.find(".ccb_reconnect") == -1 ) { // required for preen to ignore this file m_reconnect_fname += ".ccb_reconnect"; } free( fname ); } else { char *spool = param("SPOOL"); ASSERT( spool ); Sinful my_addr( daemonCore->publicNetworkIpAddr() ); m_reconnect_fname.formatstr("%s%c%s-%s.ccb_reconnect", spool, DIR_DELIM_CHAR, my_addr.getHost() ? my_addr.getHost() : "localhost", my_addr.getPort() ? my_addr.getPort() : "0"); free( spool ); } if( old_reconnect_fname != m_reconnect_fname && !old_reconnect_fname.IsEmpty() && !m_reconnect_fname.IsEmpty() ) { // reconnect filename changed // not worth freaking out on error here remove( m_reconnect_fname.Value() ); rename( old_reconnect_fname.Value(), m_reconnect_fname.Value() ); } if( old_reconnect_fname.IsEmpty() && !m_reconnect_fname.IsEmpty() && m_reconnect_info.getNumElements() == 0 ) { // we are starting up from scratch, so load saved info LoadReconnectInfo(); } Timeslice poll_slice; poll_slice.setTimeslice( // do not run more than this fraction of the time param_double("CCB_POLLING_TIMESLICE",0.05) ); poll_slice.setDefaultInterval( // try to run this often param_integer("CCB_POLLING_INTERVAL",20,0) ); poll_slice.setMaxInterval( // run at least this often param_integer("CCB_POLLING_MAX_INTERVAL",600) ); if( m_polling_timer != -1 ) { daemonCore->Cancel_Timer(m_polling_timer); } m_polling_timer = daemonCore->Register_Timer( poll_slice, (TimerHandlercpp)&CCBServer::PollSockets, "CCBServer::PollSockets", this); RegisterHandlers(); }
/* * Beginning-of-function code: * * 'sp' is an array of indices in symtab for the arguments * 'cnt' is the number of arguments */ void bfcode(struct symtab **sp, int cnt) { union arglist *usym; int saveallargs = 0; int i, argofs = 0; /* * Detect if this function has ellipses and save all * argument registers onto stack. */ usym = cftnsp->sdf->dfun; while (usym && usym->type != TNULL) { if (usym->type == TELLIPSIS) { saveallargs = 1; break; } ++usym; } /* if returning a structure, move the hidden argument into a TEMP */ if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) { param_retstruct(); ++argofs; } /* recalculate the arg offset and create TEMP moves */ for (i = 0; i < cnt; i++) { if (sp[i] == NULL) continue; if ((argofs >= NARGREGS) && !xtemps) break; if (argofs > NARGREGS) { putintemp(sp[i]); } else if (sp[i]->stype == STRTY || sp[i]->stype == UNIONTY) { param_struct(sp[i], &argofs); } else if (DEUNSIGN(sp[i]->stype) == LONGLONG) { param_64bit(sp[i], &argofs, xtemps && !saveallargs); } else if (sp[i]->stype == DOUBLE || sp[i]->stype == LDOUBLE) { if (features(FEATURE_HARDFLOAT)) param_double(sp[i], &argofs, xtemps && !saveallargs); else param_64bit(sp[i], &argofs, xtemps && !saveallargs); } else if (sp[i]->stype == FLOAT) { if (features(FEATURE_HARDFLOAT)) param_float(sp[i], &argofs, xtemps && !saveallargs); else param_32bit(sp[i], &argofs, xtemps && !saveallargs); } else { param_32bit(sp[i], &argofs, xtemps && !saveallargs); } } /* if saveallargs, save the rest of the args onto the stack */ while (saveallargs && argofs < NARGREGS) { NODE *p, *q; int off = ARGINIT/SZINT + argofs; q = block(REG, NIL, NIL, INT, 0, 0); regno(q) = R0 + argofs++; p = block(REG, NIL, NIL, INT, 0, 0); regno(p) = FPREG; p = block(PLUS, p, bcon(4*off), INT, 0, 0); p = block(UMUL, p, NIL, INT, 0, 0); p = buildtree(ASSIGN, p, q); ecomp(p); } }
/* * code for the beginning of a function; a is an array of * indices in symtab for the arguments; n is the number */ void bfcode(struct symtab **sp, int cnt) { union arglist *usym; int lastreg = A0 + nargregs - 1; int saveallargs = 0; int i, reg; /* * Detect if this function has ellipses and save all * argument register onto stack. */ usym = cftnsp->sdf->dfun; while (usym && usym->type != TNULL) { if (usym->type == TELLIPSIS) { saveallargs = 1; break; } ++usym; } reg = A0; /* assign hidden return structure to temporary */ if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) { param_retptr(); ++reg; } /* recalculate the arg offset and create TEMP moves */ for (i = 0; i < cnt; i++) { if ((reg > lastreg) && !xtemps) break; else if (reg > lastreg) putintemp(sp[i]); else if (sp[i]->stype == STRTY || sp[i]->stype == UNIONTY) param_struct(sp[i], ®); else if (DEUNSIGN(sp[i]->stype) == LONGLONG) param_64bit(sp[i], ®, xtemps && !saveallargs); else if (sp[i]->stype == DOUBLE || sp[i]->stype == LDOUBLE) param_double(sp[i], ®, xtemps && !saveallargs); else if (sp[i]->stype == FLOAT) param_float(sp[i], ®, xtemps && !saveallargs); else param_32bit(sp[i], ®, xtemps && !saveallargs); } /* if saveallargs, save the rest of the args onto the stack */ if (!saveallargs) return; while (reg <= lastreg) { NODE *p, *q; int off = ARGINIT/SZINT + (reg - A0); q = block(REG, NIL, NIL, INT, 0, 0); q->n_rval = reg++; p = block(REG, NIL, NIL, INT, 0, 0); p->n_rval = FP; p = block(PLUS, p, bcon(4*off), INT, 0, 0); p = block(UMUL, p, NIL, INT, 0, 0); p = buildtree(ASSIGN, p, q); ecomp(p); } }