diff --git a/slurm/slurm.h.in b/slurm/slurm.h.in index 6c68a2c013c7a3d759a0e129d04111eba2dd2be7..ab0236c263fbee3f32396c460d5d667d01cdf5cd 100644 --- a/slurm/slurm.h.in +++ b/slurm/slurm.h.in @@ -1388,6 +1388,7 @@ typedef struct job_descriptor { /* For submit, allocate, and update requests */ char *gres; /* comma separated list of required generic * resources, default NONE */ uint32_t group_id; /* group to assume, if run as root. */ + uint32_t group_number; /* jobpack group number index */ uint16_t immediate; /* 1 if allocate to run or fail immediately, * 0 if to be queued awaiting resources */ uint32_t job_id; /* job ID, default set by SLURM */ @@ -1404,14 +1405,19 @@ typedef struct job_descriptor { /* For submit, allocate, and update requests */ char *network; /* network use spec */ uint32_t nice; /* requested priority change, * NICE_OFFSET == no change */ + uint32_t numpack; /* number of jobpack jobs */ uint32_t num_tasks; /* number of tasks to be started, * for batch only */ uint8_t open_mode; /* out/err open mode truncate or append, * see OPEN_MODE_* */ uint16_t other_port; /* port to send various notification msg to */ uint8_t overcommit; /* over subscribe resources, for batch only */ + uint32_t pack_leader; /* job_id of pack_leader for job_pack or 0 */ char *partition; /* name of requested partition, * default in SLURM config */ + char **pelog_env; /* other environment variables for job + prolog/epilog */ + uint32_t pelog_env_size;/* element count in pelog_env */ uint16_t plane_size; /* plane size when task_dist = SLURM_DIST_PLANE */ uint8_t power_flags; /* power management flags, @@ -1423,6 +1429,7 @@ typedef struct job_descriptor { /* For submit, allocate, and update requests */ char *qos; /* Quality of Service */ uint16_t reboot; /* force node reboot before startup */ char *resp_host; /* NOTE: Set by slurmctld */ + uint8_t resv_port; /* jobpack resv-port for nodes flag */ char *req_nodes; /* comma separated list of required nodes * default NONE */ uint16_t requeue; /* enable or disable job requeue option */ @@ -1903,6 +1910,8 @@ typedef struct { uint32_t cpu_freq_max; /* Maximum cpu frequency */ uint32_t cpu_freq_gov; /* cpu frequency governor */ uint32_t num_tasks; /* number of tasks */ + uint32_t packjobid; /* jobid of srun first step of the jobpack */ + uint32_t packstepid; /* stepid of jobpack member */ char *partition; /* name of assigned partition */ char *resv_ports; /* ports allocated for MPI */ time_t run_time; /* net run time (factor out time suspended) */ diff --git a/slurm/slurmdb.h b/slurm/slurmdb.h index 72360e047a8b442a63131f59e2ef0030239ba9fe..cb1ffb8179259c7c38bdc3767948636acac2873c 100644 --- a/slurm/slurmdb.h +++ b/slurm/slurmdb.h @@ -953,6 +953,8 @@ typedef struct { uint32_t nnodes; char *nodes; uint32_t ntasks; + uint32_t packjobid; /* jobid of srun first step of the jobpack */ + uint32_t packstepid; /* stepid of jobpack member */ char *pid_str; uint32_t req_cpufreq_min; uint32_t req_cpufreq_max; diff --git a/src/common/slurm_protocol_defs.h b/src/common/slurm_protocol_defs.h index f61e6151d1ad46e88417d832bf8dedfa2c478fcb..e507fba8d43553b480af0868298ecf81a58e3381 100644 --- a/src/common/slurm_protocol_defs.h +++ b/src/common/slurm_protocol_defs.h @@ -731,6 +731,8 @@ typedef struct job_step_specs { uint32_t num_tasks; /* number of tasks required */ uint8_t overcommit; /* flag, 1 to allow overcommit of processors, 0 to disallow overcommit. default is 0 */ + uint32_t packjobid; /* jobid of srun first step */ + uint32_t packstepid; /* stepid of srun first step */ uint16_t plane_size; /* plane size when task_dist = SLURM_DIST_PLANE */ uint16_t port; /* port to contact initiating srun */ @@ -767,12 +769,20 @@ typedef struct job_step_create_response_msg { typedef struct launch_tasks_request_msg { uint32_t job_id; uint32_t job_step_id; + uint32_t mpi_jobid; /* MPI jobid (same for all steps) */ + uint32_t mpi_nnodes; /* number of MPI nodes in all steps */ + uint32_t mpi_ntasks; /* number of MPI tasks in all steps */ + uint32_t mpi_stepfnodeid; /* first MPI nodeid for this step */ + uint32_t mpi_stepftaskid; /* first MPI taskid for this step */ + uint32_t mpi_stepid; /* MPI stepid (same for all steps) */ uint32_t nnodes; /* number of nodes in this job step */ uint32_t ntasks; /* number of tasks in this job step */ uint16_t ntasks_per_board;/* number of tasks to invoke on each board */ uint16_t ntasks_per_core; /* number of tasks to invoke on each core */ uint16_t ntasks_per_socket;/* number of tasks to invoke on * each socket */ + uint32_t packjobid; /* jobid of srun first step */ + uint32_t packstepid; /* stepid of srun first step */ uint32_t uid; char *user_name; uint32_t gid; @@ -828,6 +838,8 @@ typedef struct launch_tasks_request_msg { job_options_t options; /* Arbitrary job options */ char *complete_nodelist; char *ckpt_dir; /* checkpoint path */ + char **pelog_env; /* prolog/epilog environment vars */ + uint32_t pelog_env_size; char *restart_dir; /* restart from checkpoint if set */ char **spank_job_env; uint32_t spank_job_env_size; @@ -939,6 +951,8 @@ typedef struct prolog_launch_msg { uint32_t nnodes; /* count of nodes, passed via cred */ char *nodes; /* list of nodes allocated to job_step */ char *partition; /* partition the job is running in */ + char **pelog_env; /* prolog/epilog environment vars */ + uint32_t pelog_env_size; dynamic_plugin_data_t *select_jobinfo; /* opaque data type */ char **spank_job_env; /* SPANK job environment variables */ uint32_t spank_job_env_size; /* size of spank_job_env */ @@ -1007,6 +1021,10 @@ typedef struct batch_job_launch_msg { char **spank_job_env; /* SPANK job environment variables */ uint32_t spank_job_env_size; /* size of spank_job_env */ char *resv_name; /* job's reservation */ + char **pelog_env; /* prolog/epilog environment vars */ + uint32_t pelog_env_size; + char *resv_ports; /* reserve ports for jobpack nodes */ + uint32_t group_number; /* jobpack group number index */ } batch_job_launch_msg_t; typedef struct job_id_request_msg { diff --git a/src/common/slurm_protocol_pack.c b/src/common/slurm_protocol_pack.c index 7beca0624b4093fc9b4a92a65879c04b32124994..c7a8f2b3e943a75743d7702bb6559e4f881ad602 100644 --- a/src/common/slurm_protocol_pack.c +++ b/src/common/slurm_protocol_pack.c @@ -4871,6 +4871,8 @@ pack_job_step_create_request_msg(job_step_create_request_msg_t * msg, pack16(msg->relative, buffer); pack32(msg->task_dist, buffer); + pack32(msg->packjobid, buffer); + pack32(msg->packstepid, buffer); pack16(msg->plane_size, buffer); pack16(msg->port, buffer); pack16(msg->ckpt_interval, buffer); @@ -4955,6 +4957,8 @@ unpack_job_step_create_request_msg(job_step_create_request_msg_t ** msg, safe_unpack16(&tmp_ptr->relative, buffer); safe_unpack32(&tmp_ptr->task_dist, buffer); + safe_unpack32(&tmp_ptr->packjobid, buffer); + safe_unpack32(&tmp_ptr->packstepid, buffer); safe_unpack16(&tmp_ptr->plane_size, buffer); safe_unpack16(&tmp_ptr->port, buffer); safe_unpack16(&tmp_ptr->ckpt_interval, buffer); @@ -5810,6 +5814,8 @@ _unpack_job_step_info_members(job_step_info_t * step, Buf buffer, safe_unpackstr_xmalloc(&step->tres_alloc_str, &uint32_tmp, buffer); safe_unpack16(&step->start_protocol_ver, buffer); + safe_unpack32(&step->packjobid, buffer); + safe_unpack32(&step->packstepid, buffer); } else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) { safe_unpack32(&step->array_job_id, buffer); safe_unpack32(&step->array_task_id, buffer); @@ -8802,6 +8808,12 @@ _pack_job_desc_msg(job_desc_msg_t * job_desc_ptr, Buf buffer, pack16(job_desc_ptr->wait_all_nodes, buffer); pack32(job_desc_ptr->bitflags, buffer); pack32(job_desc_ptr->delay_boot, buffer); + packstr_array(job_desc_ptr->pelog_env, + job_desc_ptr->pelog_env_size, buffer); + pack8(job_desc_ptr->resv_port, buffer); + pack32(job_desc_ptr->group_number, buffer); + pack32(job_desc_ptr->numpack, buffer); + pack32(job_desc_ptr->pack_leader, buffer); } else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) { packstr(job_desc_ptr->clusters, buffer); pack16(job_desc_ptr->contiguous, buffer); @@ -9306,6 +9318,13 @@ _unpack_job_desc_msg(job_desc_msg_t ** job_desc_buffer_ptr, Buf buffer, safe_unpack16(&job_desc_ptr->wait_all_nodes, buffer); safe_unpack32(&job_desc_ptr->bitflags, buffer); safe_unpack32(&job_desc_ptr->delay_boot, buffer); + safe_unpackstr_array(&job_desc_ptr->pelog_env, + &job_desc_ptr->pelog_env_size, + buffer); + safe_unpack8(&job_desc_ptr->resv_port, buffer); + safe_unpack32(&job_desc_ptr->group_number, buffer); + safe_unpack32(&job_desc_ptr->numpack, buffer); + safe_unpack32(&job_desc_ptr->pack_leader, buffer); } else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) { uint32_t tmp_mem; job_desc_ptr = xmalloc(sizeof(job_desc_msg_t)); @@ -10000,10 +10019,18 @@ _pack_launch_tasks_request_msg(launch_tasks_request_msg_t * msg, Buf buffer, if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) { pack32(msg->job_id, buffer); pack32(msg->job_step_id, buffer); + pack32(msg->mpi_jobid, buffer); + pack32(msg->mpi_nnodes, buffer); + pack32(msg->mpi_ntasks, buffer); + pack32(msg->mpi_stepfnodeid, buffer); + pack32(msg->mpi_stepftaskid, buffer); + pack32(msg->mpi_stepid, buffer); pack32(msg->ntasks, buffer); pack16(msg->ntasks_per_board, buffer); pack16(msg->ntasks_per_core, buffer); pack16(msg->ntasks_per_socket, buffer); + pack32(msg->packjobid, buffer); + pack32(msg->packstepid, buffer); pack32(msg->uid, buffer); packstr(msg->partition, buffer); packstr(msg->user_name, buffer); @@ -10075,6 +10102,8 @@ _pack_launch_tasks_request_msg(launch_tasks_request_msg_t * msg, Buf buffer, buffer, protocol_version); } + packstr_array(msg->pelog_env, msg->pelog_env_size, + buffer); } else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) { uint16_t task_flags = 0, multi_prog = 0, user_managed_io = 0; uint8_t pty = 0, buffered_stdio = 0, labelio = 0; @@ -10289,10 +10318,19 @@ _unpack_launch_tasks_request_msg(launch_tasks_request_msg_t ** if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) { safe_unpack32(&msg->job_id, buffer); safe_unpack32(&msg->job_step_id, buffer); + safe_unpack32(&msg->mpi_jobid, buffer); + safe_unpack32(&msg->mpi_nnodes, buffer); + safe_unpack32(&msg->mpi_ntasks, buffer); + safe_unpack32(&msg->mpi_stepfnodeid, buffer); + safe_unpack32(&msg->mpi_stepftaskid, buffer); + safe_unpack32(&msg->mpi_stepid, buffer); + safe_unpack32(&msg->ntasks, buffer); safe_unpack16(&msg->ntasks_per_board, buffer); safe_unpack16(&msg->ntasks_per_core, buffer); safe_unpack16(&msg->ntasks_per_socket, buffer); + safe_unpack32(&msg->packjobid, buffer); + safe_unpack32(&msg->packstepid, buffer); safe_unpack32(&msg->uid, buffer); safe_unpackstr_xmalloc(&msg->partition, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&msg->user_name, &uint32_tmp, buffer); @@ -10386,6 +10424,8 @@ _unpack_launch_tasks_request_msg(launch_tasks_request_msg_t ** buffer, protocol_version); } + safe_unpackstr_array(&msg->pelog_env, + &msg->pelog_env_size, buffer); } else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) { uint32_t tmp_mem = 0; uint16_t task_flags = 0, multi_prog = 0, user_managed_io = 0; @@ -11007,7 +11047,24 @@ _pack_prolog_launch_msg( { xassert(msg != NULL); - if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) { + if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) { + pack32(msg->job_id, buffer); + pack32(msg->uid, buffer); + pack32(msg->gid, buffer); + + packstr(msg->alias_list, buffer); + packstr(msg->nodes, buffer); + packstr(msg->partition, buffer); + packstr(msg->std_err, buffer); + packstr(msg->std_out, buffer); + packstr(msg->work_dir, buffer); + packstr_array(msg->spank_job_env, msg->spank_job_env_size, + buffer); + slurm_cred_pack(msg->cred, buffer, protocol_version); + packstr(msg->user_name, buffer); + packstr_array(msg->pelog_env, msg->pelog_env_size, + buffer); + } else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) { pack32(msg->job_id, buffer); pack32(msg->uid, buffer); pack32(msg->gid, buffer); @@ -11051,7 +11108,37 @@ _unpack_prolog_launch_msg( launch_msg_ptr = xmalloc(sizeof(prolog_launch_msg_t)); *msg = launch_msg_ptr; - if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) { + if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) { + safe_unpack32(&launch_msg_ptr->job_id, buffer); + safe_unpack32(&launch_msg_ptr->uid, buffer); + safe_unpack32(&launch_msg_ptr->gid, buffer); + + safe_unpackstr_xmalloc(&launch_msg_ptr->alias_list, &uint32_tmp, + buffer); + safe_unpackstr_xmalloc(&launch_msg_ptr->nodes, &uint32_tmp, + buffer); + safe_unpackstr_xmalloc(&launch_msg_ptr->partition, &uint32_tmp, + buffer); + safe_unpackstr_xmalloc(&launch_msg_ptr->std_err, &uint32_tmp, + buffer); + safe_unpackstr_xmalloc(&launch_msg_ptr->std_out, &uint32_tmp, + buffer); + safe_unpackstr_xmalloc(&launch_msg_ptr->work_dir, &uint32_tmp, + buffer); + + safe_unpackstr_array(&launch_msg_ptr->spank_job_env, + &launch_msg_ptr->spank_job_env_size, + buffer); + if (!(launch_msg_ptr->cred = slurm_cred_unpack(buffer, + protocol_version))) + goto unpack_error; + + safe_unpackstr_xmalloc(&launch_msg_ptr->user_name, &uint32_tmp, + buffer); + safe_unpackstr_array(&launch_msg_ptr->pelog_env, + &launch_msg_ptr->pelog_env_size, + buffer); + } else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) { safe_unpack32(&launch_msg_ptr->job_id, buffer); safe_unpack32(&launch_msg_ptr->uid, buffer); safe_unpack32(&launch_msg_ptr->gid, buffer); @@ -12283,6 +12370,10 @@ _pack_batch_job_launch_msg(batch_job_launch_msg_t * msg, Buf buffer, packstr(msg->qos, buffer); packstr(msg->resv_name, buffer); pack32(msg->profile, buffer); + packstr_array(msg->pelog_env, msg->pelog_env_size, + buffer); + packstr(msg->resv_ports, buffer); + pack32(msg->group_number, buffer); } else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) { pack32(msg->job_id, buffer); pack32(msg->step_id, buffer); @@ -12513,6 +12604,12 @@ _unpack_batch_job_launch_msg(batch_job_launch_msg_t ** msg, Buf buffer, &uint32_tmp, buffer); safe_unpack32(&launch_msg_ptr->profile, buffer); + safe_unpackstr_array(&launch_msg_ptr->pelog_env, + &launch_msg_ptr->pelog_env_size, buffer); + safe_unpackstr_xmalloc(&launch_msg_ptr->resv_ports, + &uint32_tmp, + buffer); + safe_unpack32(&launch_msg_ptr->group_number, buffer); } else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) { uint32_t tmp_mem; safe_unpack32(&launch_msg_ptr->job_id, buffer); diff --git a/src/common/slurmdb_pack.c b/src/common/slurmdb_pack.c index c5998663d34e5dc99d2707e4f74e47e4a1d9791d..2209c685e4d63409ba8d273326afd6e7d44cd758 100644 --- a/src/common/slurmdb_pack.c +++ b/src/common/slurmdb_pack.c @@ -4857,7 +4857,34 @@ unpack_error: extern void slurmdb_pack_step_rec(slurmdb_step_rec_t *step, uint16_t protocol_version, Buf buffer) { - if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { + if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) { + pack32(step->elapsed, buffer); + pack_time(step->end, buffer); + pack32((uint32_t)step->exitcode, buffer); + pack32(step->nnodes, buffer); + packstr(step->nodes, buffer); + pack32(step->ntasks, buffer); + pack32(step->packjobid, buffer); + pack32(step->packstepid, buffer); + pack32(step->req_cpufreq_min, buffer); + pack32(step->req_cpufreq_max, buffer); + pack32(step->req_cpufreq_gov, buffer); + pack32(step->requid, buffer); + _pack_slurmdb_stats(&step->stats, protocol_version, buffer); + pack_time(step->start, buffer); + pack16(step->state, buffer); + pack32(step->stepid, buffer); /* job's step number */ + packstr(step->stepname, buffer); + pack32(step->suspended, buffer); + pack32(step->sys_cpu_sec, buffer); + pack32(step->sys_cpu_usec, buffer); + pack32(step->task_dist, buffer); + pack32(step->tot_cpu_sec, buffer); + pack32(step->tot_cpu_usec, buffer); + packstr(step->tres_alloc_str, buffer); + pack32(step->user_cpu_sec, buffer); + pack32(step->user_cpu_usec, buffer); + } else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { pack32(step->elapsed, buffer); pack_time(step->end, buffer); pack32((uint32_t)step->exitcode, buffer); @@ -4897,7 +4924,41 @@ extern int slurmdb_unpack_step_rec(slurmdb_step_rec_t **step, *step = step_ptr; - if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { + if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) { + safe_unpack32(&step_ptr->elapsed, buffer); + safe_unpack_time(&step_ptr->end, buffer); + safe_unpack32(&uint32_tmp, buffer); + step_ptr->exitcode = (int32_t)uint32_tmp; + safe_unpack32(&step_ptr->nnodes, buffer); + safe_unpackstr_xmalloc(&step_ptr->nodes, &uint32_tmp, buffer); + safe_unpack32(&step_ptr->ntasks, buffer); + safe_unpack32(&step_ptr->packjobid, buffer); + safe_unpack32(&step_ptr->packstepid, buffer); + safe_unpack32(&step_ptr->req_cpufreq_min, buffer); + safe_unpack32(&step_ptr->req_cpufreq_max, buffer); + safe_unpack32(&step_ptr->req_cpufreq_gov, buffer); + safe_unpack32(&step_ptr->requid, buffer); + if (_unpack_slurmdb_stats(&step_ptr->stats, protocol_version, + buffer) + != SLURM_SUCCESS) + goto unpack_error; + safe_unpack_time(&step_ptr->start, buffer); + safe_unpack16(&uint16_tmp, buffer); + step_ptr->state = uint16_tmp; + safe_unpack32(&step_ptr->stepid, buffer); + safe_unpackstr_xmalloc(&step_ptr->stepname, + &uint32_tmp, buffer); + safe_unpack32(&step_ptr->suspended, buffer); + safe_unpack32(&step_ptr->sys_cpu_sec, buffer); + safe_unpack32(&step_ptr->sys_cpu_usec, buffer); + safe_unpack32(&step_ptr->task_dist, buffer); + safe_unpack32(&step_ptr->tot_cpu_sec, buffer); + safe_unpack32(&step_ptr->tot_cpu_usec, buffer); + safe_unpackstr_xmalloc(&step_ptr->tres_alloc_str, + &uint32_tmp, buffer); + safe_unpack32(&step_ptr->user_cpu_sec, buffer); + safe_unpack32(&step_ptr->user_cpu_usec, buffer); + } else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpack32(&step_ptr->elapsed, buffer); safe_unpack_time(&step_ptr->end, buffer); safe_unpack32(&uint32_tmp, buffer); diff --git a/src/common/slurmdbd_defs.c b/src/common/slurmdbd_defs.c index 837b119e8cd8b1dd75f585576b219f3fa7bf9da2..dacf08c5e66083290e36b9e2fb074b9c5dcc19a3 100644 --- a/src/common/slurmdbd_defs.c +++ b/src/common/slurmdbd_defs.c @@ -4085,6 +4085,8 @@ slurmdbd_pack_step_start_msg(dbd_step_start_msg_t *msg, uint16_t rpc_version, pack32(msg->node_cnt, buffer); pack_time(msg->start_time, buffer); pack_time(msg->job_submit_time, buffer); + pack32(msg->packjobid, buffer); + pack32(msg->packstepid, buffer); pack32(msg->req_cpufreq_min, buffer); pack32(msg->req_cpufreq_max, buffer); pack32(msg->req_cpufreq_gov, buffer); @@ -4130,6 +4132,8 @@ slurmdbd_unpack_step_start_msg(dbd_step_start_msg_t **msg, safe_unpack32(&msg_ptr->node_cnt, buffer); safe_unpack_time(&msg_ptr->start_time, buffer); safe_unpack_time(&msg_ptr->job_submit_time, buffer); + safe_unpack32(&msg_ptr->packjobid, buffer); + safe_unpack32(&msg_ptr->packstepid, buffer); safe_unpack32(&msg_ptr->req_cpufreq_min, buffer); safe_unpack32(&msg_ptr->req_cpufreq_max, buffer); safe_unpack32(&msg_ptr->req_cpufreq_gov, buffer); diff --git a/src/common/slurmdbd_defs.h b/src/common/slurmdbd_defs.h index d9e4a8901783788548ed18f1a5a1e9fbb1bf6edc..01209a518ebb374d85df75df513f91b547c7a7b0 100644 --- a/src/common/slurmdbd_defs.h +++ b/src/common/slurmdbd_defs.h @@ -370,6 +370,8 @@ typedef struct dbd_step_start_msg { time_t start_time; /* step start time */ time_t job_submit_time;/* job submit time needed to find job record * in db */ + uint32_t packjobid; /* jobid of srun first step of the jobpack */ + uint32_t packstepid; /* stepid of jobpack member */ uint32_t req_cpufreq_min; /* requested minimum CPU frequency */ uint32_t req_cpufreq_max; /* requested maximum CPU frequency */ uint32_t req_cpufreq_gov; /* requested CPU frequency governor */ diff --git a/src/plugins/accounting_storage/mysql/as_mysql_archive.c b/src/plugins/accounting_storage/mysql/as_mysql_archive.c index c2bb124014e7677aaddd991729ec0fda189c43cb..70134149350eb4fcd68cf90e6ae264681045a231 100644 --- a/src/plugins/accounting_storage/mysql/as_mysql_archive.c +++ b/src/plugins/accounting_storage/mysql/as_mysql_archive.c @@ -160,6 +160,8 @@ typedef struct { char *nodelist; char *nodes; char *node_inx; + char *packjobid; + char *packstepid; char *period_end; char *period_start; char *period_suspended; @@ -367,6 +369,8 @@ static char *step_req_inx[] = { "max_disk_write_node", "ave_disk_write", "tres_alloc", + "packjobid", + "packstepid", }; @@ -419,6 +423,8 @@ enum { STEP_REQ_MAX_DISK_WRITE_NODE, STEP_REQ_AVE_DISK_WRITE, STEP_REQ_TRES, + STEP_REQ_PACKJOBID, + STEP_REQ_PACKSTEPID, STEP_REQ_COUNT, }; @@ -808,6 +814,8 @@ static void _pack_local_step(local_step_t *object, packstr(object->nodelist, buffer); packstr(object->nodes, buffer); packstr(object->node_inx, buffer); + packstr(object->packjobid, buffer); + packstr(object->packstepid, buffer); packstr(object->period_end, buffer); packstr(object->period_start, buffer); packstr(object->period_suspended, buffer); @@ -833,7 +841,58 @@ static int _unpack_local_step(local_step_t *object, uint32_t tmp32; char *tmp_char; - if (rpc_version >= SLURM_15_08_PROTOCOL_VERSION) { + if (rpc_version >= SLURM_17_02_PROTOCOL_VERSION) { + unpackstr_ptr(&object->act_cpufreq, &tmp32, buffer); + unpackstr_ptr(&object->ave_cpu, &tmp32, buffer); + unpackstr_ptr(&object->ave_disk_read, &tmp32, buffer); + unpackstr_ptr(&object->ave_disk_write, &tmp32, buffer); + unpackstr_ptr(&object->ave_pages, &tmp32, buffer); + unpackstr_ptr(&object->ave_rss, &tmp32, buffer); + unpackstr_ptr(&object->ave_vsize, &tmp32, buffer); + unpackstr_ptr(&object->exit_code, &tmp32, buffer); + unpackstr_ptr(&object->consumed_energy, &tmp32, buffer); + unpackstr_ptr(&object->job_db_inx, &tmp32, buffer); + unpackstr_ptr(&object->kill_requid, &tmp32, buffer); + unpackstr_ptr(&object->max_disk_read, &tmp32, buffer); + unpackstr_ptr(&object->max_disk_read_node, &tmp32, buffer); + unpackstr_ptr(&object->max_disk_read_task, &tmp32, buffer); + unpackstr_ptr(&object->max_disk_write, &tmp32, buffer); + unpackstr_ptr(&object->max_disk_write_node, &tmp32, buffer); + unpackstr_ptr(&object->max_disk_write_task, &tmp32, buffer); + unpackstr_ptr(&object->max_pages, &tmp32, buffer); + unpackstr_ptr(&object->max_pages_node, &tmp32, buffer); + unpackstr_ptr(&object->max_pages_task, &tmp32, buffer); + unpackstr_ptr(&object->max_rss, &tmp32, buffer); + unpackstr_ptr(&object->max_rss_node, &tmp32, buffer); + unpackstr_ptr(&object->max_rss_task, &tmp32, buffer); + unpackstr_ptr(&object->max_vsize, &tmp32, buffer); + unpackstr_ptr(&object->max_vsize_node, &tmp32, buffer); + unpackstr_ptr(&object->max_vsize_task, &tmp32, buffer); + unpackstr_ptr(&object->min_cpu, &tmp32, buffer); + unpackstr_ptr(&object->min_cpu_node, &tmp32, buffer); + unpackstr_ptr(&object->min_cpu_task, &tmp32, buffer); + unpackstr_ptr(&object->name, &tmp32, buffer); + unpackstr_ptr(&object->nodelist, &tmp32, buffer); + unpackstr_ptr(&object->nodes, &tmp32, buffer); + unpackstr_ptr(&object->node_inx, &tmp32, buffer); + unpackstr_ptr(&object->packjobid, &tmp32, buffer); + unpackstr_ptr(&object->packstepid, &tmp32, buffer); + unpackstr_ptr(&object->period_end, &tmp32, buffer); + unpackstr_ptr(&object->period_start, &tmp32, buffer); + unpackstr_ptr(&object->period_suspended, &tmp32, buffer); + unpackstr_ptr(&object->req_cpufreq_min, &tmp32, buffer); + unpackstr_ptr(&object->req_cpufreq_max, &tmp32, buffer); + unpackstr_ptr(&object->req_cpufreq_gov, &tmp32, buffer); + unpackstr_ptr(&object->state, &tmp32, buffer); + unpackstr_ptr(&object->stepid, &tmp32, buffer); + unpackstr_ptr(&object->sys_sec, &tmp32, buffer); + unpackstr_ptr(&object->sys_usec, &tmp32, buffer); + unpackstr_ptr(&object->tasks, &tmp32, buffer); + unpackstr_ptr(&object->task_dist, &tmp32, buffer); + unpackstr_ptr(&object->tres_alloc_str, &tmp32, buffer); + unpackstr_ptr(&object->user_sec, &tmp32, buffer); + unpackstr_ptr(&object->user_usec, &tmp32, buffer); + } else if (rpc_version >= SLURM_15_08_PROTOCOL_VERSION) { unpackstr_ptr(&object->act_cpufreq, &tmp32, buffer); unpackstr_ptr(&object->ave_cpu, &tmp32, buffer); unpackstr_ptr(&object->ave_disk_read, &tmp32, buffer); diff --git a/src/slurmctld/slurmctld.h b/src/slurmctld/slurmctld.h index 41e4176c3500777fae6754c3e768393f7ba6e572..535c97e099961f03d69d7243224fd7981b54f901 100644 --- a/src/slurmctld/slurmctld.h +++ b/src/slurmctld/slurmctld.h @@ -825,6 +825,8 @@ struct step_record { char *name; /* name of job step */ char *network; /* step's network specification */ uint8_t no_kill; /* 1 if no kill on node failure */ + uint32_t packjobid; /* jobid of srun first step */ + uint32_t packstepid; /* stepid of srun first step */ uint16_t port; /* port for srun communications */ time_t pre_sus_time; /* time step ran prior to last suspend */ uint16_t start_protocol_ver; /* Slurm version step was diff --git a/src/slurmctld/step_mgr.c b/src/slurmctld/step_mgr.c index afd9c8987363c6d19ebd247e45f1878ac916df7c..929137664f41aae5217cd04294fb9c5d4c06c972 100644 --- a/src/slurmctld/step_mgr.c +++ b/src/slurmctld/step_mgr.c @@ -2890,6 +2890,8 @@ static void _pack_ctld_job_step_info(struct step_record *step_ptr, Buf buffer, protocol_version); packstr(step_ptr->tres_fmt_alloc_str, buffer); pack16(step_ptr->start_protocol_ver, buffer); + pack32(step_ptr->packjobid, buffer); + pack32(step_ptr->packstepid, buffer); } else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) { pack32(step_ptr->job_ptr->array_job_id, buffer); pack32(step_ptr->job_ptr->array_task_id, buffer);