/* * convert node_info_msg_t to perl HV */ int node_info_msg_to_hv(node_info_msg_t *node_info_msg, HV *hv) { int i; HV *hv_info; AV *av; STORE_FIELD(hv, node_info_msg, last_update, time_t); STORE_FIELD(hv, node_info_msg, node_scaling, uint16_t); /* record_count implied in node_array */ av = newAV(); for(i = 0; i < node_info_msg->record_count; i ++) { if (!node_info_msg->node_array[i].name) continue; hv_info =newHV(); if (node_info_to_hv(node_info_msg->node_array + i, node_info_msg->node_scaling, hv_info) < 0) { SvREFCNT_dec((SV*)hv_info); SvREFCNT_dec((SV*)av); return -1; } av_store(av, i, newRV_noinc((SV*)hv_info)); } hv_store_sv(hv, "node_array", newRV_noinc((SV*)av)); return 0; }
/* * convert job_step_stat_response_msg_t to perl HV */ int job_step_stat_response_msg_to_hv(job_step_stat_response_msg_t *stat_msg, HV *hv) { int i = 0; ListIterator itr; job_step_stat_t *stat; AV *av; HV *hv_stat; STORE_FIELD(hv, stat_msg, job_id, uint32_t); STORE_FIELD(hv, stat_msg, step_id, uint32_t); av = newAV(); itr = slurm_list_iterator_create(stat_msg->stats_list); while((stat = (job_step_stat_t *)slurm_list_next(itr))) { hv_stat = newHV(); if(job_step_stat_to_hv(stat, hv_stat) < 0) { Perl_warn(aTHX_ "failed to convert job_step_stat_t to hv for job_step_stat_response_msg_t"); SvREFCNT_dec(hv_stat); SvREFCNT_dec(av); return -1; } av_store(av, i++, newRV_noinc((SV*)hv_stat)); } slurm_list_iterator_destroy(itr); hv_store_sv(hv, "stats_list", newRV_noinc((SV*)av)); return 0; }
int report_assoc_rec_to_hv(slurmdb_report_assoc_rec_t* rec, HV* hv) { AV* my_av; HV* rh; slurmdb_tres_rec_t *tres_rec = NULL; ListIterator itr = NULL; STORE_FIELD(hv, rec, acct, charp); STORE_FIELD(hv, rec, cluster, charp); STORE_FIELD(hv, rec, parent_acct, charp); my_av = (AV*)sv_2mortal((SV*)newAV()); if (rec->tres_list) { itr = slurm_list_iterator_create(rec->tres_list); while ((tres_rec = slurm_list_next(itr))) { rh = (HV*)sv_2mortal((SV*)newHV()); if (tres_rec_to_hv(tres_rec, rh) < 0) { Perl_warn(aTHX_ "Failed to convert a tres_rec to a hv"); slurm_list_iterator_destroy(itr); return -1; } else { av_push(my_av, newRV((SV*)rh)); } } slurm_list_iterator_destroy(itr); } hv_store_sv(hv, "tres_list", newRV((SV*)my_av)); STORE_FIELD(hv, rec, user, charp); return 0; }
/* * convert node_info_msg_t to perl HV */ int node_info_msg_to_hv(node_info_msg_t *node_info_msg, HV *hv) { int i; HV *hv_info; AV *av; STORE_FIELD(hv, node_info_msg, last_update, time_t); STORE_FIELD(hv, node_info_msg, node_scaling, uint16_t); /* * node_info_msg->node_array will have node_records with NULL names for * nodes that are hidden. They are put in the array to preserve the * node_index which will match up with a partiton's node_inx[]. Add * empty hashes for nodes that have NULL names -- hidden nodes. */ av = newAV(); for(i = 0; i < node_info_msg->record_count; i ++) { hv_info =newHV(); if (node_info_msg->node_array[i].name && node_info_to_hv(node_info_msg->node_array + i, node_info_msg->node_scaling, hv_info) < 0) { SvREFCNT_dec((SV*)hv_info); SvREFCNT_dec((SV*)av); return -1; } av_store(av, i, newRV_noinc((SV*)hv_info)); } hv_store_sv(hv, "node_array", newRV_noinc((SV*)av)); return 0; }
int report_job_grouping_to_hv(slurmdb_report_job_grouping_t* rec, HV* hv) { AV* my_av; HV* rh; slurmdb_tres_rec_t *tres_rec = NULL; ListIterator itr = NULL; /* FIX ME: include the job list here (is is not NULL, as * previously thought) */ STORE_FIELD(hv, rec, min_size, uint32_t); STORE_FIELD(hv, rec, max_size, uint32_t); STORE_FIELD(hv, rec, count, uint32_t); my_av = (AV*)sv_2mortal((SV*)newAV()); if (rec->tres_list) { itr = slurm_list_iterator_create(rec->tres_list); while ((tres_rec = slurm_list_next(itr))) { rh = (HV*)sv_2mortal((SV*)newHV()); if (tres_rec_to_hv(tres_rec, rh) < 0) { Perl_warn(aTHX_ "Failed to convert a tres_rec to a hv"); slurm_list_iterator_destroy(itr); return -1; } else { av_push(my_av, newRV((SV*)rh)); } } slurm_list_iterator_destroy(itr); } hv_store_sv(hv, "tres_list", newRV((SV*)my_av)); return 0; }
/* * convert job_info_msg_t to perl HV */ int job_info_msg_to_hv(job_info_msg_t *job_info_msg, HV *hv) { int i; HV *hv_info; AV *av; _load_node_info(); STORE_FIELD(hv, job_info_msg, last_update, time_t); /* record_count implied in job_array */ av = newAV(); for(i = 0; i < job_info_msg->record_count; i ++) { hv_info = newHV(); if (job_info_to_hv(job_info_msg->job_array + i, hv_info) < 0) { SvREFCNT_dec(hv_info); SvREFCNT_dec(av); return -1; } av_store(av, i, newRV_noinc((SV*)hv_info)); } hv_store_sv(hv, "job_array", newRV_noinc((SV*)av)); _free_node_info(); return 0; }
/* * convert job_step_stat_t to perl HV */ int job_step_stat_to_hv(job_step_stat_t *stat, HV *hv) { HV *hv_pids; STORE_PTR_FIELD(hv, stat, jobacct, "Slurm::jobacctinfo_t"); STORE_FIELD(hv, stat, num_tasks, uint32_t); STORE_FIELD(hv, stat, return_code, uint32_t); hv_pids = newHV(); if (job_step_pids_to_hv(stat->step_pids, hv_pids) < 0) { Perl_warn(aTHX_ "failed to convert job_step_pids_t to hv for job_step_stat_t"); SvREFCNT_dec(hv_pids); return -1; } hv_store_sv(hv, "step_pids", newRV_noinc((SV*)hv_pids)); return 0; }
/* * convert job_step_create_response_msg_t to perl HV */ int job_step_create_response_msg_to_hv(job_step_create_response_msg_t *resp_msg, HV *hv) { HV *hv; STORE_FIELD(hv, resp_msg, job_step_id, uint32_t); if (resp_msg->resv_ports) STORE_FIELD(hv, resp_msg, resv_ports, charp); hv = newHV(); if (slurm_step_layout_to_hv(resp->step_layout, hv) < 0) { Perl_warn(aTHX_ "Failed to convert slurm_step_layout_t to hv for job_step_create_response_msg_t"); SvREFCNT_dec(hv); return -1; } hv_store(hv, "step_layout", 11, newRV_noinc((SV*)hv)); STORE_PTR_FIELD(hv, resp_msg, cred, "TODO"); STORE_PTR_FIELD(hv, resp_msg, switch_job, "TODO"); return 0; }
/* * convert slurm_step_layout_t to perl HV */ int slurm_step_layout_to_hv(slurm_step_layout_t *step_layout, HV *hv) { AV* av, *av2; int i, j; if (step_layout->front_end) STORE_FIELD(hv, step_layout, front_end, charp); STORE_FIELD(hv, step_layout, node_cnt, uint16_t); if (step_layout->node_list) STORE_FIELD(hv, step_layout, node_list, charp); else { Perl_warn(aTHX_ "node_list missing in slurm_step_layout_t"); return -1; } STORE_FIELD(hv, step_layout, plane_size, uint16_t); av = newAV(); for (i = 0; i < step_layout->node_cnt; i ++) av_store_uint16_t(av, i, step_layout->tasks[i]); hv_store_sv(hv, "tasks", newRV_noinc((SV*)av)); STORE_FIELD(hv, step_layout, task_cnt, uint32_t); STORE_FIELD(hv, step_layout, task_dist, uint16_t); av = newAV(); for (i = 0; i < step_layout->node_cnt; i ++) { av2 = newAV(); for (j = 0; j < step_layout->tasks[i]; j ++) av_store_uint32_t(av2, i, step_layout->tids[i][j]); av_store(av, i, newRV_noinc((SV*)av2)); } hv_store_sv(hv, "tids", newRV_noinc((SV*)av)); return 0; }
int cluster_rec_to_hv(slurmdb_cluster_rec_t* rec, HV* hv) { AV* my_av; HV* rh; ListIterator itr = NULL; slurmdb_cluster_accounting_rec_t* ar = NULL; my_av = (AV*)sv_2mortal((SV*)newAV()); if (rec->accounting_list) { itr = slurm_list_iterator_create(rec->accounting_list); while ((ar = slurm_list_next(itr))) { rh = (HV*)sv_2mortal((SV*)newHV()); if (cluster_accounting_rec_to_hv(ar, rh) < 0) { Perl_warn(aTHX_ "Failed to convert a cluster_accounting_rec to a hv"); slurm_list_iterator_destroy(itr); return -1; } else { av_push(my_av, newRV((SV*)rh)); } } slurm_list_iterator_destroy(itr); } hv_store_sv(hv, "accounting_list", newRV((SV*)my_av)); STORE_FIELD(hv, rec, classification, uint16_t); STORE_FIELD(hv, rec, control_host, charp); STORE_FIELD(hv, rec, control_port, uint32_t); STORE_FIELD(hv, rec, dimensions, uint16_t); STORE_FIELD(hv, rec, flags, uint32_t); STORE_FIELD(hv, rec, name, charp); STORE_FIELD(hv, rec, nodes, charp); STORE_FIELD(hv, rec, plugin_id_select, uint32_t); /* slurmdb_assoc_rec_t* root_assoc; */ STORE_FIELD(hv, rec, rpc_version, uint16_t); STORE_FIELD(hv, rec, tres_str, charp); return 0; }
/* convert job_step_pids_t to perl HV */ int job_step_pids_to_hv(job_step_pids_t *pids, HV *hv) { int i; AV *av; STORE_FIELD(hv, pids, node_name, charp); /* pid_cnt implied in pid array */ av = newAV(); for (i = 0; i < pids->pid_cnt; i ++) { av_store_uint32_t(av, i, pids->pid[i]); } hv_store_sv(hv, "pid", newRV_noinc((SV*)av)); return 0; }
/* * convert trigger_info_t to perl HV */ int trigger_info_to_hv(trigger_info_t *trigger_info, HV *hv) { STORE_FIELD(hv, trigger_info, trig_id, uint32_t); STORE_FIELD(hv, trigger_info, res_type, uint16_t); if(trigger_info->res_id) STORE_FIELD(hv, trigger_info, res_id, charp); STORE_FIELD(hv, trigger_info, trig_type, uint32_t); STORE_FIELD(hv, trigger_info, offset, uint16_t); STORE_FIELD(hv, trigger_info, user_id, uint32_t); if(trigger_info->program) STORE_FIELD(hv, trigger_info, program, charp); return 0; }
int tres_rec_to_hv(slurmdb_tres_rec_t* rec, HV* hv) { STORE_FIELD(hv, rec, alloc_secs, uint64_t); STORE_FIELD(hv, rec, rec_count, uint32_t); STORE_FIELD(hv, rec, count, uint64_t); STORE_FIELD(hv, rec, id, uint32_t); STORE_FIELD(hv, rec, name, charp); STORE_FIELD(hv, rec, type, charp); return 0; }
/* * convert partition_info_msg_t to perl HV */ int partition_info_msg_to_hv(partition_info_msg_t *part_info_msg, HV *hv) { int i; HV *hv_info; AV *av; STORE_FIELD(hv, part_info_msg, last_update, time_t); /* record_count implied in partition_array */ av = newAV(); for(i = 0; i < part_info_msg->record_count; i ++) { hv_info = newHV(); if (partition_info_to_hv(part_info_msg->partition_array + i, hv_info) < 0) { SvREFCNT_dec(hv_info); SvREFCNT_dec(av); return -1; } av_store(av, i, newRV_noinc((SV*)hv_info)); } hv_store_sv(hv, "partition_array", newRV_noinc((SV*)av)); return 0; }
int cluster_accounting_rec_to_hv(slurmdb_cluster_accounting_rec_t* ar, HV* hv) { HV* rh; STORE_FIELD(hv, ar, alloc_secs, uint64_t); STORE_FIELD(hv, ar, down_secs, uint64_t); STORE_FIELD(hv, ar, idle_secs, uint64_t); STORE_FIELD(hv, ar, over_secs, uint64_t); STORE_FIELD(hv, ar, pdown_secs, uint64_t); STORE_FIELD(hv, ar, period_start, time_t); STORE_FIELD(hv, ar, resv_secs, uint64_t); rh = (HV*)sv_2mortal((SV*)newHV()); if (tres_rec_to_hv(&ar->tres_rec, rh) < 0) { Perl_warn(aTHX_ "Failed to convert a tres_rec to a hv"); return -1; } hv_store_sv(hv, "tres_rec", newRV((SV*)rh)); return 0; }
/* * convert job_step_info_response_msg_t to perl HV */ int job_step_info_response_msg_to_hv( job_step_info_response_msg_t *job_step_info_msg, HV *hv) { int i; AV* av; HV* hv_info; STORE_FIELD(hv, job_step_info_msg, last_update, time_t); /* job_step_count implied in job_steps */ av = newAV(); for(i = 0; i < job_step_info_msg->job_step_count; i ++) { hv_info = newHV(); if (job_step_info_to_hv( job_step_info_msg->job_steps + i, hv_info) < 0) { SvREFCNT_dec(hv_info); SvREFCNT_dec(av); return -1; } av_store(av, i, newRV_noinc((SV*)hv_info)); } hv_store_sv(hv, "job_steps", newRV_noinc((SV*)av)); return 0; }
/* * convert slurmd_status_t to perl HV */ int slurmd_status_to_hv(slurmd_status_t *status, HV *hv) { STORE_FIELD(hv, status, booted, time_t); STORE_FIELD(hv, status, last_slurmctld_msg, time_t); STORE_FIELD(hv, status, slurmd_debug, uint16_t); STORE_FIELD(hv, status, actual_cpus, uint16_t); STORE_FIELD(hv, status, actual_sockets, uint16_t); STORE_FIELD(hv, status, actual_cores, uint16_t); STORE_FIELD(hv, status, actual_threads, uint16_t); STORE_FIELD(hv, status, actual_real_mem, uint32_t); STORE_FIELD(hv, status, actual_tmp_disk, uint32_t); STORE_FIELD(hv, status, pid, uint32_t); if (status->hostname) STORE_FIELD(hv, status, hostname, charp); if (status->slurmd_logfile) STORE_FIELD(hv, status, slurmd_logfile, charp); if (status->step_list) STORE_FIELD(hv, status, step_list, charp); if (status->version) STORE_FIELD(hv, status, version, charp); return 0; }
/* * convert slurm_ctl_conf_t into perl HV */ int slurm_ctl_conf_to_hv(slurm_ctl_conf_t *conf, HV *hv) { STORE_FIELD(hv, conf, last_update, time_t); if(conf->acct_gather_profile_type) STORE_FIELD(hv, conf, acct_gather_profile_type, charp); if(conf->acct_gather_infiniband_type) STORE_FIELD(hv, conf, acct_gather_infiniband_type, charp); if(conf->acct_gather_filesystem_type) STORE_FIELD(hv, conf, acct_gather_filesystem_type, charp); STORE_FIELD(hv, conf, accounting_storage_enforce, uint16_t); if(conf->accounting_storage_backup_host) STORE_FIELD(hv, conf, accounting_storage_backup_host, charp); if(conf->accounting_storage_host) STORE_FIELD(hv, conf, accounting_storage_host, charp); if(conf->accounting_storage_loc) STORE_FIELD(hv, conf, accounting_storage_loc, charp); /* accounting_storage_pass */ STORE_FIELD(hv, conf, accounting_storage_port, uint32_t); if(conf->accounting_storage_type) STORE_FIELD(hv, conf, accounting_storage_type, charp); if(conf->accounting_storage_user) STORE_FIELD(hv, conf, accounting_storage_user, charp); if(conf->authinfo) STORE_FIELD(hv, conf, authinfo, charp); if(conf->authtype) STORE_FIELD(hv, conf, authtype, charp); if(conf->backup_addr) STORE_FIELD(hv, conf, backup_addr, charp); if(conf->backup_controller) STORE_FIELD(hv, conf, backup_controller, charp); STORE_FIELD(hv, conf, batch_start_timeout, uint16_t); STORE_FIELD(hv, conf, boot_time, time_t); if(conf->checkpoint_type) STORE_FIELD(hv, conf, checkpoint_type, charp); if(conf->cluster_name) STORE_FIELD(hv, conf, cluster_name, charp); STORE_FIELD(hv, conf, complete_wait, uint16_t); if(conf->control_addr) STORE_FIELD(hv, conf, control_addr, charp); if(conf->control_machine) STORE_FIELD(hv, conf, control_machine, charp); if(conf->crypto_type) STORE_FIELD(hv, conf, crypto_type, charp); STORE_FIELD(hv, conf, debug_flags, uint32_t); STORE_FIELD(hv, conf, def_mem_per_cpu, uint32_t); STORE_FIELD(hv, conf, disable_root_jobs, uint16_t); STORE_FIELD(hv, conf, dynalloc_port, uint16_t); STORE_FIELD(hv, conf, enforce_part_limits, uint16_t); if(conf->epilog) STORE_FIELD(hv, conf, epilog, charp); STORE_FIELD(hv, conf, epilog_msg_time, uint32_t); if(conf->epilog_slurmctld) STORE_FIELD(hv, conf, epilog_slurmctld, charp); if(conf->ext_sensors_type) STORE_FIELD(hv, conf, ext_sensors_type, charp); STORE_FIELD(hv, conf, ext_sensors_freq, uint16_t); STORE_FIELD(hv, conf, fast_schedule, uint16_t); STORE_FIELD(hv, conf, first_job_id, uint32_t); STORE_FIELD(hv, conf, get_env_timeout, uint16_t); if(conf->gres_plugins) STORE_FIELD(hv, conf, gres_plugins, charp); STORE_FIELD(hv, conf, group_info, uint16_t); STORE_FIELD(hv, conf, hash_val, uint32_t); STORE_FIELD(hv, conf, health_check_interval, uint16_t); STORE_FIELD(hv, conf, health_check_node_state, uint16_t); if(conf->health_check_program) STORE_FIELD(hv, conf, health_check_program, charp); STORE_FIELD(hv, conf, inactive_limit, uint16_t); if (conf->job_acct_gather_type) STORE_FIELD(hv, conf, job_acct_gather_freq, charp); if(conf->job_acct_gather_type) STORE_FIELD(hv, conf, job_acct_gather_type, charp); if(conf->job_ckpt_dir) STORE_FIELD(hv, conf, job_ckpt_dir, charp); if(conf->job_comp_host) STORE_FIELD(hv, conf, job_comp_host, charp); if(conf->job_comp_loc) STORE_FIELD(hv, conf, job_comp_loc, charp); /* job_comp_pass */ STORE_FIELD(hv, conf, job_comp_port, uint32_t); if(conf->job_comp_type) STORE_FIELD(hv, conf, job_comp_type, charp); if(conf->job_comp_user) STORE_FIELD(hv, conf, job_comp_user, charp); if(conf->job_credential_private_key) STORE_FIELD(hv, conf, job_credential_private_key, charp); if(conf->job_credential_public_certificate) STORE_FIELD(hv, conf, job_credential_public_certificate, charp); STORE_FIELD(hv, conf, job_file_append, uint16_t); STORE_FIELD(hv, conf, job_requeue, uint16_t); if(conf->job_submit_plugins) STORE_FIELD(hv, conf, job_submit_plugins, charp); STORE_FIELD(hv, conf, keep_alive_time, uint16_t); STORE_FIELD(hv, conf, kill_on_bad_exit, uint16_t); STORE_FIELD(hv, conf, kill_wait, uint16_t); if(conf->licenses) STORE_FIELD(hv, conf, licenses, charp); if(conf->mail_prog) STORE_FIELD(hv, conf, mail_prog, charp); STORE_FIELD(hv, conf, max_array_sz, uint16_t); STORE_FIELD(hv, conf, max_job_cnt, uint16_t); STORE_FIELD(hv, conf, max_mem_per_cpu, uint32_t); STORE_FIELD(hv, conf, max_tasks_per_node, uint16_t); STORE_FIELD(hv, conf, min_job_age, uint16_t); if(conf->mpi_default) STORE_FIELD(hv, conf, mpi_default, charp); if(conf->mpi_params) STORE_FIELD(hv, conf, mpi_params, charp); STORE_FIELD(hv, conf, msg_timeout, uint16_t); STORE_FIELD(hv, conf, next_job_id, uint32_t); if(conf->node_prefix) STORE_FIELD(hv, conf, node_prefix, charp); STORE_FIELD(hv, conf, over_time_limit, uint16_t); if(conf->plugindir) STORE_FIELD(hv, conf, plugindir, charp); if(conf->plugstack) STORE_FIELD(hv, conf, plugstack, charp); STORE_FIELD(hv, conf, preempt_mode, uint16_t); if(conf->preempt_type) STORE_FIELD(hv, conf, preempt_type, charp); STORE_FIELD(hv, conf, priority_decay_hl, uint32_t); STORE_FIELD(hv, conf, priority_favor_small, uint16_t); STORE_FIELD(hv, conf, priority_max_age, uint32_t); STORE_FIELD(hv, conf, priority_reset_period, uint16_t); if(conf->priority_type) STORE_FIELD(hv, conf, priority_type, charp); STORE_FIELD(hv, conf, prolog_flags, uint16_t); STORE_FIELD(hv, conf, priority_weight_age, uint32_t); STORE_FIELD(hv, conf, priority_weight_fs, uint32_t); STORE_FIELD(hv, conf, priority_weight_js, uint32_t); STORE_FIELD(hv, conf, priority_weight_part, uint32_t); STORE_FIELD(hv, conf, priority_weight_qos, uint32_t); STORE_FIELD(hv, conf, private_data, uint16_t); if(conf->proctrack_type) STORE_FIELD(hv, conf, proctrack_type, charp); if(conf->prolog) STORE_FIELD(hv, conf, prolog, charp); if(conf->prolog_slurmctld) STORE_FIELD(hv, conf, prolog_slurmctld, charp); STORE_FIELD(hv, conf, propagate_prio_process, uint16_t); if(conf->propagate_rlimits) STORE_FIELD(hv, conf, propagate_rlimits, charp); if(conf->propagate_rlimits_except) STORE_FIELD(hv, conf, propagate_rlimits_except, charp); STORE_FIELD(hv, conf, reconfig_flags, uint16_t); if(conf->resume_program) STORE_FIELD(hv, conf, resume_program, charp); STORE_FIELD(hv, conf, resume_rate, uint16_t); STORE_FIELD(hv, conf, resume_timeout, uint16_t); if(conf->resv_epilog) STORE_FIELD(hv, conf, resv_epilog, charp); STORE_FIELD(hv, conf, resv_over_run, uint16_t); if(conf->resv_prolog) STORE_FIELD(hv, conf, resv_prolog, charp); STORE_FIELD(hv, conf, ret2service, uint16_t); if(conf->salloc_default_command) STORE_FIELD(hv, conf, salloc_default_command, charp); if(conf->sched_logfile) STORE_FIELD(hv, conf, sched_logfile, charp); STORE_FIELD(hv, conf, sched_log_level, uint16_t); if(conf->sched_params) STORE_FIELD(hv, conf, sched_params, charp); STORE_FIELD(hv, conf, sched_time_slice, uint16_t); if(conf->schedtype) STORE_FIELD(hv, conf, schedtype, charp); STORE_FIELD(hv, conf, schedport, uint16_t); STORE_FIELD(hv, conf, schedrootfltr, uint16_t); if(conf->select_type) STORE_FIELD(hv, conf, select_type, charp); STORE_PTR_FIELD(hv, conf, select_conf_key_pairs, "Slurm::List"); /* TODO: Think about memory management */ STORE_FIELD(hv, conf, select_type_param, uint16_t); if(conf->slurm_conf) STORE_FIELD(hv, conf, slurm_conf, charp); STORE_FIELD(hv, conf, slurm_user_id, uint32_t); if(conf->slurm_user_name) STORE_FIELD(hv, conf, slurm_user_name, charp); STORE_FIELD(hv, conf, slurmd_user_id, uint32_t); if(conf->slurmd_user_name) STORE_FIELD(hv, conf, slurmd_user_name, charp); STORE_FIELD(hv, conf, slurmctld_debug, uint16_t); if(conf->slurmctld_logfile) STORE_FIELD(hv, conf, slurmctld_logfile, charp); if(conf->slurmctld_pidfile) STORE_FIELD(hv, conf, slurmctld_pidfile, charp); if(conf->slurmctld_plugstack) STORE_FIELD(hv, conf, slurmctld_plugstack, charp); STORE_FIELD(hv, conf, slurmctld_port, uint32_t); STORE_FIELD(hv, conf, slurmctld_port_count, uint16_t); STORE_FIELD(hv, conf, slurmctld_timeout, uint16_t); STORE_FIELD(hv, conf, slurmd_debug, uint16_t); if(conf->slurmd_logfile) STORE_FIELD(hv, conf, slurmd_logfile, charp); if(conf->slurmd_pidfile) STORE_FIELD(hv, conf, slurmd_pidfile, charp); STORE_FIELD(hv, conf, slurmd_port, uint32_t); if(conf->slurmd_spooldir) STORE_FIELD(hv, conf, slurmd_spooldir, charp); STORE_FIELD(hv, conf, slurmd_timeout, uint16_t); if(conf->srun_epilog) STORE_FIELD(hv, conf, srun_epilog, charp); if(conf->srun_prolog) STORE_FIELD(hv, conf, srun_prolog, charp); if(conf->state_save_location) STORE_FIELD(hv, conf, state_save_location, charp); if(conf->suspend_exc_nodes) STORE_FIELD(hv, conf, suspend_exc_nodes, charp); if(conf->suspend_exc_parts) STORE_FIELD(hv, conf, suspend_exc_parts, charp); if(conf->suspend_program) STORE_FIELD(hv, conf, suspend_program, charp); STORE_FIELD(hv, conf, suspend_rate, uint16_t); STORE_FIELD(hv, conf, suspend_time, uint32_t); STORE_FIELD(hv, conf, suspend_timeout, uint16_t); if(conf->switch_type) STORE_FIELD(hv, conf, switch_type, charp); if(conf->task_epilog) STORE_FIELD(hv, conf, task_epilog, charp); if(conf->task_plugin) STORE_FIELD(hv, conf, task_plugin, charp); STORE_FIELD(hv, conf, task_plugin_param, uint16_t); if(conf->task_prolog) STORE_FIELD(hv, conf, task_prolog, charp); if(conf->tmp_fs) STORE_FIELD(hv, conf, tmp_fs, charp); if(conf->topology_plugin) STORE_FIELD(hv, conf, topology_plugin, charp); STORE_FIELD(hv, conf, track_wckey, uint16_t); STORE_FIELD(hv, conf, tree_width, uint16_t); if(conf->unkillable_program) STORE_FIELD(hv, conf, unkillable_program, charp); STORE_FIELD(hv, conf, unkillable_timeout, uint16_t); STORE_FIELD(hv, conf, use_pam, uint16_t); if(conf->version) STORE_FIELD(hv, conf, version, charp); STORE_FIELD(hv, conf, vsize_factor, uint16_t); STORE_FIELD(hv, conf, wait_time, uint16_t); return 0; }
/* * convert job_info_t to perl HV */ int job_info_to_hv(job_info_t *job_info, HV *hv) { int j; AV *av; if(job_info->account) STORE_FIELD(hv, job_info, account, charp); if(job_info->alloc_node) STORE_FIELD(hv, job_info, alloc_node, charp); STORE_FIELD(hv, job_info, alloc_sid, uint32_t); STORE_FIELD(hv, job_info, assoc_id, uint32_t); STORE_FIELD(hv, job_info, batch_flag, uint16_t); if(job_info->command) STORE_FIELD(hv, job_info, command, charp); if(job_info->comment) STORE_FIELD(hv, job_info, comment, charp); STORE_FIELD(hv, job_info, contiguous, uint16_t); STORE_FIELD(hv, job_info, cpus_per_task, uint16_t); if(job_info->dependency) STORE_FIELD(hv, job_info, dependency, charp); STORE_FIELD(hv, job_info, derived_ec, uint32_t); STORE_FIELD(hv, job_info, eligible_time, time_t); STORE_FIELD(hv, job_info, end_time, time_t); if(job_info->exc_nodes) STORE_FIELD(hv, job_info, exc_nodes, charp); av = newAV(); for(j = 0; ; j += 2) { if(job_info->exc_node_inx[j] == -1) break; av_store(av, j, newSVuv(job_info->exc_node_inx[j])); av_store(av, j+1, newSVuv(job_info->exc_node_inx[j+1])); } hv_store_sv(hv, "exc_node_inx", newRV_noinc((SV*)av)); STORE_FIELD(hv, job_info, exit_code, uint32_t); if(job_info->features) STORE_FIELD(hv, job_info, features, charp); if(job_info->gres) STORE_FIELD(hv, job_info, gres, charp); STORE_FIELD(hv, job_info, group_id, uint32_t); STORE_FIELD(hv, job_info, job_id, uint32_t); STORE_FIELD(hv, job_info, job_state, uint16_t); if(job_info->licenses) STORE_FIELD(hv, job_info, licenses, charp); STORE_FIELD(hv, job_info, max_cpus, uint32_t); STORE_FIELD(hv, job_info, max_nodes, uint32_t); STORE_FIELD(hv, job_info, sockets_per_node, uint16_t); STORE_FIELD(hv, job_info, cores_per_socket, uint16_t); STORE_FIELD(hv, job_info, threads_per_core, uint16_t); if(job_info->name) STORE_FIELD(hv, job_info, name, charp); if(job_info->network) STORE_FIELD(hv, job_info, network, charp); STORE_FIELD(hv, job_info, nice, uint16_t); if(job_info->nodes) STORE_FIELD(hv, job_info, nodes, charp); av = newAV(); for(j = 0; ; j += 2) { if(job_info->node_inx[j] == -1) break; av_store(av, j, newSVuv(job_info->node_inx[j])); av_store(av, j+1, newSVuv(job_info->node_inx[j+1])); } hv_store_sv(hv, "node_inx", newRV_noinc((SV*)av)); STORE_FIELD(hv, job_info, ntasks_per_core, uint16_t); STORE_FIELD(hv, job_info, ntasks_per_node, uint16_t); STORE_FIELD(hv, job_info, ntasks_per_socket, uint16_t); #ifdef HAVE_BG slurm_get_select_jobinfo(job_info->select_jobinfo, SELECT_JOBDATA_NODE_CNT, &job_info->num_nodes); #endif STORE_FIELD(hv, job_info, num_nodes, uint32_t); STORE_FIELD(hv, job_info, num_cpus, uint32_t); STORE_FIELD(hv, job_info, pn_min_memory, uint32_t); STORE_FIELD(hv, job_info, pn_min_cpus, uint16_t); STORE_FIELD(hv, job_info, pn_min_tmp_disk, uint32_t); if(job_info->partition) STORE_FIELD(hv, job_info, partition, charp); STORE_FIELD(hv, job_info, pre_sus_time, time_t); STORE_FIELD(hv, job_info, priority, uint32_t); if(job_info->qos) STORE_FIELD(hv, job_info, qos, charp); if(job_info->req_nodes) STORE_FIELD(hv, job_info, req_nodes, charp); av = newAV(); for(j = 0; ; j += 2) { if(job_info->req_node_inx[j] == -1) break; av_store(av, j, newSVuv(job_info->req_node_inx[j])); av_store(av, j+1, newSVuv(job_info->req_node_inx[j+1])); } hv_store_sv(hv, "req_node_inx", newRV_noinc((SV*)av)); STORE_FIELD(hv, job_info, req_switch, uint32_t); STORE_FIELD(hv, job_info, requeue, uint16_t); STORE_FIELD(hv, job_info, resize_time, time_t); STORE_FIELD(hv, job_info, restart_cnt, uint16_t); if(job_info->resv_name) STORE_FIELD(hv, job_info, resv_name, charp); STORE_PTR_FIELD(hv, job_info, select_jobinfo, "Slurm::dynamic_plugin_data_t"); STORE_PTR_FIELD(hv, job_info, job_resrcs, "Slurm::job_resources_t"); STORE_FIELD(hv, job_info, shared, uint16_t); STORE_FIELD(hv, job_info, show_flags, uint16_t); STORE_FIELD(hv, job_info, start_time, time_t); if(job_info->state_desc) STORE_FIELD(hv, job_info, state_desc, charp); STORE_FIELD(hv, job_info, state_reason, uint16_t); STORE_FIELD(hv, job_info, submit_time, time_t); STORE_FIELD(hv, job_info, suspend_time, time_t); STORE_FIELD(hv, job_info, time_limit, uint32_t); STORE_FIELD(hv, job_info, time_min, uint32_t); STORE_FIELD(hv, job_info, user_id, uint32_t); STORE_FIELD(hv, job_info, wait4switch, uint32_t); if(job_info->wckey) STORE_FIELD(hv, job_info, wckey, charp); if(job_info->work_dir) STORE_FIELD(hv, job_info, work_dir, charp); return 0; }
/* * convert job_step_info_t to perl HV */ int job_step_info_to_hv(job_step_info_t *step_info, HV *hv) { int j; AV *av; STORE_FIELD(hv, step_info, array_job_id, uint32_t); STORE_FIELD(hv, step_info, array_task_id, uint32_t); if(step_info->ckpt_dir) STORE_FIELD(hv, step_info, ckpt_dir, charp); STORE_FIELD(hv, step_info, ckpt_interval, uint16_t); if(step_info->gres) STORE_FIELD(hv, step_info, gres, charp); STORE_FIELD(hv, step_info, job_id, uint32_t); if(step_info->name) STORE_FIELD(hv, step_info, name, charp); if(step_info->network) STORE_FIELD(hv, step_info, network, charp); if(step_info->nodes) STORE_FIELD(hv, step_info, nodes, charp); av = newAV(); for(j = 0; ; j += 2) { if(step_info->node_inx[j] == -1) break; av_store_int(av, j, step_info->node_inx[j]); av_store_int(av, j+1, step_info->node_inx[j+1]); } hv_store_sv(hv, "node_inx", newRV_noinc((SV*)av)); STORE_FIELD(hv, step_info, num_cpus, uint32_t); STORE_FIELD(hv, step_info, num_tasks, uint32_t); if(step_info->partition) STORE_FIELD(hv, step_info, partition, charp); STORE_FIELD(hv, step_info, profile, uint32_t); if(step_info->resv_ports) STORE_FIELD(hv, step_info, resv_ports, charp); STORE_FIELD(hv, step_info, run_time, time_t); STORE_FIELD(hv, step_info, start_time, time_t); STORE_FIELD(hv, step_info, step_id, uint32_t); STORE_FIELD(hv, step_info, time_limit, uint32_t); STORE_FIELD(hv, step_info, user_id, uint32_t); STORE_FIELD(hv, step_info, state, uint16_t); return 0; }
int qos_rec_to_hv(slurmdb_qos_rec_t* rec, HV* hv, List all_qos) { char *preempt = NULL; preempt = slurmdb_get_qos_complete_str_bitstr(all_qos, rec->preempt_bitstr); hv_store_charp(hv, "preempt", preempt); STORE_FIELD(hv, rec, description, charp); STORE_FIELD(hv, rec, id, uint32_t); STORE_FIELD(hv, rec, flags, uint32_t); STORE_FIELD(hv, rec, grace_time, uint32_t); STORE_FIELD(hv, rec, grp_jobs, uint32_t); STORE_FIELD(hv, rec, grp_submit_jobs, uint32_t); STORE_FIELD(hv, rec, grp_tres, charp); STORE_FIELD(hv, rec, grp_tres_mins, charp); STORE_FIELD(hv, rec, grp_tres_run_mins, charp); STORE_FIELD(hv, rec, grp_wall, uint32_t); STORE_FIELD(hv, rec, max_jobs_pu, uint32_t); STORE_FIELD(hv, rec, max_submit_jobs_pu, uint32_t); STORE_FIELD(hv, rec, max_tres_mins_pj, charp); STORE_FIELD(hv, rec, max_tres_pj, charp); STORE_FIELD(hv, rec, max_tres_pn, charp); STORE_FIELD(hv, rec, max_tres_pu, charp); STORE_FIELD(hv, rec, max_tres_run_mins_pu,charp); STORE_FIELD(hv, rec, max_wall_pj, uint32_t); STORE_FIELD(hv, rec, min_tres_pj, charp); STORE_FIELD(hv, rec, name, charp); STORE_FIELD(hv, rec, preempt_mode, uint16_t); STORE_FIELD(hv, rec, priority, uint32_t); STORE_FIELD(hv, rec, usage_factor, double); STORE_FIELD(hv, rec, usage_thres, double); return 0; }
int step_rec_to_hv(slurmdb_step_rec_t *rec, HV* hv) { HV* stats_hv = (HV*)sv_2mortal((SV*)newHV()); stats_to_hv(&rec->stats, stats_hv); hv_store_sv(hv, "stats", newRV((SV*)stats_hv)); STORE_FIELD(hv, rec, elapsed, uint32_t); STORE_FIELD(hv, rec, end, time_t); STORE_FIELD(hv, rec, exitcode, int32_t); STORE_FIELD(hv, rec, nnodes, uint32_t); STORE_FIELD(hv, rec, nodes, charp); STORE_FIELD(hv, rec, ntasks, uint32_t); STORE_FIELD(hv, rec, pid_str, charp); STORE_FIELD(hv, rec, req_cpufreq_min, uint32_t); STORE_FIELD(hv, rec, req_cpufreq_max, uint32_t); STORE_FIELD(hv, rec, req_cpufreq_gov, uint32_t); STORE_FIELD(hv, rec, requid, uint32_t); STORE_FIELD(hv, rec, start, time_t); STORE_FIELD(hv, rec, state, uint32_t); STORE_FIELD(hv, rec, stepid, uint32_t); STORE_FIELD(hv, rec, stepname, charp); STORE_FIELD(hv, rec, suspended, uint32_t); STORE_FIELD(hv, rec, sys_cpu_sec, uint32_t); STORE_FIELD(hv, rec, sys_cpu_usec, uint32_t); STORE_FIELD(hv, rec, task_dist, uint16_t); STORE_FIELD(hv, rec, tot_cpu_sec, uint32_t); STORE_FIELD(hv, rec, tot_cpu_usec, uint32_t); STORE_FIELD(hv, rec, tres_alloc_str, charp); STORE_FIELD(hv, rec, user_cpu_sec, uint32_t); STORE_FIELD(hv, rec, user_cpu_usec, uint32_t); return 0; }
int stats_to_hv(slurmdb_stats_t *stats, HV* hv) { STORE_FIELD(hv, stats, act_cpufreq, double); STORE_FIELD(hv, stats, cpu_ave, double); STORE_FIELD(hv, stats, consumed_energy, double); STORE_FIELD(hv, stats, cpu_min, uint32_t); STORE_FIELD(hv, stats, cpu_min_nodeid, uint32_t); STORE_FIELD(hv, stats, cpu_min_taskid, uint32_t); STORE_FIELD(hv, stats, disk_read_ave, double); STORE_FIELD(hv, stats, disk_read_max, double); STORE_FIELD(hv, stats, disk_read_max_nodeid, uint32_t); STORE_FIELD(hv, stats, disk_read_max_taskid, uint32_t); STORE_FIELD(hv, stats, disk_write_ave, double); STORE_FIELD(hv, stats, disk_write_max, double); STORE_FIELD(hv, stats, disk_write_max_nodeid, uint32_t); STORE_FIELD(hv, stats, disk_write_max_taskid, uint32_t); STORE_FIELD(hv, stats, pages_ave, double); STORE_FIELD(hv, stats, pages_max, uint64_t); STORE_FIELD(hv, stats, pages_max_nodeid, uint32_t); STORE_FIELD(hv, stats, pages_max_taskid, uint32_t); STORE_FIELD(hv, stats, rss_ave, double); STORE_FIELD(hv, stats, rss_max, uint64_t); STORE_FIELD(hv, stats, rss_max_nodeid, uint32_t); STORE_FIELD(hv, stats, rss_max_taskid, uint32_t); STORE_FIELD(hv, stats, vsize_ave, double); STORE_FIELD(hv, stats, vsize_max, uint64_t); STORE_FIELD(hv, stats, vsize_max_nodeid, uint32_t); STORE_FIELD(hv, stats, vsize_max_taskid, uint32_t); return 0; }
int report_cluster_rec_to_hv(slurmdb_report_cluster_rec_t* rec, HV* hv) { AV* my_av; HV* rh; slurmdb_report_assoc_rec_t* ar = NULL; slurmdb_report_user_rec_t* ur = NULL; slurmdb_tres_rec_t *tres_rec = NULL; ListIterator itr = NULL; /* FIXME: do the accounting_list (add function to parse * slurmdb_accounting_rec_t) */ my_av = (AV*)sv_2mortal((SV*)newAV()); if (rec->assoc_list) { itr = slurm_list_iterator_create(rec->assoc_list); while ((ar = slurm_list_next(itr))) { rh = (HV*)sv_2mortal((SV*)newHV()); if (report_assoc_rec_to_hv(ar, rh) < 0) { Perl_warn(aTHX_ "Failed to convert a report_assoc_rec to a hv"); slurm_list_iterator_destroy(itr); return -1; } else { av_push(my_av, newRV((SV*)rh)); } } slurm_list_iterator_destroy(itr); } hv_store_sv(hv, "assoc_list", newRV((SV*)my_av)); STORE_FIELD(hv, rec, name, charp); my_av = (AV*)sv_2mortal((SV*)newAV()); if (rec->tres_list) { itr = slurm_list_iterator_create(rec->tres_list); while ((tres_rec = slurm_list_next(itr))) { rh = (HV*)sv_2mortal((SV*)newHV()); if (tres_rec_to_hv(tres_rec, rh) < 0) { Perl_warn(aTHX_ "Failed to convert a tres_rec to a hv"); slurm_list_iterator_destroy(itr); return -1; } else { av_push(my_av, newRV((SV*)rh)); } } slurm_list_iterator_destroy(itr); } hv_store_sv(hv, "tres_list", newRV((SV*)my_av)); my_av = (AV*)sv_2mortal((SV*)newAV()); if (rec->user_list) { itr = slurm_list_iterator_create(rec->user_list); while ((ur = slurm_list_next(itr))) { rh = (HV*)sv_2mortal((SV*)newHV()); if (report_user_rec_to_hv(ur, rh) < 0) { Perl_warn(aTHX_ "Failed to convert a report_user_rec to a hv"); slurm_list_iterator_destroy(itr); return -1; } else { av_push(my_av, newRV((SV*)rh)); } } slurm_list_iterator_destroy(itr); } hv_store_sv(hv, "user_list", newRV((SV*)my_av)); return 0; }
/* * convert reserve_info_t to perl HV */ int reserve_info_to_hv(reserve_info_t *reserve_info, HV *hv) { if (reserve_info->accounts) STORE_FIELD(hv, reserve_info, accounts, charp); STORE_FIELD(hv, reserve_info, end_time, time_t); if (reserve_info->features) STORE_FIELD(hv, reserve_info, features, charp); STORE_FIELD(hv, reserve_info, flags, uint16_t); if (reserve_info->licenses) STORE_FIELD(hv, reserve_info, licenses, charp); if (reserve_info->name) STORE_FIELD(hv, reserve_info, name, charp); STORE_FIELD(hv, reserve_info, node_cnt, uint32_t); if (reserve_info->node_list) STORE_FIELD(hv, reserve_info, node_list, charp); /* no store for int pointers yet */ if (reserve_info->node_inx) { int j; AV *av = newAV(); for(j = 0; ; j += 2) { if(reserve_info->node_inx[j] == -1) break; av_store(av, j, newSVuv(reserve_info->node_inx[j])); av_store(av, j+1, newSVuv(reserve_info->node_inx[j+1])); } hv_store_sv(hv, "node_inx", newRV_noinc((SV*)av)); } if (reserve_info->partition) STORE_FIELD(hv, reserve_info, partition, charp); STORE_FIELD(hv, reserve_info, start_time, time_t); if (reserve_info->users) STORE_FIELD(hv, reserve_info, users, charp); return 0; }
/* * convert partition_info_t to perl HV */ int partition_info_to_hv(partition_info_t *part_info, HV *hv) { if (part_info->allow_alloc_nodes) STORE_FIELD(hv, part_info, allow_alloc_nodes, charp); if (part_info->allow_groups) STORE_FIELD(hv, part_info, allow_groups, charp); if (part_info->alternate) STORE_FIELD(hv, part_info, alternate, charp); if (part_info->cr_type) STORE_FIELD(hv, part_info, cr_type, uint16_t); if (part_info->def_mem_per_cpu) STORE_FIELD(hv, part_info, def_mem_per_cpu, uint32_t); STORE_FIELD(hv, part_info, default_time, uint32_t); if (part_info->deny_accounts) STORE_FIELD(hv, part_info, deny_accounts, charp); if (part_info->deny_qos) STORE_FIELD(hv, part_info, deny_qos, charp); STORE_FIELD(hv, part_info, flags, uint16_t); if (part_info->grace_time) STORE_FIELD(hv, part_info, grace_time, uint32_t); if (part_info->max_cpus_per_node) STORE_FIELD(hv, part_info, max_cpus_per_node, uint32_t); if (part_info->max_mem_per_cpu) STORE_FIELD(hv, part_info, max_mem_per_cpu, uint32_t); STORE_FIELD(hv, part_info, max_nodes, uint32_t); STORE_FIELD(hv, part_info, max_share, uint16_t); STORE_FIELD(hv, part_info, max_time, uint32_t); STORE_FIELD(hv, part_info, min_nodes, uint32_t); if (part_info->name) STORE_FIELD(hv, part_info, name, charp); else { Perl_warn(aTHX_ "partition name missing in partition_info_t"); return -1; } /* no store for int pointers yet */ if (part_info->node_inx) { int j; AV* av = newAV(); for(j = 0; ; j += 2) { if(part_info->node_inx[j] == -1) break; av_store(av, j, newSVuv(part_info->node_inx[j])); av_store(av, j+1, newSVuv(part_info->node_inx[j+1])); } hv_store_sv(hv, "node_inx", newRV_noinc((SV*)av)); } if (part_info->nodes) STORE_FIELD(hv, part_info, nodes, charp); STORE_FIELD(hv, part_info, preempt_mode, uint16_t); STORE_FIELD(hv, part_info, priority, uint16_t); if (part_info->qos_char) STORE_FIELD(hv, part_info, qos_char, charp); STORE_FIELD(hv, part_info, state_up, uint16_t); STORE_FIELD(hv, part_info, total_cpus, uint32_t); STORE_FIELD(hv, part_info, total_nodes, uint32_t); return 0; }
/* * convert node_info_t to perl HV */ int node_info_to_hv(node_info_t *node_info, uint16_t node_scaling, HV *hv) { uint16_t err_cpus = 0, alloc_cpus = 0; #ifdef HAVE_BG int cpus_per_node = 1; if(node_scaling) cpus_per_node = node_info->cpus / node_scaling; #endif if(node_info->arch) STORE_FIELD(hv, node_info, arch, charp); STORE_FIELD(hv, node_info, boot_time, time_t); STORE_FIELD(hv, node_info, cores, uint16_t); STORE_FIELD(hv, node_info, cpu_load, uint32_t); STORE_FIELD(hv, node_info, cpus, uint16_t); if (node_info->features) STORE_FIELD(hv, node_info, features, charp); if (node_info->features_act) STORE_FIELD(hv, node_info, features_act, charp); if (node_info->gres) STORE_FIELD(hv, node_info, gres, charp); if (node_info->name) STORE_FIELD(hv, node_info, name, charp); else { Perl_warn (aTHX_ "node name missing in node_info_t"); return -1; } STORE_FIELD(hv, node_info, node_state, uint32_t); if(node_info->os) STORE_FIELD(hv, node_info, os, charp); STORE_FIELD(hv, node_info, real_memory, uint64_t); if(node_info->reason) STORE_FIELD(hv, node_info, reason, charp); STORE_FIELD(hv, node_info, reason_time, time_t); STORE_FIELD(hv, node_info, reason_uid, uint32_t); STORE_FIELD(hv, node_info, slurmd_start_time, time_t); STORE_FIELD(hv, node_info, boards, uint16_t); STORE_FIELD(hv, node_info, sockets, uint16_t); STORE_FIELD(hv, node_info, threads, uint16_t); STORE_FIELD(hv, node_info, tmp_disk, uint32_t); slurm_get_select_nodeinfo(node_info->select_nodeinfo, SELECT_NODEDATA_SUBCNT, NODE_STATE_ALLOCATED, &alloc_cpus); #ifdef HAVE_BG if(!alloc_cpus && (IS_NODE_ALLOCATED(node_info) || IS_NODE_COMPLETING(node_info))) alloc_cpus = node_info->cpus; else alloc_cpus *= cpus_per_node; #endif slurm_get_select_nodeinfo(node_info->select_nodeinfo, SELECT_NODEDATA_SUBCNT, NODE_STATE_ERROR, &err_cpus); #ifdef HAVE_BG err_cpus *= cpus_per_node; #endif hv_store_uint16_t(hv, "alloc_cpus", alloc_cpus); hv_store_uint16_t(hv, "err_cpus", err_cpus); STORE_PTR_FIELD(hv, node_info, select_nodeinfo, "Slurm::dynamic_plugin_data_t"); STORE_FIELD(hv, node_info, weight, uint32_t); return 0; }
int job_rec_to_hv(slurmdb_job_rec_t* rec, HV* hv) { slurmdb_step_rec_t *step; ListIterator itr = NULL; AV* steps_av = (AV*)sv_2mortal((SV*)newAV()); HV* stats_hv = (HV*)sv_2mortal((SV*)newHV()); HV* step_hv; stats_to_hv(&rec->stats, stats_hv); hv_store_sv(hv, "stats", newRV((SV*)stats_hv)); if (rec->steps) { itr = slurm_list_iterator_create(rec->steps); while ((step = slurm_list_next(itr))) { step_hv = (HV*)sv_2mortal((SV*)newHV()); step_rec_to_hv(step, step_hv); av_push(steps_av, newRV((SV*)step_hv)); } slurm_list_iterator_destroy(itr); } hv_store_sv(hv, "steps", newRV((SV*)steps_av)); STORE_FIELD(hv, rec, account, charp); STORE_FIELD(hv, rec, alloc_gres, charp); STORE_FIELD(hv, rec, alloc_nodes, uint32_t); STORE_FIELD(hv, rec, array_job_id, uint32_t); STORE_FIELD(hv, rec, array_max_tasks, uint32_t); STORE_FIELD(hv, rec, array_task_id, uint32_t); STORE_FIELD(hv, rec, array_task_str, charp); STORE_FIELD(hv, rec, associd, uint32_t); STORE_FIELD(hv, rec, blockid, charp); STORE_FIELD(hv, rec, cluster, charp); STORE_FIELD(hv, rec, derived_ec, uint32_t); STORE_FIELD(hv, rec, derived_es, charp); STORE_FIELD(hv, rec, elapsed, uint32_t); STORE_FIELD(hv, rec, eligible, time_t); STORE_FIELD(hv, rec, end, time_t); STORE_FIELD(hv, rec, exitcode, uint32_t); /*STORE_FIELD(hv, rec, first_step_ptr, void*);*/ STORE_FIELD(hv, rec, gid, uint32_t); STORE_FIELD(hv, rec, jobid, uint32_t); STORE_FIELD(hv, rec, jobname, charp); STORE_FIELD(hv, rec, lft, uint32_t); STORE_FIELD(hv, rec, partition, charp); STORE_FIELD(hv, rec, nodes, charp); STORE_FIELD(hv, rec, priority, uint32_t); STORE_FIELD(hv, rec, qosid, uint32_t); STORE_FIELD(hv, rec, req_cpus, uint32_t); STORE_FIELD(hv, rec, req_gres, charp); STORE_FIELD(hv, rec, req_mem, uint32_t); STORE_FIELD(hv, rec, requid, uint32_t); STORE_FIELD(hv, rec, resvid, uint32_t); STORE_FIELD(hv, rec, resv_name, charp); STORE_FIELD(hv, rec, show_full, uint32_t); STORE_FIELD(hv, rec, start, time_t); STORE_FIELD(hv, rec, state, uint32_t); STORE_FIELD(hv, rec, submit, time_t); STORE_FIELD(hv, rec, suspended, uint32_t); STORE_FIELD(hv, rec, sys_cpu_sec, uint32_t); STORE_FIELD(hv, rec, sys_cpu_usec, uint32_t); STORE_FIELD(hv, rec, timelimit, uint32_t); STORE_FIELD(hv, rec, tot_cpu_sec, uint32_t); STORE_FIELD(hv, rec, tot_cpu_usec, uint32_t); STORE_FIELD(hv, rec, track_steps, uint16_t); STORE_FIELD(hv, rec, tres_alloc_str, charp); STORE_FIELD(hv, rec, uid, uint32_t); STORE_FIELD(hv, rec, used_gres, charp); STORE_FIELD(hv, rec, user, charp); STORE_FIELD(hv, rec, user_cpu_sec, uint32_t); STORE_FIELD(hv, rec, user_cpu_usec, uint32_t); STORE_FIELD(hv, rec, wckey, charp); STORE_FIELD(hv, rec, wckeyid, uint32_t); return 0; }