extern void jobacctinfo_pack(jobacctinfo_t *jobacct,
uint16_t rpc_version, uint16_t protocol_type,
Buf buffer)
{
int i = 0;
bool no_pack;
no_pack = (!plugin_polling && (protocol_type != PROTOCOL_TYPE_DBD));
/* The function can take calls from both DBD and from regular
* SLURM functions. We choose to standardize on using the
* SLURM_PROTOCOL_VERSION here so if PROTOCOL_TYPE_DBD comes
* in we need to translate the DBD rpc_version to use the
* SLURM protocol_version.
*
* If this function ever changes make sure the
* slurmdbd_translate_rpc function has been updated with the
* new protocol version.
*/
if (protocol_type == PROTOCOL_TYPE_DBD)
rpc_version = slurmdbd_translate_rpc(rpc_version);
if (rpc_version >= SLURM_14_03_PROTOCOL_VERSION) {
if (!jobacct || no_pack) {
pack8((uint8_t) 0, buffer);
return;
}
pack8((uint8_t) 1, buffer);
pack32((uint32_t)jobacct->user_cpu_sec, buffer);
pack32((uint32_t)jobacct->user_cpu_usec, buffer);
pack32((uint32_t)jobacct->sys_cpu_sec, buffer);
pack32((uint32_t)jobacct->sys_cpu_usec, buffer);
pack64(jobacct->max_vsize, buffer);
pack64(jobacct->tot_vsize, buffer);
pack64(jobacct->max_rss, buffer);
pack64(jobacct->tot_rss, buffer);
pack64(jobacct->max_pages, buffer);
pack64(jobacct->tot_pages, buffer);
pack32((uint32_t)jobacct->min_cpu, buffer);
pack32((uint32_t)jobacct->tot_cpu, buffer);
pack32((uint32_t)jobacct->act_cpufreq, buffer);
pack32((uint32_t)jobacct->energy.consumed_energy, buffer);
packdouble((double)jobacct->max_disk_read, buffer);
packdouble((double)jobacct->tot_disk_read, buffer);
packdouble((double)jobacct->max_disk_write, buffer);
packdouble((double)jobacct->tot_disk_write, buffer);
_pack_jobacct_id(&jobacct->max_vsize_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_rss_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_pages_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->min_cpu_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_disk_read_id, rpc_version,
buffer);
_pack_jobacct_id(&jobacct->max_disk_write_id, rpc_version,
buffer);
} else if (rpc_version >= SLURM_2_6_PROTOCOL_VERSION) {
if (no_pack)
return;
if (!jobacct) {
for (i = 0; i < 14; i++)
pack32((uint32_t) 0, buffer);
for (i = 0; i < 4; i++)
packdouble((double) 0, buffer);
for (i = 0; i < 6; i++)
_pack_jobacct_id(NULL, rpc_version, buffer);
return;
}
pack32((uint32_t)jobacct->user_cpu_sec, buffer);
pack32((uint32_t)jobacct->user_cpu_usec, buffer);
pack32((uint32_t)jobacct->sys_cpu_sec, buffer);
pack32((uint32_t)jobacct->sys_cpu_usec, buffer);
pack32((uint32_t)jobacct->max_vsize, buffer);
pack32((uint32_t)jobacct->tot_vsize, buffer);
pack32((uint32_t)jobacct->max_rss, buffer);
pack32((uint32_t)jobacct->tot_rss, buffer);
pack32((uint32_t)jobacct->max_pages, buffer);
pack32((uint32_t)jobacct->tot_pages, buffer);
pack32((uint32_t)jobacct->min_cpu, buffer);
pack32((uint32_t)jobacct->tot_cpu, buffer);
pack32((uint32_t)jobacct->act_cpufreq, buffer);
pack32((uint32_t)jobacct->energy.consumed_energy, buffer);
packdouble((double)jobacct->max_disk_read, buffer);
packdouble((double)jobacct->tot_disk_read, buffer);
packdouble((double)jobacct->max_disk_write, buffer);
packdouble((double)jobacct->tot_disk_write, buffer);
_pack_jobacct_id(&jobacct->max_vsize_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_rss_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_pages_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->min_cpu_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_disk_read_id, rpc_version,
buffer);
_pack_jobacct_id(&jobacct->max_disk_write_id, rpc_version,
buffer);
} else {
info("jobacctinfo_pack version %u not supported", rpc_version);
return;
}
}
/* Pack all scheduling statistics */
extern void pack_all_stat(int resp, char **buffer_ptr, int *buffer_size,
uint16_t protocol_version)
{
Buf buffer;
int parts_packed;
int agent_queue_size;
time_t now = time(NULL);
uint32_t uint32_tmp = 0;
buffer_ptr[0] = NULL;
*buffer_size = 0;
buffer = init_buf(BUF_SIZE);
if (protocol_version >= SLURM_15_08_PROTOCOL_VERSION) {
parts_packed = resp;
pack32(parts_packed, buffer);
if (resp) {
pack_time(now, buffer);
debug3("pack_all_stat: time = %u",
(uint32_t) last_proc_req_start);
pack_time(last_proc_req_start, buffer);
debug3("pack_all_stat: server_thread_count = %u",
slurmctld_config.server_thread_count);
pack32(slurmctld_config.server_thread_count, buffer);
agent_queue_size = retry_list_size();
pack32(agent_queue_size, buffer);
pack32(slurmctld_diag_stats.jobs_submitted, buffer);
pack32(slurmctld_diag_stats.jobs_started, buffer);
pack32(slurmctld_diag_stats.jobs_completed, buffer);
pack32(slurmctld_diag_stats.jobs_canceled, buffer);
pack32(slurmctld_diag_stats.jobs_failed, buffer);
pack32(slurmctld_diag_stats.schedule_cycle_max,
buffer);
pack32(slurmctld_diag_stats.schedule_cycle_last,
buffer);
pack32(slurmctld_diag_stats.schedule_cycle_sum,
buffer);
pack32(slurmctld_diag_stats.schedule_cycle_counter,
buffer);
pack32(slurmctld_diag_stats.schedule_cycle_depth,
buffer);
pack32(slurmctld_diag_stats.schedule_queue_len, buffer);
pack32(slurmctld_diag_stats.backfilled_jobs, buffer);
pack32(slurmctld_diag_stats.last_backfilled_jobs,
buffer);
pack32(slurmctld_diag_stats.bf_cycle_counter, buffer);
pack64(slurmctld_diag_stats.bf_cycle_sum, buffer);
pack32(slurmctld_diag_stats.bf_cycle_last, buffer);
pack32(slurmctld_diag_stats.bf_last_depth, buffer);
pack32(slurmctld_diag_stats.bf_last_depth_try, buffer);
pack32(slurmctld_diag_stats.bf_queue_len, buffer);
pack32(slurmctld_diag_stats.bf_cycle_max, buffer);
pack_time(slurmctld_diag_stats.bf_when_last_cycle,
buffer);
pack32(slurmctld_diag_stats.bf_depth_sum, buffer);
pack32(slurmctld_diag_stats.bf_depth_try_sum, buffer);
pack32(slurmctld_diag_stats.bf_queue_len_sum, buffer);
pack32(slurmctld_diag_stats.bf_active, buffer);
}
} else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
parts_packed = resp;
pack32(parts_packed, buffer);
if (resp) {
pack_time(now, buffer);
debug3("pack_all_stat: time = %u",
(uint32_t) last_proc_req_start);
pack_time(last_proc_req_start, buffer);
debug3("pack_all_stat: server_thread_count = %u",
slurmctld_config.server_thread_count);
pack32(slurmctld_config.server_thread_count, buffer);
agent_queue_size = retry_list_size();
pack32(agent_queue_size, buffer);
pack32(slurmctld_diag_stats.jobs_submitted, buffer);
pack32(slurmctld_diag_stats.jobs_started, buffer);
pack32(slurmctld_diag_stats.jobs_completed, buffer);
pack32(slurmctld_diag_stats.jobs_canceled, buffer);
pack32(slurmctld_diag_stats.jobs_failed, buffer);
pack32(slurmctld_diag_stats.schedule_cycle_max,
buffer);
pack32(slurmctld_diag_stats.schedule_cycle_last,
buffer);
pack32(slurmctld_diag_stats.schedule_cycle_sum,
buffer);
pack32(slurmctld_diag_stats.schedule_cycle_counter,
buffer);
pack32(slurmctld_diag_stats.schedule_cycle_depth,
buffer);
pack32(slurmctld_diag_stats.schedule_queue_len, buffer);
pack32(slurmctld_diag_stats.backfilled_jobs, buffer);
pack32(slurmctld_diag_stats.last_backfilled_jobs,
buffer);
pack32(slurmctld_diag_stats.bf_cycle_counter, buffer);
uint32_tmp = (uint32_t)slurmctld_diag_stats.bf_cycle_sum;
pack32(uint32_tmp, buffer);
pack32(slurmctld_diag_stats.bf_cycle_last, buffer);
pack32(slurmctld_diag_stats.bf_last_depth, buffer);
pack32(slurmctld_diag_stats.bf_last_depth_try, buffer);
pack32(slurmctld_diag_stats.bf_queue_len, buffer);
pack32(slurmctld_diag_stats.bf_cycle_max, buffer);
pack_time(slurmctld_diag_stats.bf_when_last_cycle,
buffer);
pack32(slurmctld_diag_stats.bf_depth_sum, buffer);
pack32(slurmctld_diag_stats.bf_depth_try_sum, buffer);
pack32(slurmctld_diag_stats.bf_queue_len_sum, buffer);
pack32(slurmctld_diag_stats.bf_active, buffer);
}
}
*buffer_size = get_buf_offset(buffer);
buffer_ptr[0] = xfer_buf_data(buffer);
}
void LIR_Assembler::emit_op1(LIR_Op1* op) {
switch (op->code()) {
case lir_move:
if (op->move_kind() == lir_move_volatile) {
assert(op->patch_code() == lir_patch_none, "can't patch volatiles");
volatile_move_op(op->in_opr(), op->result_opr(), op->type(), op->info());
} else {
move_op(op->in_opr(), op->result_opr(), op->type(),
op->patch_code(), op->info(), op->pop_fpu_stack(),
op->move_kind() == lir_move_unaligned,
op->move_kind() == lir_move_wide);
}
break;
case lir_prefetchr:
prefetchr(op->in_opr());
break;
case lir_prefetchw:
prefetchw(op->in_opr());
break;
case lir_roundfp: {
LIR_OpRoundFP* round_op = op->as_OpRoundFP();
roundfp_op(round_op->in_opr(), round_op->tmp(), round_op->result_opr(), round_op->pop_fpu_stack());
break;
}
case lir_return:
return_op(op->in_opr());
break;
case lir_safepoint:
if (compilation()->debug_info_recorder()->last_pc_offset() == code_offset()) {
_masm->nop();
}
safepoint_poll(op->in_opr(), op->info());
break;
case lir_fxch:
fxch(op->in_opr()->as_jint());
break;
case lir_fld:
fld(op->in_opr()->as_jint());
break;
case lir_ffree:
ffree(op->in_opr()->as_jint());
break;
case lir_branch:
break;
case lir_push:
push(op->in_opr());
break;
case lir_pop:
pop(op->in_opr());
break;
case lir_neg:
negate(op->in_opr(), op->result_opr());
break;
case lir_leal:
leal(op->in_opr(), op->result_opr());
break;
case lir_null_check:
if (GenerateCompilerNullChecks) {
add_debug_info_for_null_check_here(op->info());
if (op->in_opr()->is_single_cpu()) {
_masm->null_check(op->in_opr()->as_register());
} else {
Unimplemented();
}
}
break;
case lir_monaddr:
monitor_address(op->in_opr()->as_constant_ptr()->as_jint(), op->result_opr());
break;
#ifdef SPARC
case lir_pack64:
pack64(op->in_opr(), op->result_opr());
break;
case lir_unpack64:
unpack64(op->in_opr(), op->result_opr());
break;
#endif
case lir_unwind:
unwind_op(op->in_opr());
break;
default:
Unimplemented();
break;
}
}
/* Pack state and configuration parameters into a buffer */
extern void bb_pack_state(bb_state_t *state_ptr, Buf buffer,
uint16_t protocol_version)
{
bb_config_t *config_ptr = &state_ptr->bb_config;
int i;
if (protocol_version >= SLURM_18_08_PROTOCOL_VERSION) {
packstr(config_ptr->allow_users_str, buffer);
packstr(config_ptr->create_buffer, buffer);
packstr(config_ptr->default_pool, buffer);
packstr(config_ptr->deny_users_str, buffer);
packstr(config_ptr->destroy_buffer, buffer);
pack32(config_ptr->flags, buffer);
packstr(config_ptr->get_sys_state, buffer);
packstr(config_ptr->get_sys_status, buffer);
pack64(config_ptr->granularity, buffer);
pack32(config_ptr->pool_cnt, buffer);
for (i = 0; i < config_ptr->pool_cnt; i++) {
packstr(config_ptr->pool_ptr[i].name, buffer);
pack64(config_ptr->pool_ptr[i].total_space, buffer);
pack64(config_ptr->pool_ptr[i].granularity, buffer);
pack64(config_ptr->pool_ptr[i].unfree_space, buffer);
pack64(config_ptr->pool_ptr[i].used_space, buffer);
}
pack32(config_ptr->other_timeout, buffer);
packstr(config_ptr->start_stage_in, buffer);
packstr(config_ptr->start_stage_out, buffer);
packstr(config_ptr->stop_stage_in, buffer);
packstr(config_ptr->stop_stage_out, buffer);
pack32(config_ptr->stage_in_timeout, buffer);
pack32(config_ptr->stage_out_timeout,buffer);
pack64(state_ptr->total_space, buffer);
pack64(state_ptr->unfree_space, buffer);
pack64(state_ptr->used_space, buffer);
pack32(config_ptr->validate_timeout, buffer);
} else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
packstr(config_ptr->allow_users_str, buffer);
packstr(config_ptr->create_buffer, buffer);
packstr(config_ptr->default_pool, buffer);
packstr(config_ptr->deny_users_str, buffer);
packstr(config_ptr->destroy_buffer, buffer);
pack32(config_ptr->flags, buffer);
packstr(config_ptr->get_sys_state, buffer);
pack64(config_ptr->granularity, buffer);
pack32(config_ptr->pool_cnt, buffer);
for (i = 0; i < config_ptr->pool_cnt; i++) {
packstr(config_ptr->pool_ptr[i].name, buffer);
pack64(config_ptr->pool_ptr[i].total_space, buffer);
pack64(config_ptr->pool_ptr[i].granularity, buffer);
pack64(config_ptr->pool_ptr[i].unfree_space, buffer);
pack64(config_ptr->pool_ptr[i].used_space, buffer);
}
pack32(config_ptr->other_timeout, buffer);
packstr(config_ptr->start_stage_in, buffer);
packstr(config_ptr->start_stage_out, buffer);
packstr(config_ptr->stop_stage_in, buffer);
packstr(config_ptr->stop_stage_out, buffer);
pack32(config_ptr->stage_in_timeout, buffer);
pack32(config_ptr->stage_out_timeout,buffer);
pack64(state_ptr->total_space, buffer);
pack64(state_ptr->unfree_space, buffer);
pack64(state_ptr->used_space, buffer);
pack32(config_ptr->validate_timeout, buffer);
}
}
int main (int argc, char *argv[])
{
Buf buffer;
uint16_t test16 = 1234, out16;
uint32_t test32 = 5678, out32, byte_cnt;
char testbytes[] = "TEST BYTES", *outbytes;
char teststring[] = "TEST STRING", *outstring = NULL;
char *nullstr = NULL;
char *data;
int data_size;
long double test_double = 1340664754944.2132312, test_double2;
uint64_t test64;
buffer = init_buf (0);
pack16(test16, buffer);
pack32(test32, buffer);
pack64((uint64_t)test_double, buffer);
packstr(testbytes, buffer);
packstr(teststring, buffer);
packstr(nullstr, buffer);
packstr("literal", buffer);
packstr("", buffer);
data_size = get_buf_offset(buffer);
printf("wrote %d bytes\n", data_size);
/* Pull data off old buffer, destroy it, and create a new one */
data = xfer_buf_data(buffer);
buffer = create_buf(data, data_size);
unpack16(&out16, buffer);
TEST(out16 != test16, "un/pack16");
unpack32(&out32, buffer);
TEST(out32 != test32, "un/pack32");
unpack64(&test64, buffer);
test_double2 = (long double)test64;
TEST((uint64_t)test_double2 != (uint64_t)test_double, "un/pack double as a uint64");
/* info("Original\t %Lf", test_double); */
/* info("uint64\t %ld", test64); */
/* info("converted LD\t %Lf", test_double2); */
unpackstr_ptr(&outbytes, &byte_cnt, buffer);
TEST( ( strcmp(testbytes, outbytes) != 0 ) , "un/packstr_ptr");
unpackstr_xmalloc(&outstring, &byte_cnt, buffer);
TEST(strcmp(teststring, outstring) != 0, "un/packstr_xmalloc");
xfree(outstring);
unpackstr_xmalloc(&nullstr, &byte_cnt, buffer);
TEST(nullstr != NULL, "un/packstr of null string.");
unpackstr_xmalloc(&outstring, &byte_cnt, buffer);
TEST(strcmp("literal", outstring) != 0,
"un/packstr of string literal");
xfree(outstring);
unpackstr_xmalloc(&outstring, &byte_cnt, buffer);
TEST(strcmp("", outstring) != 0, "un/packstr of string \"\" ");
xfree(outstring);
free_buf(buffer);
totals();
return failed;
}
