static void *_watch_tasks(void *arg) { /* Give chance for processes to spawn before starting * the polling. This should largely eliminate the * the chance of having /proc open when the tasks are * spawned, which would prevent a valid checkpoint/restart * with some systems */ _task_sleep(1); while(!jobacct_shutdown) { /* Do this until shutdown is requested */ if(!jobacct_suspended) { _get_process_data(); /* Update the data */ } _task_sleep(freq); } return NULL; }
static void *_thread_launcher(void *no_data) { //what arg would countain? frequency, socket? pthread_attr_t attr_run; time_t begin_time; int rc = SLURM_SUCCESS; slurm_attr_init(&attr_run); if (pthread_create(&thread_ipmi_id_run, &attr_run, &_thread_ipmi_run, NULL)) { //if (pthread_create(... (void *)arg)) { debug("energy accounting failed to create _thread_ipmi_run " "thread: %m"); } slurm_attr_destroy(&attr_run); begin_time = time(NULL); while (rc == SLURM_SUCCESS) { if (time(NULL) - begin_time > slurm_ipmi_conf.timeout) { error("ipmi thread init timeout"); rc = SLURM_ERROR; break; } if (flag_thread_started) break; _task_sleep(1); } if (rc != SLURM_SUCCESS) { error("%s threads failed to start in a timely manner", plugin_name); if (thread_ipmi_id_run) { pthread_cancel(thread_ipmi_id_run); pthread_join(thread_ipmi_id_run, NULL); } flag_energy_accounting_shutdown = true; } else { /* This is here to join the decay thread so we don't core * dump if in the sleep, since there is no other place to join * we have to create another thread to do it. */ slurm_attr_init(&attr_run); if (pthread_create(&cleanup_handler_thread, &attr_run, _cleanup_thread, NULL)) fatal("pthread_create error %m"); slurm_attr_destroy(&attr_run); } return NULL; }
extern jobacctinfo_t *jobacct_gather_stat_task(pid_t pid) { if (!plugin_polling || _jobacct_shutdown_test()) return NULL; else if (pid) { struct jobacctinfo *jobacct = NULL; struct jobacctinfo *ret_jobacct = NULL; ListIterator itr = NULL; _poll_data(0); slurm_mutex_lock(&task_list_lock); if (!task_list) { error("no task list created!"); goto error; } itr = list_iterator_create(task_list); while ((jobacct = list_next(itr))) { if (jobacct->pid == pid) break; } list_iterator_destroy(itr); if (jobacct == NULL) goto error; ret_jobacct = xmalloc(sizeof(struct jobacctinfo)); memcpy(ret_jobacct, jobacct, sizeof(struct jobacctinfo)); error: slurm_mutex_unlock(&task_list_lock); return ret_jobacct; } else { /* In this situation, we are just trying to get a * basis of information since we are not pollng. So * we will give a chance for processes to spawn before we * gather information. This should largely eliminate the * the chance of having /proc open when the tasks are * spawned, which would prevent a valid checkpoint/restart * with some systems */ _task_sleep(1); _poll_data(0); return NULL; } }
extern struct jobacctinfo *jobacct_gather_p_stat_task(pid_t pid) { if (jobacct_shutdown) return NULL; else if(pid) { _get_process_data(); return jobacct_common_stat_task(pid, task_list); } else { /* In this situation, we are just trying to get a * basis of information since we are not pollng. So * we will give a chance for processes to spawn before we * gather information. This should largely eliminate the * the chance of having /proc open when the tasks are * spawned, which would prevent a valid checkpoint/restart * with some systems */ _task_sleep(1); _get_process_data(); return NULL; } }
static void *_watch_tasks(void *arg) { int type = PROFILE_TASK; /* Give chance for processes to spawn before starting * the polling. This should largely eliminate the * the chance of having /proc open when the tasks are * spawned, which would prevent a valid checkpoint/restart * with some systems */ _task_sleep(1); while (!jobacct_shutdown && acct_gather_profile_running) { /* Do this until shutdown is requested */ _poll_data(); slurm_mutex_lock(&acct_gather_profile_timer[type].notify_mutex); pthread_cond_wait( &acct_gather_profile_timer[type].notify, &acct_gather_profile_timer[type].notify_mutex); slurm_mutex_unlock(&acct_gather_profile_timer[type]. notify_mutex); } return NULL; }
/* * _thread_ipmi_run is the thread calling ipmi and launching _thread_ipmi_write */ static void *_thread_ipmi_run(void *no_data) { // need input (attr) int time_lost; (void) pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); (void) pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); flag_energy_accounting_shutdown = false; if (debug_flags & DEBUG_FLAG_ENERGY) info("ipmi-thread: launched"); slurm_mutex_lock(&ipmi_mutex); if (_thread_init() != SLURM_SUCCESS) { if (debug_flags & DEBUG_FLAG_ENERGY) info("ipmi-thread: aborted"); slurm_mutex_unlock(&ipmi_mutex); return NULL; } slurm_mutex_unlock(&ipmi_mutex); flag_thread_started = true; //loop until slurm stop while (!flag_energy_accounting_shutdown) { time_lost = (int)(time(NULL) - last_update_time); _task_sleep(slurm_ipmi_conf.freq - time_lost); slurm_mutex_lock(&ipmi_mutex); _thread_update_node_energy(); slurm_mutex_unlock(&ipmi_mutex); } if (debug_flags & DEBUG_FLAG_ENERGY) info("ipmi-thread: ended"); return NULL; }
static void *_watch_tasks(void *arg) { int type = PROFILE_TASK; #if HAVE_SYS_PRCTL_H if (prctl(PR_SET_NAME, "acctg", NULL, NULL, NULL) < 0) { error("%s: cannot set my name to %s %m", __func__, "acctg"); } #endif (void) pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); (void) pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); /* Give chance for processes to spawn before starting * the polling. This should largely eliminate the * the chance of having /proc open when the tasks are * spawned, which would prevent a valid checkpoint/restart * with some systems */ _task_sleep(1); while (_init_run_test() && !_jobacct_shutdown_test() && acct_gather_profile_test()) { /* Do this until shutdown is requested */ slurm_mutex_lock(&acct_gather_profile_timer[type].notify_mutex); slurm_cond_wait( &acct_gather_profile_timer[type].notify, &acct_gather_profile_timer[type].notify_mutex); slurm_mutex_unlock(&acct_gather_profile_timer[type]. notify_mutex); slurm_mutex_lock(&g_context_lock); /* The initial poll is done after the last task is added */ _poll_data(1); slurm_mutex_unlock(&g_context_lock); } return NULL; }