/** @details -# Find target job. Return error if target job not found. -# Find depends job. Return error if depends job not found. -# Return an error if both jobs are on the same thread. -# The depend passed all checks, add the depends job to the target job dependency list */ int Trick::Executive::add_depends_on_job( std::string target_job_string , unsigned int t_instance , std::string depend_job_string , unsigned int d_instance ) { Trick::JobData * target_job ; Trick::JobData * depend_job ; /* Find target job. Return error if target job not found. */ target_job = get_job(target_job_string, t_instance) ; if ( target_job == NULL ) { message_publish(MSG_ERROR, "add_depends_on_job: Could not find target job %s instance %d\n", target_job_string.c_str(), t_instance) ; return(-1) ; } /* Find depends job. Return error if depends job not found. */ depend_job = get_job(depend_job_string, d_instance) ; if ( depend_job == NULL ) { message_publish(MSG_ERROR, "add_depends_on_job: Could not find depend job %s instance %d\n", depend_job_string.c_str(), d_instance) ; return(-2) ; } /* Return an error if both jobs are on the same thread */ if( target_job->thread == depend_job->thread) { message_publish(MSG_ERROR, "add_depends_on_job: target job %s and depend job %s on the same thread", target_job_string.c_str() , depend_job_string.c_str()) ; ; return(-3) ; } /* Passed all checks, add the depends job to the target job dependency list */ target_job->add_depend(depend_job) ; return(0) ; }
int main() { LIST *jlist = init_list(); assert(gen_job_id(jlist) == 1); assert(get_fg(jlist) == (job *)NULL); assert(jlist->size == 0); //print_bg(jlist); job *jb1 = tstjob(1); push(jlist, JOB, jb1); assert(gen_job_id(jlist) == 2); assert(get_fg(jlist) == jb1); //print_bg(jlist); job *jb2 = tstjob(3); push(jlist, JOB, jb2); assert(gen_job_id(jlist) == 2); job *jb3 = tstjob(2); push(jlist, JOB, jb3); assert(gen_job_id(jlist) == 4); push(jlist, JOB, tstjob(7)); assert(gen_job_id(jlist) == 4); print_bg(jlist); pop(jlist); assert(gen_job_id(jlist) == 4); assert(get_job_pgid(jlist, 11) == (job *)NULL); assert(get_job_pgid(jlist, 7) == jb2); assert(get_job_pgid(jlist, 3) == jb3); assert(get_job(jlist, 3) == jb2); assert(del_job(jlist, 7) == jb2); assert(get_job(jlist, 3) == (job *)NULL); assert(get_job(jlist, 55) == jb3); assert(get_job(jlist, 10) == (job *)NULL); assert(set_complete(jb2, 3) == 0); assert(set_complete(jb2, 4) == -1); assert(set_complete(jb3, 55) == 0); assert(((process *)jb2->pid_list->head->node_ptr)->complete == 0); assert(jb2->complete == 0); assert(jb3->complete == 1); assert(jlist->size == 2); assert(get_job_jid(jlist, 1) == jb1); assert(get_job_jid(jlist, 11) == (job *)NULL); printf("[job_handler_tst] All tests pass!\n"); return 0; }
static void assign_job(struct scan_peer *peer) { size_t job_len; uint16_t net_job_len; peer->job = clients_started ? get_job() : NULL; if (peer->job == NULL) { LIST_INSERT_HEAD(&inactive_peers, peer, peer_link); if (LIST_EMPTY(&active_peers) && clients_started) shutdown_master(); return; } LIST_INSERT_HEAD(&active_peers, peer, peer_link); peer->job->scan_output = NULL; job_len = strlen(peer->job->pkg_location); if (job_len > 0xffff) errx(1, "Location inside pkgsrc tree too long"); net_job_len = htons(job_len); (void)memcpy(peer->tmp_buf, &net_job_len, 2); deferred_write(peer->fd, peer->tmp_buf, 2, peer, send_job_path, kill_peer); }
int builtin_fg(cmd_t* cmd, job_list_t* jobs) { int index = -1; job_t* curr_job; if (cmd->args[1]) { // Get job specified. index = (int) strtol(cmd->args[1], NULL, 10); curr_job = get_job_by_index(jobs, index); } else { // Otherwise get latest job. curr_job = get_latest_job(jobs); } if (curr_job) { // Wait for process to complete synchronously. int exit_code = waitfor(curr_job->pid, jobs, 0); // Extract completed job from job list. get_job(jobs, curr_job->pid); return exit_code; } else { if (index > 0) { fprintf(stderr, "fg: job not found: %d\n", index); } else { fprintf(stderr, "fg: no current job\n"); } return 1; } }
/** * gstreamill_get_job: * @uri: (in): access uri, e.g. /live/test/encoder/0 * * Get the Job by access uri. * * Returns: job */ Job *gstreamill_get_job (Gstreamill *gstreamill, gchar *uri) { Job *job = NULL; GRegex *regex; GMatchInfo *match_info; gchar *name = NULL; regex = g_regex_new ("^/(live|dvr)/(?<name>[^/]*)/.*", G_REGEX_OPTIMIZE, 0, NULL); match_info = NULL; g_regex_match (regex, uri, 0, &match_info); g_regex_unref (regex); if (g_match_info_matches (match_info)) { name = g_match_info_fetch_named (match_info, "name"); } if (name != NULL) { job = get_job (gstreamill, name); g_free (name); } if (match_info != NULL) { g_match_info_free (match_info); } return job; }
int Trick::SimObject::add_tag_to_job( std::string job_tag , std::string job_name ) { Trick::JobData * jd ; if ( (jd = get_job(name + "." + job_name)) != NULL ) { return jd->add_tag(job_tag) ; } return -1 ; }
int Trick::Executive::get_freeze_job(std::string sim_object_name) { freeze_job = get_job(sim_object_name + ".sched_freeze_to_exec_command") ; if ( freeze_job == NULL ) { exec_terminate_with_return(-1 , __FILE__ , __LINE__ , "Executive could not find freeze job" ) ; } else { freeze_job->next_tics = TRICK_MAX_LONG_LONG ; } return 0 ; }
static void standalone_mode(void) { struct scan_job *job; while ((job = get_job()) != NULL) { job->scan_output = scan_pkglocation(job->pkg_location); process_job(job, JOB_DONE); } }
static unsigned int is_job_done (pid_t pid, unsigned int print, unsigned int details) { int status; int idx = index_of (pid); job *j = get_job (idx); const char l = (j == list->tail) ? '+' : '-'; pid_t p = waitpid (pid, &status, WNOHANG|WUNTRACED); if (p == -1) { warn ("jobs [%d] %d (%s)", j->content->job, j->content->pid, j->content->cmd); remove_job (idx); return TRUE; } if (j == NULL) { fprintf (stderr, "'%d': no such job\n", pid); return TRUE; } if (j->content->stopped && print) { if (details) { int i; fprintf (stdout, "[%d] %c %d suspended: %s", j->content->job, l, pid, j->content->cmd); for (i = 0; i < j->content->argc; i++) { char q; switch (j->content->protected[i]) { case NONE: q = '\0'; break; case DOUBLE_QUOTE: q = '"'; break; case SINGLE_QUOTE: q = '\''; } fprintf (stdout, " %c%s%c", q, j->content->argv[i], q); } fprintf (stdout, "\n"); } else { fprintf (stdout, "[%d] %c %d (%s) suspended\n", j->content->job, l, pid, j->content->cmd); } /* well, it's a lie but we don't want to print it twice */ return TRUE; }
/** * gstreamill_job_stop: * @name: (in): job name to be stoped * * Returns: plain text. */ gchar * gstreamill_job_stop (Gstreamill *gstreamill, gchar *name) { Job *job; job = get_job (gstreamill, name); if (job != NULL) { stop_job (job, SIGUSR2); return g_strdup ("ok"); } else { return g_strdup ("job not found"); } }
/** * gstreamill_job_stop: * @name: (in): job name to be stoped * * Returns: plain text. */ gchar * gstreamill_job_stop (Gstreamill *gstreamill, gchar *name) { Job *job; job = get_job (gstreamill, name); if (job != NULL) { stop_job (job, SIGTERM); return g_strdup_printf ("{\n \"name\": \"%s\",\n \"result\": \"success\"\n}", name); } else { return g_strdup ("{\n \"result\": \"failure\",\n \"reason\": \"job not found\"\n}"); } }
double Trick::Executive::get_job_cycle(std::string job_name) { Trick::JobData * job = NULL ; if ( job_name.empty() ) { return(get_curr_job()->cycle) ; } else { if ( (job = get_job(job_name)) != NULL ) { return(job->cycle) ; } } return(0.0) ; }
void* vina_worker(void* arg) { struct para* work_para = (struct para*)arg; char work_path[MAX_PATH]; int my_job; while ((my_job = get_job(work_para->jp, work_para->t)) != NO_JOB) { get_workpath(work_para->home_path, my_job, work_path); setup(work_para->cf, work_para->home_path, my_job, work_para->t); do_job(my_job, work_para->t, work_path); cleanup(work_path, work_para->cf->gather_loc, work_para->t, work_para->cf->outfile, my_job); } printf("Done!"); free(work_para); return NULL; }
void *main_tsp(void *arg){ unsigned long long perf; struct timespec t1, t2; uint64_t vpres=0; long long int myCuts = 0; clock_gettime (CLOCK_REALTIME, &t1); /* calculer chacun des travaux */ tsp_path_t solution; memset (solution, -1, MAX_TOWNS * sizeof (int)); solution[0] = 0; pthread_mutex_lock(&q_mutex); while (!empty_queue (&q, &q_mutex)) { int hops = 0, len = 0; get_job (&q, solution, &hops, &len, &vpres, &q_mutex); pthread_mutex_unlock(&q_mutex); //printf("Thread %ld\n", syscall(SYS_gettid)); // le noeud est moins bon que la solution courante if (minimum < INT_MAX && (nb_towns - hops) > 10 && ( (lower_bound_using_hk(solution, hops, len, vpres)) >= minimum || (lower_bound_using_lp(solution, hops, len, vpres)) >= minimum)){ pthread_mutex_lock(&q_mutex); continue; } tsp (hops, len, vpres, solution, &myCuts, sol, &sol_len); pthread_mutex_lock(&q_mutex); } pthread_mutex_unlock(&q_mutex); /* update cuts */ pthread_mutex_lock(&cuts_mutex); cuts += myCuts; pthread_mutex_unlock(&cuts_mutex); clock_gettime (CLOCK_REALTIME, &t2); perf = TIME_DIFF (t1,t2); printf("Son thread %ld finished after %lld.%03lld ms\n\n", syscall(SYS_gettid), perf/1000000ll, perf%1000000ll); return 0 ; }
void* dispatch_job () { struct job *job; while(1) { pthread_mutex_lock(&mutex); job = get_job(); pthread_mutex_unlock(&mutex); if (job) { do_job(job); free(job); } else { pthread_exit(NULL); } } }
void * tsp_worker(void * args) { WorkerArgs * a = (WorkerArgs*) args; long long int cuts; while (!empty_queue(a->q)) { int hops = 0, len = 0; cuts = 0; pthread_mutex_lock(&mutex_queue); get_job(a->q, a->solution, &hops, &len); pthread_mutex_unlock(&mutex_queue); tsp(hops, len, a->solution, &cuts, a->sol, a->sol_len); pthread_mutex_lock(&mutex_cuts); *(a->cuts) += cuts; pthread_mutex_unlock(&mutex_cuts); } free(args); return (void*)42; }
static void assign_job(void *arg) { struct build_peer *peer = arg; size_t build_info_len; uint32_t net_build_info_len; if (peer->tmp_buf[0] == 'S') { send_build_stats(peer); return; } if (peer->tmp_buf[0] != 'G') { kill_peer(peer); return; } LIST_REMOVE(peer, peer_link); peer->job = get_job(); if (peer->job == NULL) { LIST_INSERT_HEAD(&unassigned_peers, peer, peer_link); if (LIST_EMPTY(&active_peers)) event_loopexit(NULL); return; } LIST_INSERT_HEAD(&active_peers, peer, peer_link); build_info_len = peer->job->end - peer->job->begin; if (build_info_len > 0xffffff) errx(1, "Build info too long"); net_build_info_len = htonl(build_info_len); (void)memcpy(peer->tmp_buf, &net_build_info_len, 4); deferred_write(peer->fd, peer->tmp_buf, 4, peer, send_build_info, kill_peer); peer = LIST_FIRST(&unassigned_peers); if (peer != NULL) assign_job(peer); }
void * tfn7(void * arg) { int count; Job task = (struct job *)malloc(sizeof(struct job)); task->next = NULL; task->val = 0; task->tid = -1; pthread_t tid = pthread_self(); count = 0; while (count < MAX_ITEM) { if (pthread_mutex_trylock(&q_lock) == 0) { get_job(arg, task, &count, tid); pthread_mutex_unlock(&q_lock); } } print(task); if (free_job(task) == -1) { exit(1); } return (void *)0; }
void * tfn7(void * arg) { int count; /* 每次取得链表结点数 */ struct job * task = NULL; /* 属于当前线程的任务结点的队列头 */ pthread_t tid; tid = pthread_self(); /* 得到当前线程ID,根据此线程ID判断任务是否归属于当前线程 */ count = 0; while(count < MAX_ITEM) if(pthread_mutex_trylock(&q_lock) == 0) { /* 将队列加锁 */ get_job((Job) arg, task, &count); pthread_mutex_unlock(&q_lock); /* 遍历链表结束,释放锁 */ } print((Job) arg); if(free_job(task) == -1) exit(1); return (void *)0; }
int main(int argc, char *argv[]) { log_options_t opts = LOG_OPTS_STDERR_ONLY; node_info_msg_t *node_info_ptr = NULL; node_info_msg_t *new_node_ptr = NULL; int error_code; int height = 40; int width = 100; int startx = 0; int starty = 0; int end = 0; int i; int rc; int mapset = 0; log_init(xbasename(argv[0]), opts, SYSLOG_FACILITY_DAEMON, NULL); parse_command_line(argc, argv); if (params.verbose) { opts.stderr_level += params.verbose; log_alter(opts, SYSLOG_FACILITY_USER, NULL); } if (params.cluster_dims == 4) { min_screen_width = 92; } else if (params.cluster_dims == 3) min_screen_width = 92; while (slurm_load_node((time_t) NULL, &new_node_ptr, SHOW_ALL)) { error_code = slurm_get_errno(); printf("slurm_load_node: %s\n", slurm_strerror(error_code)); if (params.display == COMMANDS) { new_node_ptr = NULL; break; /* just continue */ } if (params.iterate == 0) _smap_exit(1); /* Calls exit(), no return */ sleep(10); /* keep trying to reconnect */ } _init_colors(); select_g_ba_init(new_node_ptr, 0); init_grid(new_node_ptr); if (params.resolve) { #if defined HAVE_BG_FILES && defined HAVE_BG_L_P #if 1 error("this doesn't work in the current 2.3 code. FIXME"); #else if (!have_db2) { printf("Required libraries can not be found " "to access the Bluegene system.\nPlease " "set your LD_LIBRARY_PATH correctly to " "point to them.\n"); goto part_fini; } if (!mapset) mapset = 1; if (params.resolve[0] != 'R') { i = strlen(params.resolve); i -= 3; if (i < 0) { printf("No real block was entered\n"); goto part_fini; } char *rack_mid = find_bp_rack_mid(params.resolve+i); if (rack_mid) { printf("X=%c Y=%c Z=%c resolves to %s\n", params.resolve[0+i], params.resolve[1+i], params.resolve[2+i], rack_mid); } else { printf("X=%c Y=%c Z=%c has no resolve\n", params.resolve[0+i], params.resolve[1+i], params.resolve[2+i]); } } else { uint16_t *coord = find_bp_loc(params.resolve); if (coord) { printf("%s resolves to X=%d Y=%d Z=%d\n", params.resolve, coord[0], coord[1], coord[2]); } else { printf("%s has no resolve.\n", params.resolve); } } part_fini: #endif #else printf("Must be physically on a BlueGene system for support " "of resolve option.\n"); #endif _smap_exit(0); /* Calls exit(), no return */ } if (!params.commandline) { int check_width = min_screen_width; signal(SIGWINCH, (void (*)(int))_resize_handler); initscr(); if (params.cluster_dims == 4) { height = dim_size[2] * dim_size[3] + dim_size[2] + 3; width = (dim_size[1] + dim_size[3] + 1) * dim_size[0] + 2; check_width += width; } else if (params.cluster_dims == 3) { height = dim_size[1] * dim_size[2] + dim_size[1] + 3; width = dim_size[0] + dim_size[2] + 3; check_width += width; } else { height = 10; width = COLS; } if ((COLS < check_width) || (LINES < height)) { endwin(); error("Screen is too small make sure the screen " "is at least %dx%d\n" "Right now it is %dx%d\n", check_width, height, COLS, LINES); _smap_exit(1); /* Calls exit(), no return */ } raw(); keypad(stdscr, TRUE); noecho(); cbreak(); curs_set(0); nodelay(stdscr, TRUE); start_color(); _set_pairs(); grid_win = newwin(height, width, starty, startx); max_display = grid_win->_maxy * grid_win->_maxx; if (params.cluster_dims == 4) { startx = width; COLS -= 2; width = COLS - width; height = LINES; } else if (params.cluster_dims == 3) { startx = width; COLS -= 2; width = COLS - width; height = LINES; } else { startx = 0; starty = height; height = LINES - height; } text_win = newwin(height, width, starty, startx); } while (!end) { if (!params.commandline) { _get_option(); redraw: clear_window(text_win); clear_window(grid_win); move(0, 0); main_xcord = 1; main_ycord = 1; } if (!params.no_header) print_date(); clear_grid(); switch (params.display) { case JOBS: get_job(); break; case RESERVATIONS: get_reservation(); break; case SLURMPART: get_slurm_part(); break; case COMMANDS: if (params.cluster_flags & CLUSTER_FLAG_BG) { if (!mapset) { mapset = 1; wclear(text_win); } get_command(); } else { error("Must be on a BG SYSTEM to " "run this command"); if (!params.commandline) endwin(); _smap_exit(1); /* Calls exit(), no return */ } break; case BGPART: if (params.cluster_flags & CLUSTER_FLAG_BG) get_bg_part(); else { error("Must be on a BG SYSTEM to " "run this command"); if (!params.commandline) endwin(); _smap_exit(1); /* Calls exit(), no return */ } break; } if (!params.commandline) { box(text_win, 0, 0); wnoutrefresh(text_win); print_grid(); box(grid_win, 0, 0); wnoutrefresh(grid_win); doupdate(); node_info_ptr = new_node_ptr; if (node_info_ptr) { error_code = slurm_load_node( node_info_ptr->last_update, &new_node_ptr, SHOW_ALL); if (error_code == SLURM_SUCCESS) slurm_free_node_info_msg( node_info_ptr); else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) { error_code = SLURM_SUCCESS; new_node_ptr = node_info_ptr; } } else { error_code = slurm_load_node( (time_t) NULL, &new_node_ptr, SHOW_ALL); } if (error_code && (quiet_flag != 1)) { if (!params.commandline) { mvwprintw( text_win, main_ycord, 1, "slurm_load_node: %s", slurm_strerror( slurm_get_errno())); main_ycord++; } else { printf("slurm_load_node: %s", slurm_strerror( slurm_get_errno())); } } } if (params.iterate) { for (i = 0; i < params.iterate; i++) { sleep(1); if (!params.commandline) { if ((rc = _get_option()) == 1) goto redraw; else if (resize_screen) { resize_screen = 0; goto redraw; } } } } else break; } if (!params.commandline) { nodelay(stdscr, FALSE); getch(); endwin(); } _smap_exit(0); /* Calls exit(), no return */ exit(0); /* Redundant, but eliminates compiler warning */ }
int main (int argc, char **argv) { unsigned long temps; int i; struct timeval t1, t2; int *cuts = NULL; /* Juste à des fins de statistiques pour savoir combien de fois on a pu optimiser */ if (argc != 3) { fprintf (stderr, "Usage: %s <ncities> <seed> \n",argv[0]) ; exit (1) ; } Argc = argc ; Argv = argv ; minimum = INT_MAX ; printf ("ncities = %3d\n", atoi(argv[1])) ; init_queue (&q); genmap () ; gettimeofday(&t1,NULL); { Path_t path; int i; for(i=0;i<MAXE;i++) path[i] = -1 ; path [0] = 0; tsp_partiel (1, 0, path, cuts); no_more_jobs (&q); } gettimeofday(&t2,NULL); temps = TIME_DIFF(t1,t2); printf("time = %ld.%03ldms\n", temps/1000, temps%1000); { Path_t path; int hops, len, n = 0; cuts = calloc(NrTowns+1,sizeof(*cuts)); while (!empty_queue(&q)) { n++; get_job(&q, path, &hops, &len); tsp(hops, len, path, cuts); } printf("%d jobs", n); } gettimeofday(&t2,NULL); temps = TIME_DIFF(t1,t2); printf("time = %ld.%03ldms (cuts :", temps/1000, temps%1000); for (i=0; i<NrTowns; i++) printf(" %d",cuts[i]); printf(")\n"); return 0 ; }
/** * gstreamill_job_start: * @job: (in): json type of job description. * * Returns: json type of job execution result. */ gchar * gstreamill_job_start (Gstreamill *gstreamill, gchar *job_desc) { gchar *p, *name; Job *job; if (!jobdesc_is_valid (job_desc)) { p = g_strdup_printf ("{\n \"result\": \"failure\",\n \"reason\": \"invalid job\"\n}"); return p; } if (jobdesc_is_live (job_desc)) { GST_ERROR ("live job arrived:\n%s", job_desc); } else { GST_ERROR ("transcode job arrived:\n%s", job_desc); } /* create job object */ name = jobdesc_get_name (job_desc); if (get_job (gstreamill, name) != NULL) { GST_ERROR ("start job failure, duplicated name %s.", name); p = g_strdup_printf ("{\n \"result\": \"failure\",\n \"reason\": \"duplicated name\"\n}"); g_free (name); return p; } job = job_new ("job", job_desc, "name", name, "exe_path", gstreamill->exe_path, NULL); g_free (name); /* job initialize */ job->log_dir = gstreamill->log_dir; g_mutex_init (&(job->access_mutex)); job->is_live = jobdesc_is_live (job_desc); job->eos = FALSE; job->current_access = 0; job->age = 0; job->last_start_time = NULL; if (job_initialize (job, gstreamill->daemon) != 0) { p = g_strdup_printf ("{\n \"result\": \"failure\",\n \"reason\": \"initialize job failure\"\n}"); g_object_unref (job); return p; } if (job->is_live && (job_output_initialize (job) != 0)) { p = g_strdup_printf ("{\n \"result\": \"failure\",\n \"reason\": \"initialize job output failure\"\n}"); g_object_unref (job); return p; } /* reset and start job */ job_reset (job); if (gstreamill->daemon) { guint64 stat; stat = create_job_process (job); if (stat == JOB_STATE_PLAYING) { GST_ERROR ("Start job %s success", job->name); g_mutex_lock (&(gstreamill->job_list_mutex)); gstreamill->job_list = g_slist_append (gstreamill->job_list, job); g_mutex_unlock (&(gstreamill->job_list_mutex)); p = g_strdup_printf ("{\n \"name\": \"%s\",\n\"result\": \"success\"\n}", job->name); } else { GST_ERROR ("Start job %s failure, return stat: %s", job->name, job_state_get_name (stat)); g_object_unref (job); p = g_strdup_printf ("{\n \"result\": \"failure\",\n \"reason\": \"create process failure\"\n}"); } } else { job_encoders_output_initialize (job); if (job_start (job) == 0) { g_mutex_lock (&(gstreamill->job_list_mutex)); gstreamill->job_list = g_slist_append (gstreamill->job_list, job); g_mutex_unlock (&(gstreamill->job_list_mutex)); p = g_strdup ("{\n \"result\": \"success\"\n}"); } else { p = g_strdup_printf ("{\n \"result\": \"failure\",\n \"reason\": \"unknown\"\n}"); } } return p; }
static int handle_worker_result(int sd, int events, void *arg) { wproc_object_job *oj = NULL; char *buf, *error_reason = NULL; unsigned long size; int ret; static struct kvvec kvv = KVVEC_INITIALIZER; struct wproc_worker *wp = (struct wproc_worker *)arg; if(iocache_capacity(wp->ioc) == 0) { logit(NSLOG_RUNTIME_WARNING, TRUE, "wproc: iocache_capacity() is 0 for worker %s.\n", wp->name); } ret = iocache_read(wp->ioc, wp->sd); if (ret < 0) { logit(NSLOG_RUNTIME_WARNING, TRUE, "wproc: iocache_read() from %s returned %d: %s\n", wp->name, ret, strerror(errno)); return 0; } else if (ret == 0) { logit(NSLOG_INFO_MESSAGE, TRUE, "wproc: Socket to worker %s broken, removing", wp->name); wproc_num_workers_online--; iobroker_unregister(nagios_iobs, sd); if (workers.len <= 0) { /* there aren't global workers left, we can't run any more checks * we should try respawning a few of the standard ones */ logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: All our workers are dead, we can't do anything!"); } remove_worker(wp); fanout_destroy(wp->jobs, fo_reassign_wproc_job); wp->jobs = NULL; wproc_destroy(wp, 0); return 0; } while ((buf = worker_ioc2msg(wp->ioc, &size, 0))) { struct wproc_job *job; wproc_result wpres; /* log messages are handled first */ if (size > 5 && !memcmp(buf, "log=", 4)) { logit(NSLOG_INFO_MESSAGE, TRUE, "wproc: %s: %s\n", wp->name, buf + 4); continue; } /* for everything else we need to actually parse */ if (buf2kvvec_prealloc(&kvv, buf, size, '=', '\0', KVVEC_ASSIGN) <= 0) { logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: Failed to parse key/value vector from worker response with len %lu. First kv=%s", size, buf ? buf : "(NULL)"); continue; } memset(&wpres, 0, sizeof(wpres)); wpres.job_id = -1; wpres.type = -1; wpres.response = &kvv; parse_worker_result(&wpres, &kvv); job = get_job(wp, wpres.job_id); if (!job) { logit(NSLOG_RUNTIME_WARNING, TRUE, "wproc: Job with id '%d' doesn't exist on %s.\n", wpres.job_id, wp->name); continue; } if (wpres.type != job->type) { logit(NSLOG_RUNTIME_WARNING, TRUE, "wproc: %s claims job %d is type %d, but we think it's type %d\n", wp->name, job->id, wpres.type, job->type); break; } oj = (wproc_object_job *)job->arg; /* * ETIME ("Timer expired") doesn't really happen * on any modern systems, so we reuse it to mean * "program timed out" */ if (wpres.error_code == ETIME) { wpres.early_timeout = TRUE; } if (wpres.early_timeout) { asprintf(&error_reason, "timed out after %.2fs", tv_delta_f(&wpres.start, &wpres.stop)); } else if (WIFSIGNALED(wpres.wait_status)) { asprintf(&error_reason, "died by signal %d%s after %.2f seconds", WTERMSIG(wpres.wait_status), WCOREDUMP(wpres.wait_status) ? " (core dumped)" : "", tv_delta_f(&wpres.start, &wpres.stop)); } else if (job->type != WPJOB_CHECK && WEXITSTATUS(wpres.wait_status) != 0) { asprintf(&error_reason, "is a non-check helper but exited with return code %d", WEXITSTATUS(wpres.wait_status)); } if (error_reason) { logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: %s job %d from worker %s %s", wpjob_type_name(job->type), job->id, wp->name, error_reason); logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: command: %s\n", job->command); if (job->type != WPJOB_CHECK && oj) { logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: host=%s; service=%s; contact=%s\n", oj->host_name ? oj->host_name : "(none)", oj->service_description ? oj->service_description : "(none)", oj->contact_name ? oj->contact_name : "(none)"); } else if (oj) { struct check_result *cr = (struct check_result *)job->arg; logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: host=%s; service=%s;\n", cr->host_name, cr->service_description); } logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: early_timeout=%d; exited_ok=%d; wait_status=%d; error_code=%d;\n", wpres.early_timeout, wpres.exited_ok, wpres.wait_status, wpres.error_code); wproc_logdump_buffer(NSLOG_RUNTIME_ERROR, TRUE, "wproc: stderr", wpres.outerr); wproc_logdump_buffer(NSLOG_RUNTIME_ERROR, TRUE, "wproc: stdout", wpres.outstd); } my_free(error_reason); switch (job->type) { case WPJOB_CHECK: ret = handle_worker_check(&wpres, wp, job); break; case WPJOB_NOTIFY: if (wpres.early_timeout) { if (oj->service_description) { logit(NSLOG_RUNTIME_WARNING, TRUE, "Warning: Notifying contact '%s' of service '%s' on host '%s' by command '%s' timed out after %.2f seconds\n", oj->contact_name, oj->service_description, oj->host_name, job->command, tv2float(&wpres.runtime)); } else { logit(NSLOG_RUNTIME_WARNING, TRUE, "Warning: Notifying contact '%s' of host '%s' by command '%s' timed out after %.2f seconds\n", oj->contact_name, oj->host_name, job->command, tv2float(&wpres.runtime)); } } break; case WPJOB_OCSP: if (wpres.early_timeout) { logit(NSLOG_RUNTIME_WARNING, TRUE, "Warning: OCSP command '%s' for service '%s' on host '%s' timed out after %.2f seconds\n", job->command, oj->service_description, oj->host_name, tv2float(&wpres.runtime)); } break; case WPJOB_OCHP: if (wpres.early_timeout) { logit(NSLOG_RUNTIME_WARNING, TRUE, "Warning: OCHP command '%s' for host '%s' timed out after %.2f seconds\n", job->command, oj->host_name, tv2float(&wpres.runtime)); } break; case WPJOB_GLOBAL_SVC_EVTHANDLER: if (wpres.early_timeout) { logit(NSLOG_EVENT_HANDLER | NSLOG_RUNTIME_WARNING, TRUE, "Warning: Global service event handler command '%s' timed out after %.2f seconds\n", job->command, tv2float(&wpres.runtime)); } break; case WPJOB_SVC_EVTHANDLER: if (wpres.early_timeout) { logit(NSLOG_EVENT_HANDLER | NSLOG_RUNTIME_WARNING, TRUE, "Warning: Service event handler command '%s' timed out after %.2f seconds\n", job->command, tv2float(&wpres.runtime)); } break; case WPJOB_GLOBAL_HOST_EVTHANDLER: if (wpres.early_timeout) { logit(NSLOG_EVENT_HANDLER | NSLOG_RUNTIME_WARNING, TRUE, "Warning: Global host event handler command '%s' timed out after %.2f seconds\n", job->command, tv2float(&wpres.runtime)); } break; case WPJOB_HOST_EVTHANDLER: if (wpres.early_timeout) { logit(NSLOG_EVENT_HANDLER | NSLOG_RUNTIME_WARNING, TRUE, "Warning: Host event handler command '%s' timed out after %.2f seconds\n", job->command, tv2float(&wpres.runtime)); } break; case WPJOB_CALLBACK: run_job_callback(job, &wpres, 0); break; default: logit(NSLOG_RUNTIME_WARNING, TRUE, "Worker %d: Unknown jobtype: %d\n", wp->pid, job->type); break; } destroy_job(job); } return 0; }
int main (int argc, char **argv) { unsigned long long perf; tsp_path_t path; struct tsp_queue q; struct timespec t1, t2; /* lire les arguments */ int opt; while ((opt = getopt(argc, argv, "s")) != -1) { switch (opt) { case 's': affiche_sol = true; break; default: usage(argv[0]); break; } } if (optind != argc-3) usage(argv[0]); nb_towns = atoi(argv[optind]); myseed = atol(argv[optind+1]); nb_threads = atoi(argv[optind+2]); assert(nb_towns > 0); assert(nb_threads > 0); minimum = INT_MAX; /* generer la carte et la matrice de distance */ fprintf (stderr, "ncities = %3d\n", nb_towns); genmap (); init_queue (&q); clock_gettime (CLOCK_REALTIME, &t1); /* on vide le chemin 'path' : on met des -1 dans toutes les cases */ memset (path, -1, MAX_TOWNS * sizeof (int)); /* on définit la première ville comme étant 0 */ path[0] = 0; /* On met des travaux dans la file d'attente q */ generate_tsp_jobs (&q, 1, 0, path, &cuts, sol, & sol_len, 3); no_more_jobs (&q); /* on vide le chemin 'solution' : on met des -1 dans toutes les cases */ /* puis on définit la première ville comme étant 0 */ tsp_path_t solution; memset (solution, -1, MAX_TOWNS * sizeof (int)); solution[0] = 0; /* allocation du tableau d'informations sur les threads */ tab_threads = malloc(nb_threads*sizeof(Cell)); memset(tab_threads, 0, nb_threads*sizeof(int)); /* initialisation du mutex*/ pthread_mutex_init(&mutex, NULL); int i; /* on place tous les threads dans l'état 'non-occupé' */ for(i=0; i<nb_threads; i++){ tab_threads[i].occupe = 0; } /* Tant que la file de jobs n'est pas vide on sort un job et on l'execute avec tsp */ while (!empty_queue (&q)) { int hops = 0, len = 0; /* on récupère un job dans la file d'atente des jobs */ get_job (&q, solution, &hops, &len); i = 0; /* on boucle tant qu'on n'a pas trouvé de thread pour effectuer le job */ while (1){ /* si le thread i n'est pas occupé alors on va l'utiliser pour effectuer le job */ if(!tab_threads[i].occupe){ /* on place le thread i en statut 'occupé' */ tab_threads[i].occupe = 1; /* on crée une structure arguments qui va recevoir les arguments de tsp */ struct arg_struct arguments; arguments.hops = hops; arguments.len = len; memcpy(arguments.path, solution, nb_towns * sizeof (int)); /* tsp est récursive et on a besoin de savoir quand le thread a terminé le job afin de le mettre en 'non-occupé' */ /* On introduit donc un entier qui est 1 si le tsp appelé est celui du père et 0 si c'est dans les fils */ arguments.pere = 1; /* lancement du thread sur tsp avec les bons arguments*/ pthread_create (&tab_threads[i].thread, NULL, tsp, (void*)&arguments); break; } /* sinon on va regarder si le suivant%nb_threads est occupé */ i = (i+1)%nb_threads; } } i = 0; /* on attend la fin de tous les threads avant de continuer */ while(1){ pthread_join(tab_threads[i].thread, NULL); i++; if (i == nb_threads) break; } clock_gettime (CLOCK_REALTIME, &t2); if (affiche_sol) print_solution_svg (sol, sol_len); perf = TIME_DIFF (t1,t2); printf("<!-- # = %d seed = %ld len = %d threads = %d time = %lld.%03lld ms ( %lld coupures ) -->\n", nb_towns, myseed, sol_len, nb_threads, perf/1000000ll, perf%1000000ll, cuts); return 0 ; }
void get_command(void) { char com[255]; int text_width, text_startx; allocated_block_t *allocated_block = NULL; int i = 0; int count = 0; WINDOW *command_win = NULL; List allocated_blocks = NULL; ListIterator results_i; if (params.commandline && !params.command) { printf("Configure won't work with commandline mode.\n"); printf("Please remove the -c from the commandline.\n"); bg_configure_ba_fini(); exit(0); } if (working_cluster_rec) { char *cluster_name = slurm_get_cluster_name(); if (strcmp(working_cluster_rec->name, cluster_name)) { xfree(cluster_name); endwin(); printf("To use the configure option you must be on the " "cluster the configure is for.\nCross cluster " "support doesn't exist today.\nSorry for the " "inconvenince.\n"); bg_configure_ba_fini(); exit(0); } xfree(cluster_name); } /* make sure we don't get any noisy debug */ ba_configure_set_ba_debug_flags(0); bg_configure_ba_setup_wires(); color_count = 0; allocated_blocks = list_create(_destroy_allocated_block); if (params.commandline) { snprintf(com, sizeof(com), "%s", params.command); goto run_command; } else { text_width = text_win->_maxx; text_startx = text_win->_begx; command_win = newwin(3, text_width - 1, LINES - 4, text_startx + 1); curs_set(1); echo(); } while (strcmp(com, "quit")) { clear_window(grid_win); print_grid(); clear_window(text_win); box(text_win, 0, 0); box(grid_win, 0, 0); if (!params.no_header) _print_header_command(); if (error_string != NULL) { i = 0; while (error_string[i] != '\0') { if (error_string[i] == '\n') { main_ycord++; main_xcord=1; i++; } mvwprintw(text_win, main_ycord, main_xcord, "%c", error_string[i++]); main_xcord++; } main_ycord++; main_xcord = 1; memset(error_string, 0, 255); } results_i = list_iterator_create(allocated_blocks); count = list_count(allocated_blocks) - (LINES-(main_ycord+5)); if (count<0) count=0; i=0; while ((allocated_block = list_next(results_i)) != NULL) { if (i >= count) _print_text_command(allocated_block); i++; } list_iterator_destroy(results_i); wnoutrefresh(text_win); wnoutrefresh(grid_win); doupdate(); clear_window(command_win); box(command_win, 0, 0); mvwprintw(command_win, 0, 3, "Input Command: (type quit to change view, " "exit to exit)"); wmove(command_win, 1, 1); wgetstr(command_win, com); if (!strcmp(com, "exit")) { endwin(); if (allocated_blocks) list_destroy(allocated_blocks); bg_configure_ba_fini(); exit(0); } run_command: if (!strcmp(com, "quit") || !strcmp(com, "\\q")) { break; } else if (!strncasecmp(com, "layout", 6)) { _set_layout(com); } else if (!strncasecmp(com, "basepartition", 13)) { _set_base_part_cnt(com); } else if (!strncasecmp(com, "nodecard", 8)) { _set_nodecard_cnt(com); } else if (!strncasecmp(com, "resolve", 7) || !strncasecmp(com, "r ", 2)) { _resolve(com); } else if (!strncasecmp(com, "resume", 6)) { mvwprintw(text_win, main_ycord, main_xcord, "%s", com); } else if (!strncasecmp(com, "drain", 5)) { mvwprintw(text_win, main_ycord, main_xcord, "%s", com); } else if (!strncasecmp(com, "alldown", 7)) { _change_state_all_bps(com, NODE_STATE_DOWN); } else if (!strncasecmp(com, "down", 4)) { _change_state_bps(com, NODE_STATE_DOWN); } else if (!strncasecmp(com, "allup", 5)) { _change_state_all_bps(com, NODE_STATE_IDLE); } else if (!strncasecmp(com, "up", 2)) { _change_state_bps(com, NODE_STATE_IDLE); } else if (!strncasecmp(com, "remove", 6) || !strncasecmp(com, "delete", 6) || !strncasecmp(com, "drop", 4)) { _remove_allocation(com, allocated_blocks); } else if (!strncasecmp(com, "create", 6)) { _create_allocation(com, allocated_blocks); } else if (!strncasecmp(com, "copy", 4) || !strncasecmp(com, "c ", 2) || !strncasecmp(com, "c\0", 2)) { _copy_allocation(com, allocated_blocks); } else if (!strncasecmp(com, "save", 4)) { _save_allocation(com, allocated_blocks); } else if (!strncasecmp(com, "load", 4)) { _load_configuration(com, allocated_blocks); } else if (!strncasecmp(com, "clear all", 9) || !strncasecmp(com, "clear", 5)) { list_flush(allocated_blocks); } else { memset(error_string, 0, 255); sprintf(error_string, "Unknown command '%s'",com); } if (params.commandline) { bg_configure_ba_fini(); exit(1); } } if (allocated_blocks) list_destroy(allocated_blocks); params.display = 0; noecho(); clear_window(text_win); main_xcord = 1; main_ycord = 1; curs_set(0); print_date(); get_job(); return; }
int mpi_main(int argc, char **argv, job_t (send_jobs)(filter_t *, unsigned char **, int, int), job_t (get_job)(filter_t *)) { int rank, image_width, image_height; filter_t filter; job_t job; double starttime; unsigned char ** result; MPI_Init(&argc, &argv); starttime = MPI_Wtime(); MPI_Comm_rank(MPI_COMM_WORLD, &rank); // Init if (rank == 0) { // Read in image and filter and send to workers if (argc < 3 || argc > 4) { fprintf(stderr, "USAGE: %s filter.txt input.pnm [output.pnm]\n", argv[1]); return 1; } const char * filter_path = argv[1]; const char * image_path = argv[2]; const char * output_path = argv[argc == 3 ? 2 : 3]; unsigned char ** image; filter.filter = read_filter(filter_path, &filter.width, &filter.height); image = read_image(image_path, &image_width, &image_height); send_filter(&filter); job = send_jobs(&filter, image, image_width, image_height); result = do_job(&job, &filter); LOG("Fetching results."); fetch_results(result, image_width); LOG("Writing output"); write_image(output_path, result, job.width, job.height); } else { // Receive filter and job filter = get_filter(); job = get_job(&filter); result = do_job(&job, &filter); LOG("Sending results"); send_result(&job, result); } // Cleanup /* free_filter(filter.filter, filter.height); */ /* free_image(job.image); */ /* free_image(result); */ starttime = MPI_Wtime() - starttime; if (rank == 0) printf("%f\n", starttime); MPI_Finalize(); return 0; }
static int handle_worker_result(int sd, int events, void *arg) { worker_process *wp = (worker_process *)arg; wproc_object_job *oj; char *buf; unsigned long size; int ret; static struct kvvec kvv = KVVEC_INITIALIZER; ret = iocache_read(wp->ioc, wp->sd); if (ret < 0) { logit(NSLOG_RUNTIME_WARNING, TRUE, "iocache_read() from worker %d returned %d: %s\n", wp->pid, ret, strerror(errno)); return 0; } else if (ret == 0) { /* * XXX FIXME worker exited. spawn a new on to replace it * and distribute all unfinished jobs from this one to others */ return 0; } while ((buf = iocache_use_delim(wp->ioc, MSG_DELIM, MSG_DELIM_LEN, &size))) { int job_id = -1; worker_job *job; wproc_result wpres; /* log messages are handled first */ if (size > 5 && !memcmp(buf, "log=", 4)) { logit(NSLOG_INFO_MESSAGE, TRUE, "worker %d: %s\n", wp->pid, buf + 4); continue; } /* for everything else we need to actually parse */ if (buf2kvvec_prealloc(&kvv, buf, size, '=', '\0', KVVEC_ASSIGN) <= 0) { /* XXX FIXME log an error */ continue; } memset(&wpres, 0, sizeof(wpres)); wpres.job_id = -1; wpres.type = -1; wpres.response = &kvv; parse_worker_result(&wpres, &kvv); job = get_job(wp, wpres.job_id); if (!job) { logit(NSLOG_RUNTIME_WARNING, TRUE, "Worker job with id '%d' doesn't exist on worker %d.\n", job_id, wp->pid); continue; } if (wpres.type != job->type) { logit(NSLOG_RUNTIME_WARNING, TRUE, "Worker %d claims job %d is type %d, but we think it's type %d\n", wp->pid, job->id, wpres.type, job->type); break; } oj = (wproc_object_job *)job->arg; /* * ETIME ("Timer expired") doesn't really happen * on any modern systems, so we reuse it to mean * "program timed out" */ if (wpres.error_code == ETIME) { wpres.early_timeout = TRUE; } switch (job->type) { case WPJOB_CHECK: ret = handle_worker_check(&wpres, wp, job); break; case WPJOB_NOTIFY: if (wpres.early_timeout) { if (oj->service_description) { logit(NSLOG_RUNTIME_WARNING, TRUE, "Warning: Notifying contact '%s' of service '%s' on host '%s' by command '%s' timed out after %.2f seconds\n", oj->contact_name, oj->service_description, oj->host_name, job->command, tv2float(&wpres.runtime)); } else { logit(NSLOG_RUNTIME_WARNING, TRUE, "Warning: Notifying contact '%s' of host '%s' by command '%s' timed out after %.2f seconds\n", oj->contact_name, oj->host_name, job->command, tv2float(&wpres.runtime)); } } break; case WPJOB_OCSP: if (wpres.early_timeout) { logit(NSLOG_RUNTIME_WARNING, TRUE, "Warning: OCSP command '%s' for service '%s' on host '%s' timed out after %.2f seconds\n", job->command, oj->service_description, oj->host_name, tv2float(&wpres.runtime)); } break; case WPJOB_OCHP: if (wpres.early_timeout) { logit(NSLOG_RUNTIME_WARNING, TRUE, "Warning: OCHP command '%s' for host '%s' timed out after %.2f seconds\n", job->command, oj->host_name, tv2float(&wpres.runtime)); } break; case WPJOB_GLOBAL_SVC_EVTHANDLER: if (wpres.early_timeout) { logit(NSLOG_EVENT_HANDLER | NSLOG_RUNTIME_WARNING, TRUE, "Warning: Global service event handler command '%s' timed out after %.2f seconds\n", job->command, tv2float(&wpres.runtime)); } break; case WPJOB_SVC_EVTHANDLER: if (wpres.early_timeout) { logit(NSLOG_EVENT_HANDLER | NSLOG_RUNTIME_WARNING, TRUE, "Warning: Service event handler command '%s' timed out after %.2f seconds\n", job->command, tv2float(&wpres.runtime)); } break; case WPJOB_GLOBAL_HOST_EVTHANDLER: if (wpres.early_timeout) { logit(NSLOG_EVENT_HANDLER | NSLOG_RUNTIME_WARNING, TRUE, "Warning: Global host event handler command '%s' timed out after %.2f seconds\n", job->command, tv2float(&wpres.runtime)); } break; case WPJOB_HOST_EVTHANDLER: if (wpres.early_timeout) { logit(NSLOG_EVENT_HANDLER | NSLOG_RUNTIME_WARNING, TRUE, "Warning: Host event handler command '%s' timed out after %.2f seconds\n", job->command, tv2float(&wpres.runtime)); } break; default: logit(NSLOG_RUNTIME_WARNING, TRUE, "Worker %d: Unknown jobtype: %d\n", wp->pid, job->type); break; } destroy_job(wp, job); } return 0; }
/** SIGCHLD handler **/ void handler(int signum, siginfo_t *info, void *context) { int cpid, status; cpid = info->si_pid; // sending pid //printf("Got a SIGCHLD from %d!\n", cpid); // loop to catch simultaneous SIGCHLDs while( (cpid = waitpid(-1, &status, WNOHANG | WUNTRACED | WCONTINUED)) > 0 ) { //printf("HANDLER Got %d from waitpid\n", cpid); job *j = get_job(job_list, cpid); if(j == NULL) { printf("Error: get_job returned null\n"); _exit(EXIT_FAILURE); } if(WIFEXITED(status)) { // completed if( set_complete(j, cpid) == -1 ) { printf("HANDLER set_complete went awry!\n"); _exit(EXIT_FAILURE); } } else if(WIFSIGNALED(status)) { // terminated set_complete(j, cpid); printf("\n"); //printf("TERMINATED: %d\n", WTERMSIG(status)); } else if(WIFSTOPPED(status)) { // stopped j->running = 0; if(j->fg) { send_back(job_list, j->pgid); printf("\nStopped: %s\n", j->rawcmd); } else { // queue stopped message message *m = malloc(sizeof(message)); copy_to_buf(j->rawcmd, m->msg); m->status = 0; push(msg_q, PROCESS, (void *)m); } } else if(WIFCONTINUED(status)) { // continued j->running = 1; //printf("CONTINUED\n"); } if(j->complete) { j->running = 0; if(!j->fg) { // queue finished message message *m = malloc(sizeof(message)); copy_to_buf(j->rawcmd, m->msg); m->status = 1; push(msg_q, PROCESS, (void *)m); free_job(del_job(job_list, j->pgid)); } } } //printf("HANDLER Done with waitpid loop\n"); }
static void *_resize_handler(int sig) { int startx = 0, starty = 0; int height = 40, width = 100; int check_width = min_screen_width; main_ycord = 1; /* clear existing data and update to avoid ghost during resize */ clear_window(text_win); clear_window(grid_win); doupdate(); delwin(grid_win); delwin(text_win); endwin(); initscr(); doupdate(); /* update now to make sure we get the new size */ if (params.cluster_dims == 4) { height = dim_size[2] * dim_size[3] + dim_size[2] + 3; width = (dim_size[1] + dim_size[3] + 1) * dim_size[0]; check_width += width; } else if (params.cluster_dims == 3) { height = dim_size[1] * dim_size[2] + dim_size[1] + 3; width = dim_size[0] + dim_size[2] + 3; check_width += width; } else { height = 10; width = COLS; } if (COLS < check_width || LINES < height) { endwin(); error("Screen is too small make sure " "the screen is at least %dx%d\n" "Right now it is %dx%d\n", width, height, COLS, LINES); _smap_exit(0); /* Calls exit(), no return */ } grid_win = newwin(height, width, starty, startx); max_display = (getmaxy(grid_win) - 1) * (getmaxx(grid_win) - 1); if (params.cluster_dims == 4) { startx = width; width = COLS - width - 2; height = LINES; } else if (params.cluster_dims == 3) { startx = width; width = COLS - width - 2; height = LINES; } else { startx = 0; starty = height; height = LINES - height; } text_win = newwin(height, width, starty, startx); print_date(); switch (params.display) { case JOBS: get_job(); break; case RESERVATIONS: get_reservation(); break; case SLURMPART: get_slurm_part(); break; case COMMANDS: #ifdef HAVE_BG get_command(); #endif break; case BGPART: if (params.cluster_flags & CLUSTER_FLAG_BG) get_bg_part(); break; } print_grid(); box(text_win, 0, 0); box(grid_win, 0, 0); wnoutrefresh(text_win); wnoutrefresh(grid_win); doupdate(); resize_screen = 1; return NULL; }
int main(int argc, char **argv) { log_options_t opts = LOG_OPTS_STDERR_ONLY; node_info_msg_t *node_info_ptr = NULL; node_info_msg_t *new_node_ptr = NULL; int error_code; int height = 40; int width = 100; int startx = 0; int starty = 0; int end = 0; int i; int rc; slurm_conf_init(NULL); log_init(xbasename(argv[0]), opts, SYSLOG_FACILITY_DAEMON, NULL); parse_command_line(argc, argv); if (params.verbose) { opts.stderr_level += params.verbose; log_alter(opts, SYSLOG_FACILITY_USER, NULL); } if (params.cluster_dims == 4) { min_screen_width = 92; } else if (params.cluster_dims == 3) min_screen_width = 92; /* no need for this if you are resolving */ while (slurm_load_node((time_t) NULL, &new_node_ptr, SHOW_ALL)) { if (params.resolve || (params.display == COMMANDS)) { new_node_ptr = NULL; break; /* just continue */ } error_code = slurm_get_errno(); printf("slurm_load_node: %s\n", slurm_strerror(error_code)); if (params.iterate == 0) exit(1); sleep(10); /* keep trying to reconnect */ } select_g_ba_init(new_node_ptr, 0); if (dim_size == NULL) { dim_size = get_cluster_dims(new_node_ptr); if ((dim_size == NULL) || (dim_size[0] < 1)) fatal("Invalid system dimensions"); } _init_colors(); if (params.resolve) { char *ret_str = resolve_mp(params.resolve, new_node_ptr); if (ret_str) { printf("%s", ret_str); xfree(ret_str); } _smap_exit(0); /* Calls exit(), no return */ } if (!params.commandline) { int check_width = min_screen_width; initscr(); init_grid(new_node_ptr, COLS); signal(SIGWINCH, (void (*)(int))_resize_handler); if (params.cluster_dims == 4) { height = dim_size[2] * dim_size[3] + dim_size[2] + 3; width = (dim_size[1] + dim_size[3] + 1) * dim_size[0] + 2; check_width += width; } else if (params.cluster_dims == 3) { height = dim_size[1] * dim_size[2] + dim_size[1] + 3; width = dim_size[0] + dim_size[2] + 3; check_width += width; } else { height = 10; width = COLS; } if ((COLS < check_width) || (LINES < height)) { endwin(); error("Screen is too small make sure the screen " "is at least %dx%d\n" "Right now it is %dx%d\n", check_width, height, COLS, LINES); _smap_exit(1); /* Calls exit(), no return */ } raw(); keypad(stdscr, true); noecho(); cbreak(); curs_set(0); nodelay(stdscr, true); start_color(); _set_pairs(); grid_win = newwin(height, width, starty, startx); max_display = (getmaxy(grid_win) - 1) * (getmaxx(grid_win) - 1); if (params.cluster_dims == 4) { startx = width; width = COLS - width - 2; height = LINES; } else if (params.cluster_dims == 3) { startx = width; width = COLS - width - 2; height = LINES; } else { startx = 0; starty = height; height = LINES - height; } text_win = newwin(height, width, starty, startx); } while (!end) { if (!params.commandline) { _get_option(); redraw: clear_window(text_win); clear_window(grid_win); move(0, 0); update_grid(new_node_ptr); main_xcord = 1; main_ycord = 1; } if (!params.no_header) print_date(); clear_grid(); switch (params.display) { case JOBS: get_job(); break; case RESERVATIONS: get_reservation(); break; case SLURMPART: get_slurm_part(); break; case COMMANDS: #ifdef HAVE_BG wclear(text_win); get_command(); #else error("Must be on a real BG SYSTEM to " "run this command"); if (!params.commandline) endwin(); _smap_exit(1); /* Calls exit(), no return */ #endif break; case BGPART: if (params.cluster_flags & CLUSTER_FLAG_BG) get_bg_part(); else { error("Must be on a BG SYSTEM to " "run this command"); if (!params.commandline) endwin(); _smap_exit(1); /* Calls exit(), no return */ } break; } if (!params.commandline) { box(text_win, 0, 0); wnoutrefresh(text_win); print_grid(); box(grid_win, 0, 0); wnoutrefresh(grid_win); doupdate(); node_info_ptr = new_node_ptr; if (node_info_ptr) { error_code = slurm_load_node( node_info_ptr->last_update, &new_node_ptr, SHOW_ALL); if (error_code == SLURM_SUCCESS) slurm_free_node_info_msg( node_info_ptr); else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) { error_code = SLURM_SUCCESS; new_node_ptr = node_info_ptr; } } else { error_code = slurm_load_node( (time_t) NULL, &new_node_ptr, SHOW_ALL); } if (error_code && (quiet_flag != 1)) { if (!params.commandline) { mvwprintw( text_win, main_ycord, 1, "slurm_load_node: %s", slurm_strerror( slurm_get_errno())); main_ycord++; } else { printf("slurm_load_node: %s", slurm_strerror( slurm_get_errno())); } } } if (params.iterate) { for (i = 0; i < params.iterate; i++) { sleep(1); if (!params.commandline) { if ((rc = _get_option()) == 1) goto redraw; else if (resize_screen) { resize_screen = 0; goto redraw; } } } } else break; } if (!params.commandline) { nodelay(stdscr, false); getch(); endwin(); } _smap_exit(0); /* Calls exit(), no return */ exit(0); /* Redundant, but eliminates compiler warning */ }