/* * Create job description structure based off srun options * (see opt.h) */ job_desc_msg_t * job_desc_msg_create_from_opts (void) { job_desc_msg_t *j = xmalloc(sizeof(*j)); hostlist_t hl = NULL; slurm_init_job_desc_msg(j); #if defined HAVE_ALPS_CRAY && defined HAVE_REAL_CRAY uint64_t pagg_id = job_getjid(getpid()); /* * Interactive sessions require pam_job.so in /etc/pam.d/common-session * since creating sgi_job containers requires root permissions. This is * the only exception where we allow the fallback of using the SID to * confirm the reservation (caught later, in do_basil_confirm). */ if (pagg_id == (uint64_t)-1) { error("No SGI job container ID detected - please enable the " "Cray job service via /etc/init.d/job"); } else { if (!j->select_jobinfo) j->select_jobinfo = select_g_select_jobinfo_alloc(); select_g_select_jobinfo_set(j->select_jobinfo, SELECT_JOBDATA_PAGG_ID, &pagg_id); } #endif j->contiguous = opt.contiguous; if (opt.core_spec) j->core_spec = opt.core_spec; j->features = opt.constraints; j->gres = opt.gres; if (opt.immediate == 1) j->immediate = opt.immediate; if (opt.job_name) j->name = opt.job_name; else j->name = opt.cmd_name; if (opt.argc > 0) { j->argc = 1; j->argv = (char **) xmalloc(sizeof(char *) * 2); j->argv[0] = xstrdup(opt.argv[0]); } if (opt.acctg_freq) j->acctg_freq = xstrdup(opt.acctg_freq); j->reservation = opt.reservation; j->wckey = opt.wckey; j->req_nodes = xstrdup(opt.nodelist); /* simplify the job allocation nodelist, * not laying out tasks until step */ if (j->req_nodes) { hl = hostlist_create(j->req_nodes); xfree(opt.nodelist); opt.nodelist = hostlist_ranged_string_xmalloc(hl); hostlist_uniq(hl); xfree(j->req_nodes); j->req_nodes = hostlist_ranged_string_xmalloc(hl); hostlist_destroy(hl); } if (opt.distribution == SLURM_DIST_ARBITRARY && !j->req_nodes) { error("With Arbitrary distribution you need to " "specify a nodelist or hostfile with the -w option"); return NULL; } j->exc_nodes = opt.exc_nodes; j->partition = opt.partition; j->min_nodes = opt.min_nodes; if (opt.sockets_per_node != NO_VAL) j->sockets_per_node = opt.sockets_per_node; if (opt.cores_per_socket != NO_VAL) j->cores_per_socket = opt.cores_per_socket; if (opt.threads_per_core != NO_VAL) j->threads_per_core = opt.threads_per_core; j->user_id = opt.uid; j->dependency = opt.dependency; if (opt.nice) j->nice = NICE_OFFSET + opt.nice; if (opt.priority) j->priority = opt.priority; if (opt.cpu_bind) j->cpu_bind = opt.cpu_bind; if (opt.cpu_bind_type) j->cpu_bind_type = opt.cpu_bind_type; if (opt.mem_bind) j->mem_bind = opt.mem_bind; if (opt.mem_bind_type) j->mem_bind_type = opt.mem_bind_type; if (opt.plane_size != NO_VAL) j->plane_size = opt.plane_size; j->task_dist = opt.distribution; j->group_id = opt.gid; j->mail_type = opt.mail_type; if (opt.ntasks_per_node != NO_VAL) j->ntasks_per_node = opt.ntasks_per_node; if (opt.ntasks_per_socket != NO_VAL) j->ntasks_per_socket = opt.ntasks_per_socket; if (opt.ntasks_per_core != NO_VAL) j->ntasks_per_core = opt.ntasks_per_core; if (opt.mail_user) j->mail_user = opt.mail_user; if (opt.begin) j->begin_time = opt.begin; if (opt.licenses) j->licenses = opt.licenses; if (opt.network) j->network = opt.network; if (opt.profile) j->profile = opt.profile; if (opt.account) j->account = opt.account; if (opt.comment) j->comment = opt.comment; if (opt.qos) j->qos = opt.qos; if (opt.cwd) j->work_dir = opt.cwd; if (opt.hold) j->priority = 0; if (opt.jobid != NO_VAL) j->job_id = opt.jobid; #ifdef HAVE_BG if (opt.geometry[0] > 0) { int i; for (i = 0; i < SYSTEM_DIMENSIONS; i++) j->geometry[i] = opt.geometry[i]; } #endif memcpy(j->conn_type, opt.conn_type, sizeof(j->conn_type)); if (opt.reboot) j->reboot = 1; if (opt.no_rotate) j->rotate = 0; if (opt.blrtsimage) j->blrtsimage = opt.blrtsimage; if (opt.linuximage) j->linuximage = opt.linuximage; if (opt.mloaderimage) j->mloaderimage = opt.mloaderimage; if (opt.ramdiskimage) j->ramdiskimage = opt.ramdiskimage; if (opt.max_nodes) j->max_nodes = opt.max_nodes; else if (opt.nodes_set) { /* On an allocation if the max nodes isn't set set it * to do the same behavior as with salloc or sbatch. */ j->max_nodes = opt.min_nodes; } if (opt.pn_min_cpus != NO_VAL) j->pn_min_cpus = opt.pn_min_cpus; if (opt.pn_min_memory != NO_VAL) j->pn_min_memory = opt.pn_min_memory; else if (opt.mem_per_cpu != NO_VAL) j->pn_min_memory = opt.mem_per_cpu | MEM_PER_CPU; if (opt.pn_min_tmp_disk != NO_VAL) j->pn_min_tmp_disk = opt.pn_min_tmp_disk; if (opt.overcommit) { j->min_cpus = opt.min_nodes; j->overcommit = opt.overcommit; } else if (opt.cpus_set) j->min_cpus = opt.ntasks * opt.cpus_per_task; else j->min_cpus = opt.ntasks; if (opt.ntasks_set) j->num_tasks = opt.ntasks; if (opt.cpus_set) j->cpus_per_task = opt.cpus_per_task; if (opt.no_kill) j->kill_on_node_fail = 0; if (opt.time_limit != NO_VAL) j->time_limit = opt.time_limit; if (opt.time_min != NO_VAL) j->time_min = opt.time_min; j->shared = opt.shared; if (opt.warn_signal) j->warn_signal = opt.warn_signal; if (opt.warn_time) j->warn_time = opt.warn_time; if (opt.req_switch >= 0) j->req_switch = opt.req_switch; if (opt.wait4switch >= 0) j->wait4switch = opt.wait4switch; /* srun uses the same listening port for the allocation response * message as all other messages */ j->alloc_resp_port = slurmctld_comm_addr.port; j->other_port = slurmctld_comm_addr.port; if (opt.spank_job_env_size) { j->spank_job_env = opt.spank_job_env; j->spank_job_env_size = opt.spank_job_env_size; } return (j); }
static int _job_modify(uint32_t jobid, char *bank_ptr, char *depend_ptr, char *new_hostlist, uint32_t new_node_cnt, char *part_name_ptr, uint32_t new_time_limit, char *name_ptr, char *start_ptr, char *feature_ptr, char *env_ptr, char *comment_ptr, char *gres_ptr, char *wckey_ptr) { struct job_record *job_ptr; time_t now = time(NULL); bool update_accounting = false; job_ptr = find_job_record(jobid); if (job_ptr == NULL) { error("wiki: MODIFYJOB has invalid jobid %u", jobid); return ESLURM_INVALID_JOB_ID; } if (IS_JOB_FINISHED(job_ptr) || (job_ptr->details == NULL)) { info("wiki: MODIFYJOB jobid %u is finished", jobid); return ESLURM_DISABLED; } if (comment_ptr) { info("wiki: change job %u comment %s", jobid, comment_ptr); xfree(job_ptr->comment); job_ptr->comment = xstrdup(comment_ptr); last_job_update = now; } if (depend_ptr) { int rc = update_job_dependency(job_ptr, depend_ptr); if (rc == SLURM_SUCCESS) { info("wiki: changed job %u dependency to %s", jobid, depend_ptr); } else { error("wiki: changing job %u dependency to %s", jobid, depend_ptr); return EINVAL; } } if (env_ptr) { bool have_equal = false; char old_sep[1]; int begin = 0, i; if (job_ptr->batch_flag == 0) { error("wiki: attempt to set environment variables " "for non-batch job %u", jobid); return ESLURM_DISABLED; } for (i=0; ; i++) { if (env_ptr[i] == '=') { if (have_equal) { error("wiki: setting job %u invalid " "environment variables: %s", jobid, env_ptr); return EINVAL; } have_equal = true; if (env_ptr[i+1] == '\"') { for (i+=2; ; i++) { if (env_ptr[i] == '\0') { error("wiki: setting job %u " "invalid environment " "variables: %s", jobid, env_ptr); return EINVAL; } if (env_ptr[i] == '\"') { i++; break; } if (env_ptr[i] == '\\') { i++; } } } else if (env_ptr[i+1] == '\'') { for (i+=2; ; i++) { if (env_ptr[i] == '\0') { error("wiki: setting job %u " "invalid environment " "variables: %s", jobid, env_ptr); return EINVAL; } if (env_ptr[i] == '\'') { i++; break; } if (env_ptr[i] == '\\') { i++; } } } } if (isspace(env_ptr[i]) || (env_ptr[i] == ',')) { if (!have_equal) { error("wiki: setting job %u invalid " "environment variables: %s", jobid, env_ptr); return EINVAL; } old_sep[0] = env_ptr[i]; env_ptr[i] = '\0'; xrealloc(job_ptr->details->env_sup, sizeof(char *) * (job_ptr->details->env_cnt+1)); job_ptr->details->env_sup [job_ptr->details->env_cnt++] = xstrdup(&env_ptr[begin]); info("wiki: for job %u add env: %s", jobid, &env_ptr[begin]); env_ptr[i] = old_sep[0]; if (isspace(old_sep[0])) break; begin = i + 1; have_equal = false; } } } if (new_time_limit) { time_t old_time = job_ptr->time_limit; job_ptr->time_limit = new_time_limit; info("wiki: change job %u time_limit to %u", jobid, new_time_limit); /* Update end_time based upon change * to preserve suspend time info */ job_ptr->end_time = job_ptr->end_time + ((job_ptr->time_limit - old_time) * 60); last_job_update = now; } if (bank_ptr && (update_job_account("wiki", job_ptr, bank_ptr) != SLURM_SUCCESS)) { return EINVAL; } if (feature_ptr) { if (IS_JOB_PENDING(job_ptr) && (job_ptr->details)) { info("wiki: change job %u features to %s", jobid, feature_ptr); job_ptr->details->features = xstrdup(feature_ptr); last_job_update = now; } else { error("wiki: MODIFYJOB features of non-pending " "job %u", jobid); return ESLURM_DISABLED; } } if (start_ptr) { char *end_ptr; uint32_t begin_time = strtol(start_ptr, &end_ptr, 10); if (IS_JOB_PENDING(job_ptr) && (job_ptr->details)) { info("wiki: change job %u begin time to %u", jobid, begin_time); job_ptr->details->begin_time = begin_time; last_job_update = now; update_accounting = true; } else { error("wiki: MODIFYJOB begin_time of non-pending " "job %u", jobid); return ESLURM_DISABLED; } } if (name_ptr) { if (IS_JOB_PENDING(job_ptr)) { info("wiki: change job %u name %s", jobid, name_ptr); xfree(job_ptr->name); job_ptr->name = xstrdup(name_ptr); last_job_update = now; update_accounting = true; } else { error("wiki: MODIFYJOB name of non-pending job %u", jobid); return ESLURM_DISABLED; } } if (new_hostlist) { int rc = 0, task_cnt; hostlist_t hl; char *tasklist; if (!IS_JOB_PENDING(job_ptr) || !job_ptr->details) { /* Job is done, nothing to reset */ if (new_hostlist == '\0') goto host_fini; error("wiki: MODIFYJOB hostlist of non-pending " "job %u", jobid); return ESLURM_DISABLED; } xfree(job_ptr->details->req_nodes); FREE_NULL_BITMAP(job_ptr->details->req_node_bitmap); if (new_hostlist == '\0') goto host_fini; tasklist = moab2slurm_task_list(new_hostlist, &task_cnt); if (tasklist == NULL) { rc = 1; goto host_fini; } hl = hostlist_create(tasklist); if (hl == 0) { rc = 1; goto host_fini; } hostlist_uniq(hl); hostlist_sort(hl); job_ptr->details->req_nodes = hostlist_ranged_string_xmalloc(hl); hostlist_destroy(hl); if (job_ptr->details->req_nodes == NULL) { rc = 1; goto host_fini; } if (node_name2bitmap(job_ptr->details->req_nodes, false, &job_ptr->details->req_node_bitmap)) { rc = 1; goto host_fini; } host_fini: if (rc) { info("wiki: change job %u invalid hostlist %s", jobid, new_hostlist); xfree(job_ptr->details->req_nodes); return EINVAL; } else { info("wiki: change job %u hostlist %s", jobid, new_hostlist); update_accounting = true; } } if (part_name_ptr) { struct part_record *part_ptr; if (!IS_JOB_PENDING(job_ptr)) { error("wiki: MODIFYJOB partition of non-pending " "job %u", jobid); return ESLURM_DISABLED; } part_ptr = find_part_record(part_name_ptr); if (part_ptr == NULL) { error("wiki: MODIFYJOB has invalid partition %s", part_name_ptr); return ESLURM_INVALID_PARTITION_NAME; } info("wiki: change job %u partition %s", jobid, part_name_ptr); xfree(job_ptr->partition); job_ptr->partition = xstrdup(part_name_ptr); job_ptr->part_ptr = part_ptr; last_job_update = now; update_accounting = true; } if (new_node_cnt) { job_desc_msg_t job_desc; #ifdef HAVE_BG uint16_t geometry[SYSTEM_DIMENSIONS] = {(uint16_t) NO_VAL}; static uint16_t cpus_per_node = 0; if (!cpus_per_node) { select_g_alter_node_cnt(SELECT_GET_NODE_CPU_CNT, &cpus_per_node); } #endif if(!IS_JOB_PENDING(job_ptr) || !job_ptr->details) { error("wiki: MODIFYJOB node count of non-pending " "job %u", jobid); return ESLURM_DISABLED; } memset(&job_desc, 0, sizeof(job_desc_msg_t)); job_desc.min_nodes = new_node_cnt; job_desc.max_nodes = NO_VAL; job_desc.select_jobinfo = select_g_select_jobinfo_alloc(); select_g_alter_node_cnt(SELECT_SET_NODE_CNT, &job_desc); select_g_select_jobinfo_free(job_desc.select_jobinfo); job_ptr->details->min_nodes = job_desc.min_nodes; if (job_ptr->details->max_nodes && (job_ptr->details->max_nodes < job_desc.min_nodes)) job_ptr->details->max_nodes = job_desc.min_nodes; info("wiki: change job %u min_nodes to %u", jobid, new_node_cnt); #ifdef HAVE_BG job_ptr->details->min_cpus = job_desc.min_cpus; job_ptr->details->max_cpus = job_desc.max_cpus; job_ptr->details->pn_min_cpus = job_desc.pn_min_cpus; new_node_cnt = job_ptr->details->min_cpus; if (cpus_per_node) new_node_cnt /= cpus_per_node; /* This is only set up so accounting is set up correctly */ select_g_select_jobinfo_set(job_ptr->select_jobinfo, SELECT_JOBDATA_NODE_CNT, &new_node_cnt); /* reset geo since changing this makes any geo potentially invalid */ select_g_select_jobinfo_set(job_ptr->select_jobinfo, SELECT_JOBDATA_GEOMETRY, geometry); #endif last_job_update = now; update_accounting = true; } if (gres_ptr) { char *orig_gres; if (!IS_JOB_PENDING(job_ptr)) { error("wiki: MODIFYJOB GRES of non-pending job %u", jobid); return ESLURM_DISABLED; } orig_gres = job_ptr->gres; job_ptr->gres = NULL; if (gres_ptr[0]) job_ptr->gres = xstrdup(gres_ptr); if (gres_plugin_job_state_validate(job_ptr->gres, &job_ptr->gres_list)) { error("wiki: MODIFYJOB Invalid GRES=%s", gres_ptr); xfree(job_ptr->gres); job_ptr->gres = orig_gres; return ESLURM_INVALID_GRES; } xfree(orig_gres); } if (wckey_ptr) { int rc = update_job_wckey("update_job", job_ptr, wckey_ptr); if (rc != SLURM_SUCCESS) { error("wiki: MODIFYJOB Invalid WCKEY=%s", wckey_ptr); return rc; } } if (update_accounting) { if (job_ptr->details && job_ptr->details->begin_time) { /* Update job record in accounting to reflect * the changes */ jobacct_storage_g_job_start(acct_db_conn, job_ptr); } } return SLURM_SUCCESS; }
/* create a slurmd job structure from a launch tasks message */ extern stepd_step_rec_t * stepd_step_rec_create(launch_tasks_request_msg_t *msg) { stepd_step_rec_t *job = NULL; srun_info_t *srun = NULL; slurm_addr_t resp_addr; slurm_addr_t io_addr; int i, nodeid = NO_VAL; xassert(msg != NULL); xassert(msg->complete_nodelist != NULL); debug3("entering stepd_step_rec_create"); if (!_valid_uid_gid((uid_t)msg->uid, &(msg->gid), &(msg->user_name))) return NULL; if (_check_acct_freq_task(msg->job_mem_lim, msg->acctg_freq)) return NULL; job = xmalloc(sizeof(stepd_step_rec_t)); #ifndef HAVE_FRONT_END nodeid = nodelist_find(msg->complete_nodelist, conf->node_name); job->node_name = xstrdup(conf->node_name); #else nodeid = 0; job->node_name = xstrdup(msg->complete_nodelist); #endif if (nodeid < 0) { error("couldn't find node %s in %s", job->node_name, msg->complete_nodelist); stepd_step_rec_destroy(job); return NULL; } job->state = SLURMSTEPD_STEP_STARTING; job->node_tasks = msg->tasks_to_launch[nodeid]; job->ntasks = msg->ntasks; job->jobid = msg->job_id; job->stepid = msg->job_step_id; job->uid = (uid_t) msg->uid; job->user_name = xstrdup(msg->user_name); job->gid = (gid_t) msg->gid; job->cwd = xstrdup(msg->cwd); job->task_dist = msg->task_dist; job->cpu_bind_type = msg->cpu_bind_type; job->cpu_bind = xstrdup(msg->cpu_bind); job->mem_bind_type = msg->mem_bind_type; job->mem_bind = xstrdup(msg->mem_bind); job->cpu_freq = msg->cpu_freq; job->ckpt_dir = xstrdup(msg->ckpt_dir); job->restart_dir = xstrdup(msg->restart_dir); job->cpus_per_task = msg->cpus_per_task; job->env = _array_copy(msg->envc, msg->env); job->array_job_id = msg->job_id; job->array_task_id = (uint16_t) NO_VAL; for (i = 0; i < msg->envc; i++) { /* 1234567890123456789 */ if (!strncmp(msg->env[i], "SLURM_ARRAY_JOB_ID=", 19)) job->array_job_id = atoi(msg->env[i] + 19); /* 12345678901234567890 */ if (!strncmp(msg->env[i], "SLURM_ARRAY_TASK_ID=", 20)) job->array_task_id = atoi(msg->env[i] + 20); } job->eio = eio_handle_create(); job->sruns = list_create((ListDelF) _srun_info_destructor); job->clients = list_create(NULL); /* FIXME! Needs destructor */ job->stdout_eio_objs = list_create(NULL); /* FIXME! Needs destructor */ job->stderr_eio_objs = list_create(NULL); /* FIXME! Needs destructor */ job->free_incoming = list_create(NULL); /* FIXME! Needs destructor */ job->incoming_count = 0; job->free_outgoing = list_create(NULL); /* FIXME! Needs destructor */ job->outgoing_count = 0; job->outgoing_cache = list_create(NULL); /* FIXME! Needs destructor */ job->envtp = xmalloc(sizeof(env_t)); job->envtp->jobid = -1; job->envtp->stepid = -1; job->envtp->procid = -1; job->envtp->localid = -1; job->envtp->nodeid = -1; job->envtp->distribution = 0; job->envtp->cpu_bind_type = 0; job->envtp->cpu_bind = NULL; job->envtp->mem_bind_type = 0; job->envtp->mem_bind = NULL; job->envtp->ckpt_dir = NULL; job->envtp->comm_port = msg->resp_port[nodeid % msg->num_resp_port]; memcpy(&resp_addr, &msg->orig_addr, sizeof(slurm_addr_t)); slurm_set_addr(&resp_addr, msg->resp_port[nodeid % msg->num_resp_port], NULL); job->user_managed_io = msg->user_managed_io; if (!msg->user_managed_io) { memcpy(&io_addr, &msg->orig_addr, sizeof(slurm_addr_t)); slurm_set_addr(&io_addr, msg->io_port[nodeid % msg->num_io_port], NULL); } srun = srun_info_create(msg->cred, &resp_addr, &io_addr); job->buffered_stdio = msg->buffered_stdio; job->labelio = msg->labelio; job->profile = msg->profile; job->task_prolog = xstrdup(msg->task_prolog); job->task_epilog = xstrdup(msg->task_epilog); job->argc = msg->argc; job->argv = _array_copy(job->argc, msg->argv); job->nnodes = msg->nnodes; job->nodeid = nodeid; job->debug = msg->slurmd_debug; job->cpus = msg->cpus_allocated[nodeid]; /* This needs to happen before acct_gather_profile_startpoll and only really looks at the profile in the job. */ acct_gather_profile_g_node_step_start(job); acct_gather_profile_startpoll(msg->acctg_freq, conf->job_acct_gather_freq); job->multi_prog = msg->multi_prog; job->timelimit = (time_t) -1; job->task_flags = msg->task_flags; job->switch_job = msg->switch_job; job->pty = msg->pty; job->open_mode = msg->open_mode; job->options = msg->options; format_core_allocs(msg->cred, conf->node_name, conf->cpus, &job->job_alloc_cores, &job->step_alloc_cores, &job->job_mem, &job->step_mem); if (job->step_mem) { jobacct_gather_set_mem_limit(job->jobid, job->stepid, job->step_mem); } else if (job->job_mem) { jobacct_gather_set_mem_limit(job->jobid, job->stepid, job->job_mem); } #ifdef HAVE_ALPS_CRAY /* This is only used for Cray emulation mode where slurmd is used to * launch job steps. On a real Cray system, ALPS is used to launch * the tasks instead of SLURM. SLURM's task launch RPC does NOT * contain the reservation ID, so just use some non-zero value here * for testing purposes. */ job->resv_id = 1; select_g_select_jobinfo_set(msg->select_jobinfo, SELECT_JOBDATA_RESV_ID, &job->resv_id); #endif get_cred_gres(msg->cred, conf->node_name, &job->job_gres_list, &job->step_gres_list); list_append(job->sruns, (void *) srun); _job_init_task_info(job, msg->global_task_ids[nodeid], msg->ifname, msg->ofname, msg->efname); return job; }
/* create a slurmd job structure from a launch tasks message */ extern stepd_step_rec_t *stepd_step_rec_create(launch_tasks_request_msg_t *msg, uint16_t protocol_version) { stepd_step_rec_t *job = NULL; srun_info_t *srun = NULL; slurm_addr_t resp_addr; slurm_addr_t io_addr; int i, nodeid = NO_VAL; xassert(msg != NULL); xassert(msg->complete_nodelist != NULL); debug3("entering stepd_step_rec_create"); if (acct_gather_check_acct_freq_task(msg->job_mem_lim, msg->acctg_freq)) return NULL; job = xmalloc(sizeof(stepd_step_rec_t)); job->msg = msg; #ifndef HAVE_FRONT_END nodeid = nodelist_find(msg->complete_nodelist, conf->node_name); job->node_name = xstrdup(conf->node_name); #else nodeid = 0; job->node_name = xstrdup(msg->complete_nodelist); #endif if (nodeid < 0) { error("couldn't find node %s in %s", job->node_name, msg->complete_nodelist); stepd_step_rec_destroy(job); return NULL; } job->state = SLURMSTEPD_STEP_STARTING; slurm_cond_init(&job->state_cond, NULL); slurm_mutex_init(&job->state_mutex); job->node_tasks = msg->tasks_to_launch[nodeid]; i = sizeof(uint16_t) * msg->nnodes; job->task_cnts = xmalloc(i); memcpy(job->task_cnts, msg->tasks_to_launch, i); job->ntasks = msg->ntasks; job->jobid = msg->job_id; job->stepid = msg->job_step_id; job->uid = (uid_t) msg->uid; job->gid = (gid_t) msg->gid; job->user_name = xstrdup(msg->user_name); job->ngids = (int) msg->ngids; job->gids = copy_gids(msg->ngids, msg->gids); job->cwd = xstrdup(msg->cwd); job->task_dist = msg->task_dist; job->cpu_bind_type = msg->cpu_bind_type; job->cpu_bind = xstrdup(msg->cpu_bind); job->mem_bind_type = msg->mem_bind_type; job->mem_bind = xstrdup(msg->mem_bind); job->cpu_freq_min = msg->cpu_freq_min; job->cpu_freq_max = msg->cpu_freq_max; job->cpu_freq_gov = msg->cpu_freq_gov; job->ckpt_dir = xstrdup(msg->ckpt_dir); job->restart_dir = xstrdup(msg->restart_dir); job->cpus_per_task = msg->cpus_per_task; job->env = _array_copy(msg->envc, msg->env); job->array_job_id = msg->job_id; job->array_task_id = NO_VAL; job->node_offset = msg->node_offset; /* Used for env vars */ job->pack_jobid = msg->pack_jobid; /* Used for env vars */ job->pack_nnodes = msg->pack_nnodes; /* Used for env vars */ if (msg->pack_nnodes && msg->pack_ntasks && msg->pack_task_cnts) { job->pack_ntasks = msg->pack_ntasks; /* Used for env vars */ i = sizeof(uint16_t) * msg->pack_nnodes; job->pack_task_cnts = xmalloc(i); memcpy(job->pack_task_cnts, msg->pack_task_cnts, i); } job->pack_offset = msg->pack_offset; /* Used for env vars & labels */ job->pack_task_offset = msg->pack_task_offset; /* Used for env vars & labels */ job->pack_node_list = xstrdup(msg->pack_node_list); for (i = 0; i < msg->envc; i++) { /* 1234567890123456789 */ if (!xstrncmp(msg->env[i], "SLURM_ARRAY_JOB_ID=", 19)) job->array_job_id = atoi(msg->env[i] + 19); /* 12345678901234567890 */ if (!xstrncmp(msg->env[i], "SLURM_ARRAY_TASK_ID=", 20)) job->array_task_id = atoi(msg->env[i] + 20); } job->eio = eio_handle_create(0); job->sruns = list_create((ListDelF) _srun_info_destructor); /* * Based on my testing the next 3 lists here could use the * eio_obj_destroy, but if you do you can get an invalid read. Since * these stay until the end of the job it isn't that big of a deal. */ job->clients = list_create(NULL); /* FIXME! Needs destructor */ job->stdout_eio_objs = list_create(NULL); /* FIXME! Needs destructor */ job->stderr_eio_objs = list_create(NULL); /* FIXME! Needs destructor */ job->free_incoming = list_create(NULL); /* FIXME! Needs destructor */ job->incoming_count = 0; job->free_outgoing = list_create(NULL); /* FIXME! Needs destructor */ job->outgoing_count = 0; job->outgoing_cache = list_create(NULL); /* FIXME! Needs destructor */ job->envtp = xmalloc(sizeof(env_t)); job->envtp->jobid = -1; job->envtp->stepid = -1; job->envtp->procid = -1; job->envtp->localid = -1; job->envtp->nodeid = -1; job->envtp->distribution = 0; job->envtp->cpu_bind_type = 0; job->envtp->cpu_bind = NULL; job->envtp->mem_bind_type = 0; job->envtp->mem_bind = NULL; job->envtp->ckpt_dir = NULL; if (!msg->resp_port) msg->num_resp_port = 0; if (msg->num_resp_port) { job->envtp->comm_port = msg->resp_port[nodeid % msg->num_resp_port]; memcpy(&resp_addr, &msg->orig_addr, sizeof(slurm_addr_t)); slurm_set_addr(&resp_addr, msg->resp_port[nodeid % msg->num_resp_port], NULL); } else { memset(&resp_addr, 0, sizeof(slurm_addr_t)); } if (!msg->io_port) msg->flags |= LAUNCH_USER_MANAGED_IO; if ((msg->flags & LAUNCH_USER_MANAGED_IO) == 0) { memcpy(&io_addr, &msg->orig_addr, sizeof(slurm_addr_t)); slurm_set_addr(&io_addr, msg->io_port[nodeid % msg->num_io_port], NULL); } else { memset(&io_addr, 0, sizeof(slurm_addr_t)); } srun = srun_info_create(msg->cred, &resp_addr, &io_addr, protocol_version); job->profile = msg->profile; job->task_prolog = xstrdup(msg->task_prolog); job->task_epilog = xstrdup(msg->task_epilog); job->argc = msg->argc; job->argv = _array_copy(job->argc, msg->argv); job->nnodes = msg->nnodes; job->nodeid = nodeid; job->debug = msg->slurmd_debug; job->cpus = msg->node_cpus; job->job_core_spec = msg->job_core_spec; /* This needs to happen before acct_gather_profile_startpoll and only really looks at the profile in the job. */ acct_gather_profile_g_node_step_start(job); acct_gather_profile_startpoll(msg->acctg_freq, conf->job_acct_gather_freq); job->timelimit = (time_t) -1; job->flags = msg->flags; job->switch_job = msg->switch_job; job->open_mode = msg->open_mode; job->options = msg->options; format_core_allocs(msg->cred, conf->node_name, conf->cpus, &job->job_alloc_cores, &job->step_alloc_cores, &job->job_mem, &job->step_mem); /* If users have configured MemLimitEnforce=no * in their slurm.conf keep going. */ if (job->step_mem && conf->mem_limit_enforce) { jobacct_gather_set_mem_limit(job->jobid, job->stepid, job->step_mem); } else if (job->job_mem && conf->mem_limit_enforce) { jobacct_gather_set_mem_limit(job->jobid, job->stepid, job->job_mem); } #ifdef HAVE_ALPS_CRAY /* This is only used for Cray emulation mode where slurmd is used to * launch job steps. On a real Cray system, ALPS is used to launch * the tasks instead of SLURM. SLURM's task launch RPC does NOT * contain the reservation ID, so just use some non-zero value here * for testing purposes. */ job->resv_id = 1; select_g_select_jobinfo_set(msg->select_jobinfo, SELECT_JOBDATA_RESV_ID, &job->resv_id); #endif /* only need these values on the extern step, don't copy otherwise */ if ((msg->job_step_id == SLURM_EXTERN_CONT) && msg->x11) { job->x11 = msg->x11; job->x11_magic_cookie = xstrdup(msg->x11_magic_cookie); job->x11_target_host = xstrdup(msg->x11_target_host); job->x11_target_port = msg->x11_target_port; } get_cred_gres(msg->cred, conf->node_name, &job->job_gres_list, &job->step_gres_list); list_append(job->sruns, (void *) srun); _job_init_task_info(job, msg->global_task_ids, msg->ifname, msg->ofname, msg->efname); return job; }
/* Returns 0 on success, -1 on failure */ static int _fill_job_desc_from_opts(job_desc_msg_t *desc) { #ifdef HAVE_REAL_CRAY uint64_t pagg_id = job_getjid(getpid()); /* * Interactive sessions require pam_job.so in /etc/pam.d/common-session * since creating sgi_job containers requires root permissions. This is * the only exception where we allow the fallback of using the SID to * confirm the reservation (caught later, in do_basil_confirm). */ if (pagg_id == (uint64_t)-1) { error("No SGI job container ID detected - please enable the " "Cray job service via /etc/init.d/job"); } else { if (!desc->select_jobinfo) desc->select_jobinfo = select_g_select_jobinfo_alloc(); select_g_select_jobinfo_set(desc->select_jobinfo, SELECT_JOBDATA_PAGG_ID, &pagg_id); } #endif desc->contiguous = opt.contiguous ? 1 : 0; desc->features = opt.constraints; desc->gres = opt.gres; if (opt.immediate == 1) desc->immediate = 1; desc->name = xstrdup(opt.job_name); desc->reservation = xstrdup(opt.reservation); desc->wckey = xstrdup(opt.wckey); desc->req_nodes = opt.nodelist; desc->exc_nodes = opt.exc_nodes; desc->partition = opt.partition; desc->min_nodes = opt.min_nodes; if (opt.max_nodes) desc->max_nodes = opt.max_nodes; desc->user_id = opt.uid; desc->group_id = opt.gid; if (opt.dependency) desc->dependency = xstrdup(opt.dependency); if (opt.cpu_bind) desc->cpu_bind = opt.cpu_bind; if (opt.cpu_bind_type) desc->cpu_bind_type = opt.cpu_bind_type; if (opt.mem_bind) desc->mem_bind = opt.mem_bind; if (opt.mem_bind_type) desc->mem_bind_type = opt.mem_bind_type; if (opt.plane_size != NO_VAL) desc->plane_size = opt.plane_size; desc->task_dist = opt.distribution; if (opt.plane_size != NO_VAL) desc->plane_size = opt.plane_size; if (opt.licenses) desc->licenses = xstrdup(opt.licenses); desc->network = opt.network; if (opt.nice) desc->nice = NICE_OFFSET + opt.nice; desc->mail_type = opt.mail_type; if (opt.mail_user) desc->mail_user = xstrdup(opt.mail_user); if (opt.begin) desc->begin_time = opt.begin; if (opt.account) desc->account = xstrdup(opt.account); if (opt.acctg_freq >= 0) desc->acctg_freq = opt.acctg_freq; if (opt.comment) desc->comment = xstrdup(opt.comment); if (opt.qos) desc->qos = xstrdup(opt.qos); if (opt.cwd) desc->work_dir = xstrdup(opt.cwd); else if (work_dir) desc->work_dir = xstrdup(work_dir); if (opt.hold) desc->priority = 0; #ifdef HAVE_BG if (opt.geometry[0] > 0) { int i; for (i=0; i<SYSTEM_DIMENSIONS; i++) desc->geometry[i] = opt.geometry[i]; } #endif if (opt.conn_type != (uint16_t)NO_VAL) desc->conn_type[0] = opt.conn_type; if (opt.reboot) desc->reboot = 1; if (opt.no_rotate) desc->rotate = 0; if (opt.blrtsimage) desc->blrtsimage = xstrdup(opt.blrtsimage); if (opt.linuximage) desc->linuximage = xstrdup(opt.linuximage); if (opt.mloaderimage) desc->mloaderimage = xstrdup(opt.mloaderimage); if (opt.ramdiskimage) desc->ramdiskimage = xstrdup(opt.ramdiskimage); /* job constraints */ if (opt.mincpus > -1) desc->pn_min_cpus = opt.mincpus; if (opt.realmem > -1) desc->pn_min_memory = opt.realmem; else if (opt.mem_per_cpu > -1) desc->pn_min_memory = opt.mem_per_cpu | MEM_PER_CPU; if (opt.tmpdisk > -1) desc->pn_min_tmp_disk = opt.tmpdisk; if (opt.overcommit) { desc->min_cpus = opt.min_nodes; desc->overcommit = opt.overcommit; } else desc->min_cpus = opt.ntasks * opt.cpus_per_task; if (opt.ntasks_set) desc->num_tasks = opt.ntasks; if (opt.cpus_set) desc->cpus_per_task = opt.cpus_per_task; if (opt.ntasks_per_node) desc->ntasks_per_node = opt.ntasks_per_node; if (opt.ntasks_per_socket > -1) desc->ntasks_per_socket = opt.ntasks_per_socket; if (opt.ntasks_per_core > -1) desc->ntasks_per_core = opt.ntasks_per_core; /* node constraints */ if (opt.sockets_per_node != NO_VAL) desc->sockets_per_node = opt.sockets_per_node; if (opt.cores_per_socket != NO_VAL) desc->cores_per_socket = opt.cores_per_socket; if (opt.threads_per_core != NO_VAL) desc->threads_per_core = opt.threads_per_core; if (opt.no_kill) desc->kill_on_node_fail = 0; if (opt.time_limit != NO_VAL) desc->time_limit = opt.time_limit; if (opt.time_min != NO_VAL) desc->time_min = opt.time_min; desc->shared = opt.shared; desc->job_id = opt.jobid; desc->wait_all_nodes = opt.wait_all_nodes; if (opt.warn_signal) desc->warn_signal = opt.warn_signal; if (opt.warn_time) desc->warn_time = opt.warn_time; if (opt.spank_job_env_size) { desc->spank_job_env = opt.spank_job_env; desc->spank_job_env_size = opt.spank_job_env_size; } return 0; }
/* * Create job description structure based off srun options * (see opt.h) */ static job_desc_msg_t *_job_desc_msg_create_from_opts(slurm_opt_t *opt_local) { srun_opt_t *srun_opt = opt_local->srun_opt; job_desc_msg_t *j = xmalloc(sizeof(*j)); hostlist_t hl = NULL; xassert(srun_opt); slurm_init_job_desc_msg(j); #if defined HAVE_ALPS_CRAY && defined HAVE_REAL_CRAY static bool sgi_err_logged = false; uint64_t pagg_id = job_getjid(getpid()); /* * Interactive sessions require pam_job.so in /etc/pam.d/common-session * since creating sgi_job containers requires root permissions. This is * the only exception where we allow the fallback of using the SID to * confirm the reservation (caught later, in do_basil_confirm). */ if (pagg_id != (uint64_t) -1) { if (!j->select_jobinfo) j->select_jobinfo = select_g_select_jobinfo_alloc(); select_g_select_jobinfo_set(j->select_jobinfo, SELECT_JOBDATA_PAGG_ID, &pagg_id); } else if (!sgi_err_logged) { error("No SGI job container ID detected - please enable the " "Cray job service via /etc/init.d/job"); sgi_err_logged = true; } #endif j->contiguous = opt_local->contiguous; if (opt_local->core_spec != NO_VAL16) j->core_spec = opt_local->core_spec; j->features = opt_local->constraints; j->cluster_features = opt_local->c_constraints; if (opt_local->gres && xstrcasecmp(opt_local->gres, "NONE")) j->gres = opt_local->gres; if (opt_local->immediate == 1) j->immediate = opt_local->immediate; if (opt_local->job_name) j->name = opt_local->job_name; else j->name = srun_opt->cmd_name; if (srun_opt->argc > 0) { j->argc = 1; j->argv = (char **) xmalloc(sizeof(char *) * 2); j->argv[0] = xstrdup(srun_opt->argv[0]); } if (opt_local->acctg_freq) j->acctg_freq = xstrdup(opt_local->acctg_freq); j->reservation = opt_local->reservation; j->wckey = opt_local->wckey; j->x11 = opt.x11; if (j->x11) { j->x11_magic_cookie = xstrdup(opt.x11_magic_cookie); j->x11_target_port = opt.x11_target_port; } j->req_nodes = xstrdup(opt_local->nodelist); /* simplify the job allocation nodelist, * not laying out tasks until step */ if (j->req_nodes) { hl = hostlist_create(j->req_nodes); xfree(opt_local->nodelist); opt_local->nodelist = hostlist_ranged_string_xmalloc(hl); hostlist_uniq(hl); xfree(j->req_nodes); j->req_nodes = hostlist_ranged_string_xmalloc(hl); hostlist_destroy(hl); } if (((opt_local->distribution & SLURM_DIST_STATE_BASE) == SLURM_DIST_ARBITRARY) && !j->req_nodes) { error("With Arbitrary distribution you need to " "specify a nodelist or hostfile with the -w option"); return NULL; } j->extra = opt_local->extra; j->exc_nodes = opt_local->exc_nodes; j->partition = opt_local->partition; j->min_nodes = opt_local->min_nodes; if (opt_local->sockets_per_node != NO_VAL) j->sockets_per_node = opt_local->sockets_per_node; if (opt_local->cores_per_socket != NO_VAL) j->cores_per_socket = opt_local->cores_per_socket; if (opt_local->threads_per_core != NO_VAL) { j->threads_per_core = opt_local->threads_per_core; /* if 1 always make sure affinity knows about it */ if (j->threads_per_core == 1) srun_opt->cpu_bind_type |= CPU_BIND_ONE_THREAD_PER_CORE; } j->user_id = opt_local->uid; j->dependency = opt_local->dependency; if (opt_local->nice != NO_VAL) j->nice = NICE_OFFSET + opt_local->nice; if (opt_local->priority) j->priority = opt_local->priority; if (srun_opt->cpu_bind) j->cpu_bind = srun_opt->cpu_bind; if (srun_opt->cpu_bind_type) j->cpu_bind_type = srun_opt->cpu_bind_type; if (opt_local->delay_boot != NO_VAL) j->delay_boot = opt_local->delay_boot; if (opt_local->mem_bind) j->mem_bind = opt_local->mem_bind; if (opt_local->mem_bind_type) j->mem_bind_type = opt_local->mem_bind_type; if (opt_local->plane_size != NO_VAL) j->plane_size = opt_local->plane_size; j->task_dist = opt_local->distribution; j->group_id = opt_local->gid; j->mail_type = opt_local->mail_type; if (opt_local->ntasks_per_node != NO_VAL) j->ntasks_per_node = opt_local->ntasks_per_node; if (opt_local->ntasks_per_socket != NO_VAL) j->ntasks_per_socket = opt_local->ntasks_per_socket; if (opt_local->ntasks_per_core != NO_VAL) j->ntasks_per_core = opt_local->ntasks_per_core; if (opt_local->mail_user) j->mail_user = opt_local->mail_user; if (opt_local->burst_buffer) j->burst_buffer = opt_local->burst_buffer; if (opt_local->begin) j->begin_time = opt_local->begin; if (opt_local->deadline) j->deadline = opt_local->deadline; if (opt_local->licenses) j->licenses = opt_local->licenses; if (opt_local->network) j->network = opt_local->network; if (opt_local->profile) j->profile = opt_local->profile; if (opt_local->account) j->account = opt_local->account; if (opt_local->comment) j->comment = opt_local->comment; if (opt_local->qos) j->qos = opt_local->qos; if (opt_local->cwd) j->work_dir = opt_local->cwd; if (opt_local->hold) j->priority = 0; if (opt_local->jobid != NO_VAL) j->job_id = opt_local->jobid; #ifdef HAVE_BG if (opt_local->geometry[0] > 0) { int i; for (i = 0; i < SYSTEM_DIMENSIONS; i++) j->geometry[i] = opt_local->geometry[i]; } #endif memcpy(j->conn_type, opt_local->conn_type, sizeof(j->conn_type)); if (opt_local->reboot) j->reboot = 1; if (opt_local->no_rotate) j->rotate = 0; if (opt_local->blrtsimage) j->blrtsimage = opt_local->blrtsimage; if (opt_local->linuximage) j->linuximage = opt_local->linuximage; if (opt_local->mloaderimage) j->mloaderimage = opt_local->mloaderimage; if (opt_local->ramdiskimage) j->ramdiskimage = opt_local->ramdiskimage; if (opt_local->max_nodes) j->max_nodes = opt_local->max_nodes; else if (opt_local->nodes_set) { /* On an allocation if the max nodes isn't set set it * to do the same behavior as with salloc or sbatch. */ j->max_nodes = opt_local->min_nodes; } if (opt_local->pn_min_cpus != NO_VAL) j->pn_min_cpus = opt_local->pn_min_cpus; if (opt_local->pn_min_memory != NO_VAL64) j->pn_min_memory = opt_local->pn_min_memory; else if (opt_local->mem_per_cpu != NO_VAL64) j->pn_min_memory = opt_local->mem_per_cpu | MEM_PER_CPU; if (opt_local->pn_min_tmp_disk != NO_VAL) j->pn_min_tmp_disk = opt_local->pn_min_tmp_disk; if (opt_local->overcommit) { j->min_cpus = opt_local->min_nodes; j->overcommit = opt_local->overcommit; } else if (opt_local->cpus_set) j->min_cpus = opt_local->ntasks * opt_local->cpus_per_task; else j->min_cpus = opt_local->ntasks; if (opt_local->ntasks_set) j->num_tasks = opt_local->ntasks; if (opt_local->cpus_set) j->cpus_per_task = opt_local->cpus_per_task; if (opt_local->no_kill) j->kill_on_node_fail = 0; if (opt_local->time_limit != NO_VAL) j->time_limit = opt_local->time_limit; if (opt_local->time_min != NO_VAL) j->time_min = opt_local->time_min; if (opt_local->shared != NO_VAL16) j->shared = opt_local->shared; if (opt_local->warn_signal) j->warn_signal = opt_local->warn_signal; if (opt_local->warn_time) j->warn_time = opt_local->warn_time; if (opt_local->job_flags) j->bitflags = opt_local->job_flags; if (opt_local->cpu_freq_min != NO_VAL) j->cpu_freq_min = opt_local->cpu_freq_min; if (opt_local->cpu_freq_max != NO_VAL) j->cpu_freq_max = opt_local->cpu_freq_max; if (opt_local->cpu_freq_gov != NO_VAL) j->cpu_freq_gov = opt_local->cpu_freq_gov; if (opt_local->req_switch >= 0) j->req_switch = opt_local->req_switch; if (opt_local->wait4switch >= 0) j->wait4switch = opt_local->wait4switch; /* srun uses the same listening port for the allocation response * message as all other messages */ j->alloc_resp_port = slurmctld_comm_addr.port; j->other_port = slurmctld_comm_addr.port; if (opt_local->spank_job_env_size) { j->spank_job_env = opt_local->spank_job_env; j->spank_job_env_size = opt_local->spank_job_env_size; } if (opt_local->power_flags) j->power_flags = opt_local->power_flags; if (opt_local->mcs_label) j->mcs_label = opt_local->mcs_label; j->wait_all_nodes = 1; /* If can run on multiple clusters find the earliest run time * and run it there */ j->clusters = xstrdup(opt_local->clusters); return j; }
/* create a slurmd job structure from a launch tasks message */ slurmd_job_t * job_create(launch_tasks_request_msg_t *msg) { struct passwd *pwd = NULL; slurmd_job_t *job = NULL; srun_info_t *srun = NULL; slurm_addr_t resp_addr; slurm_addr_t io_addr; int nodeid = NO_VAL; xassert(msg != NULL); xassert(msg->complete_nodelist != NULL); debug3("entering job_create"); if ((pwd = _pwd_create((uid_t)msg->uid)) == NULL) { error("uid %ld not found on system", (long) msg->uid); slurm_seterrno (ESLURMD_UID_NOT_FOUND); return NULL; } if (!_valid_gid(pwd, &(msg->gid))) { slurm_seterrno (ESLURMD_GID_NOT_FOUND); _pwd_destroy(pwd); return NULL; } if (msg->job_mem_lim && (msg->acctg_freq != (uint16_t) NO_VAL) && (msg->acctg_freq > conf->job_acct_gather_freq)) { error("Can't set frequency to %u, it is higher than %u. " "We need it to be at least at this level to " "monitor memory usage.", msg->acctg_freq, conf->job_acct_gather_freq); slurm_seterrno (ESLURMD_INVALID_ACCT_FREQ); _pwd_destroy(pwd); return NULL; } job = xmalloc(sizeof(slurmd_job_t)); #ifndef HAVE_FRONT_END nodeid = nodelist_find(msg->complete_nodelist, conf->node_name); job->node_name = xstrdup(conf->node_name); #else nodeid = 0; job->node_name = xstrdup(msg->complete_nodelist); #endif if(nodeid < 0) { error("couldn't find node %s in %s", job->node_name, msg->complete_nodelist); job_destroy(job); return NULL; } job->state = SLURMSTEPD_STEP_STARTING; job->pwd = pwd; job->node_tasks = msg->tasks_to_launch[nodeid]; job->ntasks = msg->ntasks; job->jobid = msg->job_id; job->stepid = msg->job_step_id; job->uid = (uid_t) msg->uid; job->gid = (gid_t) msg->gid; job->cwd = xstrdup(msg->cwd); job->task_dist = msg->task_dist; job->cpu_bind_type = msg->cpu_bind_type; job->cpu_bind = xstrdup(msg->cpu_bind); job->mem_bind_type = msg->mem_bind_type; job->mem_bind = xstrdup(msg->mem_bind); job->cpu_freq = msg->cpu_freq; job->ckpt_dir = xstrdup(msg->ckpt_dir); job->restart_dir = xstrdup(msg->restart_dir); job->cpus_per_task = msg->cpus_per_task; job->env = _array_copy(msg->envc, msg->env); job->eio = eio_handle_create(); job->sruns = list_create((ListDelF) _srun_info_destructor); job->clients = list_create(NULL); /* FIXME! Needs destructor */ job->stdout_eio_objs = list_create(NULL); /* FIXME! Needs destructor */ job->stderr_eio_objs = list_create(NULL); /* FIXME! Needs destructor */ job->free_incoming = list_create(NULL); /* FIXME! Needs destructor */ job->incoming_count = 0; job->free_outgoing = list_create(NULL); /* FIXME! Needs destructor */ job->outgoing_count = 0; job->outgoing_cache = list_create(NULL); /* FIXME! Needs destructor */ job->envtp = xmalloc(sizeof(env_t)); job->envtp->jobid = -1; job->envtp->stepid = -1; job->envtp->procid = -1; job->envtp->localid = -1; job->envtp->nodeid = -1; job->envtp->distribution = 0; job->envtp->cpu_bind_type = 0; job->envtp->cpu_bind = NULL; job->envtp->mem_bind_type = 0; job->envtp->mem_bind = NULL; job->envtp->ckpt_dir = NULL; //job->envtp->comm_port = msg->resp_port[nodeid % msg->num_resp_port]; /*memcpy(&resp_addr, &msg->orig_addr, sizeof(slurm_addr_t)); slurm_set_addr(&resp_addr, msg->resp_port[nodeid % msg->num_resp_port], NULL); job->user_managed_io = msg->user_managed_io; if (!msg->user_managed_io) { memcpy(&io_addr, &msg->orig_addr, sizeof(slurm_addr_t)); slurm_set_addr(&io_addr, msg->io_port[nodeid % msg->num_io_port], NULL); }*/ //srun = srun_info_create(msg->cred, &resp_addr, &io_addr); srun = srun_info_create(NULL, NULL, NULL); job->buffered_stdio = msg->buffered_stdio; job->labelio = msg->labelio; job->task_prolog = xstrdup(msg->task_prolog); job->task_epilog = xstrdup(msg->task_epilog); job->argc = msg->argc; job->argv = _array_copy(job->argc, msg->argv); job->nnodes = msg->nnodes; job->nodeid = nodeid; job->debug = msg->slurmd_debug; job->cpus = msg->cpus_allocated[nodeid]; if (msg->acctg_freq != (uint16_t) NO_VAL) jobacct_gather_change_poll(msg->acctg_freq); job->multi_prog = msg->multi_prog; job->timelimit = (time_t) -1; job->task_flags = msg->task_flags; job->switch_job = msg->switch_job; job->pty = msg->pty; job->open_mode = msg->open_mode; job->options = msg->options; format_core_allocs(msg->cred, conf->node_name, &job->job_alloc_cores, &job->step_alloc_cores, &job->job_mem, &job->step_mem); if (job->step_mem) { jobacct_gather_set_mem_limit(job->jobid, job->stepid, job->step_mem); } else if (job->job_mem) { jobacct_gather_set_mem_limit(job->jobid, job->stepid, job->job_mem); } #ifdef HAVE_CRAY /* This is only used for Cray emulation mode where slurmd is used to * launch job steps. On a real Cray system, ALPS is used to launch * the tasks instead of SLURM. SLURM's task launch RPC does NOT * contain the reservation ID, so just use some non-zero value here * for testing purposes. */ job->resv_id = 1; select_g_select_jobinfo_set(msg->select_jobinfo, SELECT_JOBDATA_RESV_ID, &job->resv_id); #endif get_cred_gres(msg->cred, conf->node_name, &job->job_gres_list, &job->step_gres_list); list_append(job->sruns, (void *) srun); _job_init_task_info(job, msg->global_task_ids[nodeid], msg->ifname, msg->ofname, msg->efname); return job; }