def display_job_obj (clock, job):
print "[Comm.Lib] %d ----------------------------------------" % clock
print "[Comm.Lib] %d Display Job Obj" % clock
print "[Comm.Lib] %d ----------------------------------------" % clock
print "[Comm.Lib] %d Job ID = %d" % (clock, job.id)
print "[Comm.Lib] %d Job Name = %s" % (clock, job.name)
print "[Comm.Lib] %d Job Standard Duration = %d" % (clock, job.std_duration)
print "[Comm.Lib] %d Job Deadline = %d" % (clock, job.deadline)
print "[Comm.Lib] %d Job Status = %s" % (clock, simgval.get_sim_code_str(job.status))
print "[Comm.Lib] %d Job Time Create = %s" % (clock, str(job.time_create))
print "[Comm.Lib] %d Job Time Assign = %s" % (clock, str(job.time_assign))
print "[Comm.Lib] %d Job Time Start = %s" % (clock, str(job.time_start))
print "[Comm.Lib] %d Job Time Complete = %s" % (clock, str(job.time_complete))
print "[Comm.Lib] %d Job VM ID = %s" % (clock, str(job.VM_id))
print "[Comm.Lib] %d Job VM Type = %s" % (clock, str(job.VM_type))
print "[Comm.Lib] %d Job Actual Duration on VM = %s" % (clock, str(job.act_duration_on_VM))
print "[Comm.Lib] %d Job Actual CPU Time on VM = %s" % (clock, str(job.act_cputime_on_VM))
print "[Comm.Lib] %d Job Actual Network Time on VM = %s" % (clock, str(job.act_nettime_on_VM))
print "[Comm.Lib] %d Job Use Input File = %s" % (clock, str(job.use_input_file))
print "[Comm.Lib] %d Job Input File Flow Direction = %s" % (clock, simgval.get_sim_code_str(job.input_file_flow_direction))
print "[Comm.Lib] %d Job Input File Size = %s KB (%s MB, %s GB, %s TB)" \
% (clock, str(job.input_file_size), str(job.input_file_size/1024.0), str(job.input_file_size/(1024.0*1024)), str(round(job.input_file_size/(1024.0*1024*1024), 5)))
print "[Comm.Lib] %d Job Use Output File = %s" % (clock, str(job.use_output_file))
print "[Comm.Lib] %d Job Output File Flow Direction= %s" % (clock, simgval.get_sim_code_str(job.output_file_flow_direction))
print "[Comm.Lib] %d Job Output File Size = %s KB (%s MB, %s GB, %s TB)" \
% (clock, str(job.output_file_size), str(job.output_file_size/1024.0), str(job.output_file_size/(1024.0*1024)), str(round(job.output_file_size/(1024.0*1024*1024), 5)))
print "[Comm.Lib] %d Job Output File Trans Status = %s" % (clock, simgval.get_sim_code_str(job.output_file_transfer_status))
print "[Comm.Lib] %d Job Output File Trans Size = %s KB (%s MB, %s GB, %s TB)" \
% (clock, str(job.output_file_transfer_size), str(job.output_file_transfer_size/1024.0), str(job.output_file_transfer_size/(1024.0*1024)), str(round(job.output_file_transfer_size/(1024.0*1024*1024), 5)))
print "[Comm.Lib] %d Standard Job Failure Time = %s" % (clock, str(job.std_job_failure_time))
print "[Comm.Lib] %d VM Job Failure Time = %s" % (clock, str(job.vm_job_failure_time))
print "[Comm.Lib] %d Job Failure Recovered = %s" % (clock, str(job.job_failure_recovered))
print "[Comm.Lib] %d ----------------------------------------" % clock
def make_queue_event (evt_clock, evt_src, evt_dst, evt_code, evt_sub_code, evt_data):
q_event = []
evt_id = get_event_id ()
q_event.append(evt_id)
q_event.append(evt_clock)
q_event.append(evt_src)
q_event.append(evt_dst)
q_event.append(evt_code)
q_event.append(evt_sub_code)
q_event.append(evt_data) # can be None
curframe = inspect.currentframe()
calframe = inspect.getouterframes(curframe, 2)
g_cv.acquire()
g_msg_logger.info (str(evt_clock) + "\tcreate make_queue_event")
g_msg_logger.info (str(evt_clock) + "\tCaller : %s, %s:%d" % (calframe[1][3], calframe[1][1], calframe[1][2]))
g_msg_logger.info (str(evt_clock) + "\tEVT ID : %d" % (evt_id))
g_msg_logger.info (str(evt_clock) + "\tEVT CLK : %d" % (evt_clock))
g_msg_logger.info (str(evt_clock) + "\tEVT SRC : %s" % (simgval.get_sim_code_str(evt_src)))
g_msg_logger.info (str(evt_clock) + "\tEVT DST : %s" % (simgval.get_sim_code_str(evt_dst)))
g_msg_logger.info (str(evt_clock) + "\tEVT CODE : %s" % (simgval.get_sim_code_str(evt_code)))
g_msg_logger.info (str(evt_clock) + "\tEVT SUBC : %s" % (simgval.get_sim_code_str(evt_sub_code)))
g_msg_logger.info (str(evt_clock) + "\tEVT DATA : %s" % (evt_data))
g_msg_logger.info ("")
g_cv.notify()
g_cv.release()
#print 'caller name:', calframe[1][3], "Event ID:", evt_id
return q_event
def SEH_event_processing(q_msg):
evt_src = q_msg[2] # EVT_SRC
evt_code = q_msg[4] # EVT_CODE
evt_sub_code = q_msg[5] # EVT_SUB_CODE
evt_data = q_msg[6] # EVT_DATA
print "\n\n"
g_log_handler.info("[SimEvent] %s EVT_RECV : EC:%s, ESC:%s, SRC_BLOCK:%s, data:%s" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), simgval.get_sim_code_str(evt_sub_code), simgval.get_sim_code_str(evt_src), evt_data))
print_bar()
ret_vals = [False, None]
if evt_code == simgval.gEVT_SET_CLOCK:
# SET CLOCK Event Processing
# ret_val is related to increase sim clock
ret_vals = SEH_evt_set_clock_processing(q_msg)
elif evt_code == simgval.gEVT_SET_TIMER:
# SET TIMER Event Processing
SEH_evt_set_timer_processing(q_msg)
elif evt_code == simgval.gEVT_ACK:
# EVT ACK PROCESSING
ret_vals = SEH_evt_ack_processing(q_msg)
elif evt_code == simgval.gEVT_BYPASS:
# EVT BYPASS PROCESSING
SEH_evt_bypass_processing(q_msg)
elif evt_code == simgval.gEVT_NOTI_SIMENTIY_TERMINATED:
# SIM ENTITY TERMINATION NOTIFICATION
SEH_evt_noti_simentity_terminated(q_msg)
elif evt_code == simgval.gEVT_ASK_SIMENTITY_TERMINATION:
# CHECK SIM ENTITY CAN BE TERMINATED
SEH_evt_ask_simentity_termination(q_msg)
elif evt_code == simgval.gEVT_REQ_CLEAR_SD_TMR_EVENT:
# CHECK SIM ENTITY CAN BE TERMINATED
SEH_evt_clear_sd_tmr_event(q_msg)
else:
g_log_handler.error("[SimEvent] %s EVT_CODE (%s) Error! => %s" %
(str(Global_Curr_Sim_Clock),
simgval.get_sim_code_str(evt_code), q_msg))
clib.sim_exit()
return ret_vals
def get_infos(self):
return "Storage Container <ID:" + str(self.sc_id) + ", CU:Job-" + str(
self.sc_creator
) + ", PR:$" + str(self.sc_usage_price) + ", SZ:" + str(
self.sc_usage_volume / 1024.0) + "MB, PM:" + str(
simgval.get_sim_code_str(self.sc_permission)) + ", ST:" + str(
simgval.get_sim_code_str(self.sc_status)) + ", CT:" + str(
self.sc_create_time) + ", NSFO:" + str(
len(self.sc_file_objects)) + ">"
def display_vm_obj (clock, vm):
print "[Comm.Lib] %d -----------------------------------" % clock
print "[Comm.Lib] %d Display VM Obj" % clock
print "[Comm.Lib] %d -----------------------------------" % clock
print "[Comm.Lib] %d VM ID = %d" % (clock, vm.id)
print "[Comm.Lib] %d VM Instance ID = %s" % (clock, vm.instance_id)
print "[Comm.Lib] %d VM Type Name = %s" % (clock, vm.type_name)
print "[Comm.Lib] %d VM Unit Price = %s" % (clock, vm.unit_price)
print "[Comm.Lib] %d VM Status = %s" % (clock, simgval.get_sim_code_str(vm.status))
print "[Comm.Lib] %d VM Time Create = %s" % (clock, str(vm.time_create))
print "[Comm.Lib] %d VM Time Active = %s" % (clock, str(vm.time_active))
print "[Comm.Lib] %d VM Time Terminate = %s" % (clock, str(vm.time_terminate))
print "[Comm.Lib] %d VM Cost = %f" % (clock, vm.cost)
print "[Comm.Lib] %d VM startup_lag = %d" % (clock, vm.startup_lag)
print "[Comm.Lib] %d -----------------------------------" % clock
if vm.current_job is not None:
print "[Comm.Lib] %d Current Job = (ID:%d, NM:%s, ADR:%d (CPU:%s, NET:%s), DL:%d, SDR:%d, TC:%d, ST:%s)" \
% (clock, vm.current_job.id, vm.current_job.name, vm.current_job.act_duration_on_VM, vm.current_job.act_cputime_on_VM, vm.current_job.act_nettime_on_VM, vm.current_job.deadline, vm.current_job.std_duration, vm.current_job.time_create, simgval.get_sim_code_str(vm.current_job.status))
else:
print "[Comm.Lib] %d Current Job = %s" % (clock, vm.current_job)
print "[Comm.Lib] %d VM Curr Job Start Clock = %s" % (clock, vm.current_job_start_clock)
print "[Comm.Lib] %d VM Last Job Compl Clock = %s" % (clock, vm.last_job_complete_clock)
if len(vm.job_queue) < 1:
print "[Comm.Lib] %d Job Queue = None" % (clock)
else:
sys.stdout.write ("[Comm.Lib] %d Job Queue = [" % clock)
for job in vm.job_queue:
sys.stdout.write ("(ID:%d, NM:%s, ADR:%s (CPU:%s, I/O:%s), DL%d, SDR:%d, TC:%d)," % (job.id, job.name, job.act_duration_on_VM, job.act_cputime_on_VM, job.act_nettime_on_VM, job.deadline, job.std_duration, job.time_create))
sys.stdout.write ("]\n")
if len(vm.job_history) < 1:
print "[Comm.Lib] %d Job History = None" % (clock)
else:
sys.stdout.write ("[Comm.Lib] %d Job History = [" % clock)
for job in vm.job_history:
sys.stdout.write ("(ID:%d, NM:%s, ADR:%s (CPU:%s, I/O:%s), DL:%d, SDR:%d, TC:%d, ST:%s),"
% (job.id, job.name, job.act_duration_on_VM, job.act_cputime_on_VM, job.act_nettime_on_VM, job.deadline, job.std_duration, job.time_create, simgval.get_sim_code_str(job.status)))
sys.stdout.write ("]\n")
print "[Comm.Lib] %d VM SD Policy Activated = %s" % (clock, vm.sd_policy_activated)
print "[Comm.Lib] %d VM SD Wait Time = %d" % (clock, vm.sd_wait_time)
print "[Comm.Lib] %d VM IS VScale Victim??? = %s" % (clock, vm.is_vscale_victim)
print "[Comm.Lib] %d VM VScale Case = %s" % (clock, simgval.get_sim_code_str(vm.vscale_case))
print "[Comm.Lib] %d VM VScale Victim ID = %d" % (clock, vm.vscale_victim_id)
print "[Comm.Lib] %d -----------------------------------" % clock
def sim_clock_event_processing(q_msg):
ret_val = False
evt_code = q_msg[4]
if evt_code == simgval.gEVT_SIM_START:
# processing simulation start event
sim_clock_evt_sim_start_processing(q_msg)
elif evt_code == simgval.gEVT_SIM_END:
# processing simulation end event
sim_clock_evt_sim_end_processing(q_msg)
ret_val = True
elif evt_code == simgval.gEVT_SET_CLOCK_ACK:
# clock ack (from event handler) processing
sim_clock_evt_set_clock_ack_processing(q_msg)
else:
g_log_handler.error("[SimClock] %s EVT_CODE (%s) Error! => %s" %
(str(Global_Wall_Clock),
simgval.get_sim_code_str(evt_code), q_msg))
clib.sim_exit()
return ret_val
def SEH_evt_set_timer_processing(q_msg):
evt_code = q_msg[4] # EVT_CODE
if evt_code != simgval.gEVT_SET_TIMER:
g_log_handler.error("[SimEvent] %s SEH_evt_set_timer_processing EVT_CODE (%s) Error! => %s" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), q_msg))
clib.sim_exit()
evt_clock = q_msg[1] # EVT_CLOCK
evt_src = q_msg[2] # EVT_SRC
evt_sub_code = q_msg[5] # EVT_SUB_CODE
evt_data = q_msg[6] # EVT_DATA
# Regist Timer Event
# [DEST_BLOCK, EVT_SUB_CODE, EVT_DATA[]]
# [simgval.gBLOCK_WORKLOAD_GEN, "EVT_WAKEUP", None]
timer_evt = []
timer_evt.append(evt_clock)
timer_evt_obj = []
timer_evt_obj.append(evt_src)
timer_evt_obj.append(evt_sub_code)
timer_evt_obj.append(evt_data)
timer_evt.append(timer_evt_obj)
insert_Timer_Events(timer_evt)
g_log_handler.info("[SimEvent] %s RECV EVT_SET_TIMER => %s" %
(str(Global_Curr_Sim_Clock), str(q_msg)))
g_log_handler.info("[SimEvent] %s INSERT Timer Event => %s" %
(str(Global_Curr_Sim_Clock), str(Timer_Events)))
def sim_clock_evt_set_clock_ack_processing(q_msg):
evt_clock = q_msg[1]
evt_code = q_msg[4]
evt_sub_code = q_msg[5]
evt_data = q_msg[6]
if evt_code != simgval.gEVT_SET_CLOCK_ACK:
g_log_handler.error(
"[SimClock] %s sim_clock_evt_sim_ack_processing EVT_CODE (%s) Error! => %s"
% (str(Global_Wall_Clock), simgval.get_sim_code_str(evt_code),
q_msg))
clib.sim_exit()
if Global_Wall_Clock == (evt_clock):
#time.sleep(1)
print "[SimClock] Simulation Clock OK: SIM_TIMER:%ds, SIM_EVENT_HANDLER:%ds" % (
Global_Wall_Clock, evt_clock)
# increase wall clock
tick = evt_sub_code
increase_Wall_Clock(tick)
q_evt = clib.make_queue_event(Global_Wall_Clock, g_my_block_id,
simgval.gBLOCK_SIM_EVENT_HANDLER,
simgval.gEVT_SET_CLOCK, tick, None)
gQ_OUT.put(q_evt)
else:
g_log_handler.error("[SimClock] Simulation Clock Mismatch: SIM_TIMER:%ds, SIM_EVENT_HANDLER:%ds" \
% (Global_Wall_Clock, evt_clock))
clib.sim_exit()
def terminate_sim_entity_workloadgen (q_msg):
evt_id = q_msg[0] # EVT_ID
evt_code = q_msg[4] # EVT_CODE
evt_sub_code = q_msg[5] # EVT_SUB_CODE
if evt_code != simgval.gEVT_EXP_TIMER or evt_sub_code != simgval.gEVT_SUB_WORKGEN_TERMINATE:
g_log_handler.error("[Work_Gen] %s EVT_CODE (%s)/EVT_SUB_CODE (%s) Error! => %s" \
%(str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), simgval.get_sim_code_str(evt_sub_code), q_msg))
clib.sim_exit()
# [a] ack send first
workgen_send_evt_ack (evt_id, evt_code)
# [b] send gEVT_NOTI_SIMENTIY_TERMINATED (common event code) to event handler
term_evt = clib.make_queue_event (Global_Curr_Sim_Clock, g_my_block_id, simgval.gBLOCK_SIM_EVENT_HANDLER, simgval.gEVT_NOTI_SIMENTIY_TERMINATED, None, None)
gQ_OUT.put (term_evt)
def display_storage_container_infos(self, clock):
print ""
print "[Comm.Lib] %d ======================================================================" % clock
print "[Comm.Lib] %d Display Storage Container Obj Infos." % clock
print "[Comm.Lib] %d ======================================================================" % clock
print "[Comm.Lib] %d SC UID : %s" % (clock,
self.sc_id)
print "[Comm.Lib] %d SC Creator : Job-%s" % (
clock, self.sc_creator)
print "[Comm.Lib] %d SC Terminator : %s" % (
clock, self.sc_terminator)
print "[Comm.Lib] %d SC Region : %s" % (clock,
self.sc_region)
print "[Comm.Lib] %d SC Permission : %s" % (
clock, simgval.get_sim_code_str(self.sc_permission))
print "[Comm.Lib] %d SC Status : %s" % (
clock, simgval.get_sim_code_str(self.sc_status))
print "[Comm.Lib] %d SC Create Time : %s" % (
clock, self.sc_create_time)
print "[Comm.Lib] %d SC Delete Time : %s" % (
clock, self.sc_delete_time)
print "[Comm.Lib] %d SC Usage Price : $%s" % (
clock, self.sc_usage_price)
print "[Comm.Lib] %d SC Usage Volume : %s KB (%s MB, %s GB, %s TB)" % (
clock, self.sc_usage_volume, self.sc_usage_volume / 1024.0,
self.sc_usage_volume / (1024.0 * 1024), self.sc_usage_volume /
(1024.0 * 1024 * 1024))
print "[Comm.Lib] %d SC Num of File Objects : %s SFOs" % (
clock, len(self.sc_file_objects))
if len(self.sc_file_objects) > 0:
print "[Comm.Lib] %d ----------------------------------------------------------------------" % clock
total_sfo_file_size = 0
for sfo in self.sc_file_objects:
print "[Comm.Lib] %d SC File Objects [%05d] : %s" % (
clock, sfo.sfo_id, sfo.get_infos())
total_sfo_file_size += sfo.sfo_size
print "[Comm.Lib] %d SFO Total File Size : %s KB (%s MB, %s GB, %s TB)" % (
clock, total_sfo_file_size, total_sfo_file_size / 1024.0,
total_sfo_file_size / (1024.0 * 1024), self.sc_usage_volume /
(1024.0 * 1024 * 1024))
print "[Comm.Lib] %d ======================================================================" % clock
def get_job_info_str(job):
if job is None:
return "Job-" + str(None)
else:
job_info_str = "%s (ID:%s, ADR:%s [C:%s,I:%s/%s], ST:%s, SDR:%s)" % (
job.name, job.id, job.act_duration_on_VM, job.act_cputime_on_VM,
job.act_nettime_on_VM[0], job.act_nettime_on_VM[1],
simgval.get_sim_code_str(job.status), job.std_duration)
return job_info_str
def display_Timer_Events_List():
print "[SimEvent] %s Display Timer Event List " % (
str(Global_Curr_Sim_Clock))
print "[SimEvent] %s ================================================================" % (
str(Global_Curr_Sim_Clock))
for seq, te in enumerate(Timer_Events):
tmr = te[0]
s_blk = simgval.get_sim_code_str(te[1][0])
s_ec = simgval.get_sim_code_str(te[1][1])
s_ed = str(te[1][2])
print "[SimEvent] %s [%d] Tmr: %d, BLK: %s, EC: %s, ED: %s" \
% (str(Global_Curr_Sim_Clock), seq, tmr, s_blk, s_ec, s_ed)
print "[SimEvent] %s ================================================================" % (
str(Global_Curr_Sim_Clock))
def sim_clock_evt_sim_end_processing(q_msg):
evt_code = q_msg[4]
if evt_code != simgval.gEVT_SIM_END:
g_log_handler.error(
"[SimClock] %s sim_clock_evt_sim_end_processing EVT_CODE (%s) Error! => %s"
% (str(Global_Wall_Clock), simgval.get_sim_code_str(evt_code),
q_msg))
clib.sim_exit()
g_log_handler.info(
"[SimClock] %s EVT_RECV: %s" %
(str(Global_Wall_Clock), simgval.get_sim_code_str(evt_code)))
# simulation complete event
sim_end_evt = clib.make_queue_event(Global_Wall_Clock, g_my_block_id,
simgval.gBLOCK_SIM_EVENT_HANDLER,
simgval.gEVT_SIM_END, None, None)
gQ_OUT.put(sim_end_evt)
def logwrite_VM_Instance_Lists (log, header, title, vms):
log.info(str(header) + ' ==============================================================')
log.info(str(header) + ' Display %s' % title)
log.info(str(header) + ' ==============================================================')
seq = 0
for vm in vms:
log.info(str(header) + ' [%d] ID:%d, IID:%s, TY:%s, PR:$%s, ST:%s, TC:%s TA:%s TT:%s C$:%f, SL:%d, CJ:%s, NJ:%d, JH:%d'
%(seq, vm.id, vm.instance_id, vm.type_name, vm.unit_price, simgval.get_sim_code_str(vm.status),
str(vm.time_create), str(vm.time_active), str(vm.time_terminate),
vm.cost, vm.startup_lag, str(vm.current_job), len(vm.job_queue), len(vm.job_history)))
seq += 1
log.info(str(header) + ' ==============================================================')
def SEH_evt_noti_simentity_terminated(q_msg):
evt_src = q_msg[2] # EVT_SRC
evt_code = q_msg[4] # EVT_CODE
if evt_code != simgval.gEVT_NOTI_SIMENTIY_TERMINATED:
g_log_handler.error("[SimEvent] %s EVT_CODE (%s) Error! => %s" %
(str(Global_Curr_Sim_Clock),
simgval.get_sim_code_str(evt_code), q_msg))
clib.sim_exit()
remaining_events_exist = find_Timer_Event_by_block(evt_src)
if remaining_events_exist is True:
g_log_handler.error("[SimEvent] %s EVT_CODE (%s) Processing Error! => Timer Events for %s Exist!" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), simgval.get_sim_code_str(evt_src)))
clib.sim_exit()
set_sim_entity_running_state(evt_src, False)
print "[SimEvent] %s EVT_CODE (%s) Processing => %s" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), str(g_Sim_Entity_Running_States[simgval.gBLOCK_SIM_ENTITY_START+1:]))
# [condition 1] if all sim entities are false (stopped), send termination noti event to sim_clock
all_entities_terminated = all(
state is False for state in
g_Sim_Entity_Running_States[simgval.gBLOCK_SIM_ENTITY_START + 1:])
# [condition 2] no timer events
no_of_tmr_evts = get_number_of_imp_Timer_Events()
if all_entities_terminated is True and no_of_tmr_evts < 1:
# Set Termination Flag
set_SEH_sim_entity_term_flag(True)
# simulation complete event
sim_end_evt = clib.make_queue_event(Global_Curr_Sim_Clock,
g_my_block_id,
simgval.gBLOCK_SIM_CLOCK,
simgval.gEVT_SIM_END, None, None)
gQ_CLOCK.put(sim_end_evt)
def SEH_evt_bypass_processing(q_msg):
evt_src = q_msg[2] # EVT_SRC
evt_code = q_msg[4] # EVT_CODE
evt_sub_code = q_msg[5] # EVT_SUB_CODE
evt_data = q_msg[6] # EVT_DATA
if evt_code != simgval.gEVT_BYPASS:
g_log_handler.error(
"[SimEvent] %s SEH_evt_bypass_processing EVT_CODE (%s) Error! => %s"
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code),
q_msg))
clib.sim_exit()
print "[SimEvent] %s IN Sentout_Timer_Event_IDs=>" % str(
Global_Curr_Sim_Clock), Sentout_Timer_Event_IDs
so_evt_dst_block = evt_sub_code
so_evt_code = evt_data.pop(0) # EVT_DATA[0] -- Actual Event Code.
so_evt_sub_code = evt_src
so_evt_data = evt_data
q_evt_so = clib.make_queue_event(Global_Curr_Sim_Clock, g_my_block_id,
so_evt_dst_block, so_evt_code,
so_evt_sub_code, so_evt_data)
r = send_EVT_to_Block(evt_code, so_evt_dst_block, q_evt_so)
if r is False:
g_log_handler.error(
"[SimEvent] %s EVT_BYPASS DST BLOCK (%s) ERROR!!!" %
(str(Global_Curr_Sim_Clock),
simgval.get_sim_code_str(so_evt_dst_block)))
clib.sim_exit()
print "[SimEvent] %s 1 BYPASS_EVT:%s sent out" % (
str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(so_evt_code))
print "[SimEvent] %s Out Sentout_Timer_Event_IDs=>" % str(
Global_Curr_Sim_Clock), Sentout_Timer_Event_IDs
def set_Job_output_file_transfer_infos(job, transfer_status, transfer_size):
if transfer_status == simgval.gSFO_DST_FULL_UPLOAD:
if transfer_size != job.output_file_size:
print "[DEBUG JOB OBJ] Output File Size (%s KB) and Transfer Size (%s KB) Mismatch! - transfer_status:%s" \
% (job.output_file_size, transfer_size, simgval.get_sim_code_str(transfer_status))
clib.sim_exit()
elif transfer_status == simgval.gSFO_DST_PARTIAL_UPLOAD:
if transfer_status >= job.output_file_size:
print "[DEBUG JOB OBJ] Transfer Size (%s KB) should be smaller than Output File Size (%s KB) transfer_status:%s" \
% (transfer_size, job.output_file_size, simgval.get_sim_code_str(transfer_status))
clib.sim_exit()
else:
print "[DEBUG JOB OBJ] transfer_status Error! - %s" % (
simgval.get_sim_code_str(transfer_status))
clib.sim_exit()
g_Job_Obj_CV.acquire()
job.output_file_transfer_status = transfer_status
job.output_file_transfer_size = transfer_size
g_Job_Obj_CV.notify()
g_Job_Obj_CV.release()
def display_VM_Instances_List (clock, title, vms):
print ""
print "[Comm.Lib] %d ==============================================================" % clock
print "[Comm.Lib] %d Display %s" % (clock, title)
print "[Comm.Lib] %d ==============================================================" % clock
seq = 0
for vm in vms:
print "[Comm.Lib] %d [%d] ID:%d, IID:%s, TY:%s, PR:$%sST:%s, TC:%s TA:%s TT:%s C$:%f, SL:%d, CJ:%s, NJ:%d, JH:%d" \
% (clock, seq,
vm.id, vm.instance_id, vm.type_name, vm.unit_price, simgval.get_sim_code_str(vm.status),
str(vm.time_create), str(vm.time_active), str(vm.time_terminate),
vm.cost, vm.startup_lag, str(vm.current_job) if vm.current_job is None else 'JID: ' + str(vm.current_job.id), len(vm.job_queue), len(vm.job_history))
seq += 1
print "[Comm.Lib] %d ==============================================================" % clock
def sim_clock_evt_sim_start_processing(q_msg):
evt_code = q_msg[4]
if evt_code != simgval.gEVT_SIM_START:
g_log_handler.error(
"[SimClock] %s sim_clock_evt_sim_start_processing EVT_CODE (%s) Error! => %s"
% (str(Global_Wall_Clock), simgval.get_sim_code_str(evt_code),
q_msg))
clib.sim_exit()
g_log_handler.info("[SimClock] %s Simulation Start..." %
(Global_Wall_Clock))
# send msg to sim_evt_handler ==> Wake up event for simulation event handler
q_evt = clib.make_queue_event(Global_Wall_Clock, g_my_block_id,
simgval.gBLOCK_SIM_EVENT_HANDLER,
simgval.gEVT_SET_CLOCK, None, None)
gQ_OUT.put(q_evt)
def SEH_evt_ack_processing(q_msg):
evt_id = q_msg[0] # EVT_ID
evt_code = q_msg[4] # EVT_CODE
return_vals = [False, None]
if evt_code != simgval.gEVT_ACK:
g_log_handler.error(
"[SimEvent] %s SEH_evt_ack_processing EVT_CODE (%s) Error! => %s" %
(str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code),
q_msg))
clib.sim_exit()
print "[SimEvent] %s RECV EVT_ACK => %s" % (str(Global_Curr_Sim_Clock),
str(q_msg))
print "[SimEvent] %s IN Sentout_Timer_Event_IDs => %s" % (
str(Global_Curr_Sim_Clock), str(Sentout_Timer_Event_IDs))
print evt_id
r = remove_Sentout_Timer_Event_IDs(evt_id)
if r is False:
clib.sim_exit()
print "[SimEvent] %s remove_Sentout_Timer_Event_IDs [%d]" % (
str(Global_Curr_Sim_Clock), evt_id)
print "[SimEvent] %s OUT Sentout_Timer_Event_IDs => %s" % (
str(Global_Curr_Sim_Clock), str(Sentout_Timer_Event_IDs))
no_so_evt = get_count_Sentout_Timer_Event_IDs()
if no_so_evt == 0:
return_vals = [True, 1]
print "[SimEvent] %s No Sentout_Timer_Event_IDs => Activate Sim_Clock" % (
str(Global_Curr_Sim_Clock))
'''
print "\n\n[SimEvent] SEH_evt_ack_processing = Timer Event =>"
for e in Timer_Events:
print e
clib.sim_long_sleep()
clib.sim_long_sleep()
# activate timer thread
'''
return return_vals
def display_conf_obj (clock, conf_obj):
print ""
print "[Comm.Lib] %d ======================================================================" % clock
print "[Comm.Lib] %d Display Simulation Config Obj." % clock
print "[Comm.Lib] %d ======================================================================" % clock
print "[Comm.Lib] %d Config ID : %d" % (clock, conf_obj.id)
print "[Comm.Lib] %d Simulation Trace Int : %d" % (clock, conf_obj.sim_trace_interval)
print "[Comm.Lib] %d Log Path : %s" % (clock, conf_obj.log_path)
print "[Comm.Lib] %d Report Path : %s" % (clock, conf_obj.report_path)
print "[Comm.Lib] %d Workload File : %s" % (clock, conf_obj.workload_file)
print "[Comm.Lib] %d Workload Type : %s" % (clock, simgval.get_sim_code_str(conf_obj.workload_type))
print "[Comm.Lib] %d Min Startup Lag : %s" % (clock, conf_obj.min_startup_lag)
print "[Comm.Lib] %d Max Startup Lag : %s" % (clock, conf_obj.max_startup_lag)
print "[Comm.Lib] %d Job Assign Policy : %s" % (clock, simgval.get_sim_code_str(conf_obj.job_assign_policy))
print "[Comm.Lib] %d Job Assign Max Running_VMs : %s" % (clock, conf_obj.job_assign_max_running_vms)
print "[Comm.Lib] %d Enable Vertical Scaling : %s" % (clock, conf_obj.enable_vertical_scaling)
print "[Comm.Lib] %d Vertical Scaling Operation : %s" % (clock, simgval.get_sim_code_str(conf_obj.vscale_operation))
print "[Comm.Lib] %d VM SD Policy : %s" % (clock, simgval.get_sim_code_str(conf_obj.vm_scale_down_policy))
print "[Comm.Lib] %d VM SD Policy Unit : %s" % (clock, conf_obj.vm_scale_down_policy_unit)
print "[Comm.Lib] %d VM SD Policy Rec Smp Cnt : %d" % (clock, conf_obj.vm_scale_down_policy_recent_sample_cnt)
print "[Comm.Lib] %d VM SD Policy Param1 : %s" % (clock, str(conf_obj.vm_scale_down_policy_param1))
print "[Comm.Lib] %d VM SD Policy Param2 : %s" % (clock, str(conf_obj.vm_scale_down_policy_param2))
print "[Comm.Lib] %d VM SD Policy Param3 : %s" % (clock, str(conf_obj.vm_scale_down_policy_param3))
print "[Comm.Lib] %d VM SD Policy Timer Clock : %s" % (clock, conf_obj.vm_scale_down_policy_timer_unit)
print "[Comm.Lib] %d VM SD Policy Min Wait Time : %d" % (clock, conf_obj.vm_scale_down_policy_min_wait_time)
print "[Comm.Lib] %d VM SD Policy Max Wait Time : %d" % (clock, conf_obj.vm_scale_down_policy_max_wait_time)
#print "[Comm.Lib] %d VM Unit Price : %s" % (clock, conf_obj.vm_unit_price)
print "[Comm.Lib] %d VM Billing Time Unit : %s" % (clock, simgval.get_sim_code_str(conf_obj.billing_time_unit))
print "[Comm.Lib] %d VM Billing Time Period : %s" % (clock, conf_obj.billing_time_period)
print "[Comm.Lib] %d VM Billing Unit Clock : %s" % (clock, conf_obj.billing_unit_clock)
print "[Comm.Lib] %d VM Selection Method : %s" % (clock, simgval.get_sim_code_str(conf_obj.vm_selection_method))
print "[Comm.Lib] %d VM Config File : %s" % (clock, conf_obj.vm_config_file_path)
print "[Comm.Lib] %d NO OF VM TYPES : %s" % (clock, conf_obj.no_of_vm_types)
print "[Comm.Lib] %d Registered VM Types Infos : %s" % (clock, conf_obj.get_vm_types_str())
print "[Comm.Lib] %d Max Capacity of Storage : %s KB (%s MB, %s GB, %s TB)" \
% (clock, conf_obj.max_capacity_of_storage*1024, conf_obj.max_capacity_of_storage, conf_obj.max_capacity_of_storage/1024.0, conf_obj.max_capacity_of_storage/(1024.0*1024))
print "[Comm.Lib] %d Max # of Storage Containers : %s" % (clock, conf_obj.max_num_of_storage_containers)
print "[Comm.Lib] %d Storage Unit Cost : $%s" % (clock, conf_obj.storage_unit_cost)
print "[Comm.Lib] %d Storage Billing Unit Clock : %s" % (clock, conf_obj.storage_billing_unit_clock)
print "[Comm.Lib] %d Performance of Data Transfer [INTER,IN,OUT] : %s (Unit MB/s)" % (clock, conf_obj.perf_data_transfer)
print "[Comm.Lib] %d Cost of Data Transfer [INTER,IN,OUT] : %s (Unit Dollars)" % (clock, conf_obj.cost_data_transfer)
print "[Comm.Lib] %d Probability of Job Failure : %s" % (clock, conf_obj.prob_job_failure)
print "[Comm.Lib] %d Job Failure Policy : %s" % (clock, simgval.get_sim_code_str(conf_obj.job_failure_policy))
print "[Comm.Lib] %d ======================================================================" % clock
def set_sim_entity_running_state(block_id, state):
global g_Sim_Entity_Running_States
if g_Sim_Entity_Running_States[block_id] != state:
g_Sim_Entity_Running_States_CV.acquire()
g_Sim_Entity_Running_States[block_id] = state
g_Sim_Entity_Running_States_CV.notify()
g_Sim_Entity_Running_States_CV.release()
print "[SimEvent] %s Set Sim Entity Running State:" % (
str(Global_Curr_Sim_Clock))
print "[SimEvent] %s %s state is changed to %s" % (
str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(block_id),
str(g_Sim_Entity_Running_States[block_id]))
else:
g_log_handler.error("[SimEvent] %s Set Sim Entity Running State Error! => Both Values are the same (OLD:%s, NEW:%s)!" \
% (str(Global_Curr_Sim_Clock), g_Sim_Entity_Running_States[block_id], state))
clib.sim_exit()
def logwrite_job_obj(self, clock, logger):
logger.info("")
logger.info("%d ----------------------------------------" % clock)
logger.info("%d Display Job Obj" % clock)
logger.info("%d ----------------------------------------" % clock)
logger.info("%d Job ID = %d" % (clock, self.id))
logger.info("%d Job Name = %s" %
(clock, self.name))
logger.info("%d Job Standard Duration = %d" %
(clock, self.std_duration))
logger.info("%d Job Deadline = %d" %
(clock, self.deadline))
logger.info("%d Job Status = %s" %
(clock, simgval.get_sim_code_str(self.status)))
logger.info("%d Job Time Create = %s" %
(clock, str(self.time_create)))
logger.info("%d Job Time Assign = %s" %
(clock, str(self.time_assign)))
logger.info("%d Job Time Start = %s" %
(clock, str(self.time_start)))
logger.info("%d Job Time Complete = %s" %
(clock, str(self.time_complete)))
logger.info("%d Job VM ID = %s" %
(clock, str(self.VM_id)))
logger.info("%d Job VM Type = %s" %
(clock, str(self.VM_type)))
logger.info("%d Job Actual Duration on VM = %s" %
(clock, str(self.act_duration_on_VM)))
logger.info("%d Job Actual CPU Time on VM = %s" %
(clock, str(self.act_cputime_on_VM)))
logger.info("%d Job Actual Network Time on VM = %s" %
(clock, str(self.act_nettime_on_VM)))
logger.info("%d Job Use Input File = %s" %
(clock, str(self.use_input_file)))
logger.info(
"%d Job Input File Flow Direction = %s" %
(clock, simgval.get_sim_code_str(self.input_file_flow_direction)))
logger.info(
"%d Job Input File Size = %s KB (%s MB, %s GB, %s TB)" %
(clock, str(
self.input_file_size), str(self.input_file_size / 1024.0),
str(self.input_file_size / (1024.0 * 1024)),
str(round(self.input_file_size / (1024.0 * 1024 * 1024), 5))))
logger.info("%d Job Use Output File = %s" %
(clock, str(self.use_output_file)))
logger.info(
"%d Job Output File Flow Direction= %s" %
(clock, simgval.get_sim_code_str(self.output_file_flow_direction)))
logger.info(
"%d Job Output File Size = %s KB (%s MB, %s GB, %s TB)" %
(clock, str(
self.output_file_size), str(self.output_file_size / 1024.0),
str(self.output_file_size / (1024.0 * 1024)),
str(round(self.output_file_size / (1024.0 * 1024 * 1024), 5))))
logger.info(
"%d Job Output File Trans Status = %s" %
(clock, simgval.get_sim_code_str(
self.output_file_transfer_status)))
logger.info(
"%d Job Output File Trans Size = %s KB (%s MB, %s GB, %s TB)" %
(clock, str(self.output_file_transfer_size),
str(self.output_file_transfer_size / 1024.0),
str(self.output_file_transfer_size / (1024.0 * 1024)),
str(
round(self.output_file_transfer_size /
(1024.0 * 1024 * 1024), 5))))
logger.info("%d Standard Job Failure Time = %s" %
(clock, str(self.std_job_failure_time)))
logger.info("%d VM Job Failure Time = %s" %
(clock, str(self.vm_job_failure_time)))
logger.info("%d Job Failure Recovered = %s" %
(clock, str(self.job_failure_recovered)))
logger.info("%d ----------------------------------------" % clock)
logger.info("")
def SEH_evt_clear_sd_tmr_event(q_msg):
evt_id = q_msg[0] # EVT_ID
evt_src = q_msg[2] # EVT_SRC
evt_code = q_msg[4] # EVT_CODE
evt_real_src = q_msg[5] # EVT_SUB_CODE
evt_data = q_msg[6] # EVT_DATA
if evt_code != simgval.gEVT_REQ_CLEAR_SD_TMR_EVENT:
g_log_handler.error("[SimEvent] %s EVT_CODE (%s) Error! => %s" %
(str(Global_Curr_Sim_Clock),
simgval.get_sim_code_str(evt_code), q_msg))
clib.sim_exit()
if evt_real_src != simgval.gBLOCK_BROKER:
g_log_handler.error("[SimEvent] %s EVT_CODE (%s) Error! - Invalid REAL SRC Block (%s) => %s" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), simgval.get_sim_code_str(evt_real_src), q_msg))
clib.sim_exit()
vm_obj = evt_data[0]
exception_flag = evt_data[1]
if vm_obj.sd_policy_activated != True:
g_log_handler.error("[SimEvent] %s EVT_CODE (%s) Error! - Invalid Access to Lib:SEH_evt_clear_sd_tmr_event => %s" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), q_msg))
clib.logwrite_vm_obj(g_log_handler,
"[SimEvent] " + str(Global_Curr_Sim_Clock),
vm_obj)
clib.sim_exit()
index, te = get_index_Timer_Event_by_Infos(simgval.gBLOCK_BROKER,
simgval.gEVT_SUB_VM_SCALE_DOWN,
vm_obj.id)
if index < 0 or te is None:
# this case hardly happens but it exists -- no just warning instead of terminating simulator - 10/27/2014
g_log_handler.error("[SimEvent] %s EVT_CODE (%s) Error! - Proper Timer Event for VM (ID:%d) Scale Down not found!!!" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), vm_obj.id))
else:
# proper event exists
te_blk = te[1][0]
te_ec = te[1][1]
te_data = te[1][2]
if te_blk != simgval.gBLOCK_BROKER or \
te_ec != simgval.gEVT_SUB_VM_SCALE_DOWN or \
te_data[0] != vm_obj.id or \
index < 0:
g_log_handler.error("[SimEvent] %s EVT_CODE (%s) Error! - Timer Event (IDX:%d, EC:%s) for VM(ID:%d) Scale Down Mismatch!" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code),
index, simgval.get_sim_code_str(te_ec),vm_obj.id))
clib.sim_exit()
remove_Timer_Event_by_Index(index)
g_log_handler.error("[SimEvent] %s EVT_CODE (%s) - Remove Timer Event (IDX:%d, EC:%s) for VM(ID:%d) Scale Down" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), index, simgval.get_sim_code_str(te_ec),vm_obj.id))
# send by pass to notify "request to clear sd event completed"
seh_dst_block_id = simgval.gBLOCK_BROKER
seh_evt_code = simgval.gEVT_SUCCESS_CLEAR_SD_TMR_EVENT
seh_evt_id_data = [vm_obj, exception_flag]
seh_evt = clib.make_queue_event(Global_Curr_Sim_Clock, g_my_block_id,
seh_dst_block_id, seh_evt_code, None,
seh_evt_id_data)
ret = send_EVT_to_Block(seh_evt_code, seh_dst_block_id, seh_evt)
# send ack
SEH_send_evt_ack(evt_id)
def logwrite_JobList (log, header, title, recv_jobs):
log.info(str(header) + ' ==============================================================')
log.info(str(header) + ' Display %s' % title)
log.info(str(header) + ' ==============================================================')
seq = 0
for recv_job in recv_jobs:
log.info(str(header) + ' [%d] ID:%d, NM:%s, SDR:%d, DL:%d, ST:%s, TC:%s TA:%s, TS:%s, TE:%s, VM:%d, VMTY:%s, ADR:%d (CPU:%s, IO:%s)'
%(seq, recv_job.id, recv_job.name, recv_job.std_duration, recv_job.deadline, simgval.get_sim_code_str(recv_job.status),
recv_job.time_create, recv_job.time_assign, recv_job.time_start, recv_job.time_complete,recv_job.VM_id, recv_job.VM_type, recv_job.act_duration_on_VM, recv_job.act_cputime_on_VM, recv_job.act_nettime_on_VM))
seq += 1
log.info(str(header) + ' ==============================================================')
def display_JobList (clock, title, recv_jobs):
print ""
print "[Comm.Lib] %d ===================================" % clock
print "[Comm.Lib] %d Display %s" % (clock, title)
print "[Comm.Lib] %d ===================================" % clock
seq = 0
for recv_job in recv_jobs:
print "[Comm.Lib] %d [%d] ID:%d, NM:%s, ADR:%s (CPU:%s, IO:%s), SDR:%d, DL:%d, ST:%s, TC:%s, TA:%s, TS:%s, TE:%s, VM:%d" \
% (clock, seq,
recv_job.id, recv_job.name, recv_job.act_duration_on_VM, recv_job.act_cputime_on_VM, recv_job.act_nettime_on_VM, recv_job.std_duration, recv_job.deadline, simgval.get_sim_code_str(recv_job.status),
recv_job.time_create, recv_job.time_assign, recv_job.time_start, recv_job.time_complete,recv_job.VM_id)
seq += 1
print "[Comm.Lib] %d ===================================" % clock
def logwrite_vm_obj (log_handler, header, vm):
log_handler.info (str(header) + " Display VM Object" )
log_handler.info (str(header) + " ================================================================")
log_handler.info (str(header) + " VM ID = %d" % (vm.id))
log_handler.info (str(header) + " VM Instance ID = %s" % (vm.instance_id))
log_handler.info (str(header) + " VM Type Name = %s" % (vm.type_name))
log_handler.info (str(header) + " VM Unit Price = %s" % (vm.unit_price))
log_handler.info (str(header) + " VM Status = %s" % (simgval.get_sim_code_str(vm.status)))
log_handler.info (str(header) + " VM Time Create = %s" % (str(vm.time_create)))
log_handler.info (str(header) + " VM Time Active = %s" % (str(vm.time_active)))
log_handler.info (str(header) + " VM Time Terminate = %s" % (str(vm.time_terminate)))
log_handler.info (str(header) + " VM Cost = %f" % (vm.cost))
log_handler.info (str(header) + " VM startup_lag = %d" % (vm.startup_lag))
log_handler.info (str(header) + " ================================================================")
if vm.current_job is not None:
log_handler.info (str(header) + " Current Job = (ID:%d, NM:%s, ADR:%s (CPU:%s, I/O:%s), DL:%d, SDR:%d)"
% (vm.current_job.id, vm.current_job.name, vm.current_job.act_duration_on_VM, vm.current_job.act_cputime_on_VM, vm.current_job.act_nettime_on_VM, vm.current_job.deadline, vm.current_job.std_duration))
else:
log_handler.info (str(header) + " Current Job = %s" % (vm.current_job))
log_handler.info (str(header) + " VM Curr Job Start Clock = %d" % (vm.current_job_start_clock))
log_handler.info (str(header) + " VM Last Job Compe Clock = %d" % (vm.last_job_complete_clock))
if len(vm.job_queue) < 1:
log_handler.info (str(header) + " Job Queue = None")
else:
job_queue_list = []
for job in vm.job_queue:
job_info = []
job_info.append(job.id)
job_info.append(job.name)
job_info.append(job.act_duration_on_VM)
job_info.append(job.act_cputime_on_VM)
job_info.append(job.act_nettime_on_VM)
job_info.append(job.deadline)
job_info.append(job.std_duration)
job_info.append(job.time_create)
job_queue_list.append (job_info)
log_handler.info (str(header) + " Job Queue = %s" % (str(job_queue_list)))
if len(vm.job_history) < 1:
log_handler.info (str(header) + " Job History = None")
else:
jh_list = []
for jh in vm.job_history:
jh_info = []
jh_info.append(jh.id)
jh_info.append(jh.name)
jh_info.append(jh.act_duration_on_VM)
jh_info.append(jh.act_cputime_on_VM)
jh_info.append(jh.act_nettime_on_VM)
jh_info.append(jh.deadline)
jh_info.append(jh.std_duration)
jh_info.append(jh.time_create)
jh_list.append(jh_info)
log_handler.info (str(header) + " Job History = %s" % (str(jh_list)))
log_handler.info (str(header) + " VM SD Policy Activated = %s" % (vm.sd_policy_activated))
log_handler.info (str(header) + " VM SD Wait Time = %d" % (vm.sd_wait_time))
log_handler.info (str(header) + " VM IS VScale Victim??? = %s" % (vm.is_vscale_victim))
log_handler.info (str(header) + " VM VM VScale Case = %s" % (simgval.get_sim_code_str(vm.vscale_case)))
log_handler.info (str(header) + " VM VScale Victim ID = %d" % (vm.vscale_victim_id))
log_handler.info (str(header) + " ================================================================")
def load_sim_config(sim_conf_obj):
perf_data_trans_cloud = 0
perf_data_trans_in = 0
perf_data_trans_out = 0
cost_data_trans_cloud = 0
cost_data_trans_in = 0
cost_data_trans_out = 0
conf_txt_vm_sd_policy_name = None
with open('./config/config.txt', 'r') as f:
for l in f.readlines():
if l.startswith('#'):
continue
# VM SD Policy
if "VM_SCALE_DOWN_POLICY_NAME" in l:
conf_txt_vm_sd_policy_name = l.split('=')[1].strip()
simobj.set_Config_vm_scale_down_policy(
sim_conf_obj, conf_txt_vm_sd_policy_name)
if "VM_SCALE_DOWN_POLICY_UNIT" in l:
simobj.set_Config_vm_scale_down_policy_unit(
sim_conf_obj,
l.split('=')[1].strip())
if "VM_SCALE_DOWN_POLICY_RECENT_SAMPLE_CNT" in l:
simobj.set_Config_vm_scale_down_policy_recent_sample_cnt(
sim_conf_obj,
l.split('=')[1].strip())
if "VM_SCALE_DOWN_POLICY_PARAM1" in l:
simobj.set_Config_vm_scale_down_policy_param1(
sim_conf_obj,
l.split('=')[1].strip())
if "VM_SCALE_DOWN_POLICY_PARAM2" in l:
simobj.set_Config_vm_scale_down_policy_param2(
sim_conf_obj,
l.split('=')[1].strip())
if "VM_SCALE_DOWN_POLICY_PARAM3" in l:
simobj.set_Config_vm_scale_down_policy_param3(
sim_conf_obj,
l.split('=')[1].strip())
if "VM_SCALE_DOWN_POLICY_MIN_WAIT_TIME" in l:
simobj.set_Config_vm_scale_down_policy_min_wait_time(
sim_conf_obj,
l.split('=')[1].strip())
if "VM_SCALE_DOWN_POLICY_MAX_WAIT_TIME" in l:
simobj.set_Config_vm_scale_down_policy_max_wait_time(
sim_conf_obj,
l.split('=')[1].strip())
if "WORK_LOAD_FILE" in l:
simobj.set_Config_workload_file(sim_conf_obj,
l.split('=')[1].strip())
#if "WORK_LOAD_TYPE" in l:
# simobj.set_Config_workload_type (sim_conf_obj, l.split('=')[1].strip())
if "JOB_ASSIGNMENT_POLICY" in l:
simobj.set_Config_job_assign_policy(sim_conf_obj,
l.split('=')[1].strip())
if "MAX_NUM_OF_CONCURRENT_VMS" in l:
simobj.set_Config_job_assign_max_running_VMs(
sim_conf_obj,
l.split('=')[1].strip())
# vertical scaling
if "ENABLE_VERTICAL_SCALING=YES" in l:
simobj.set_Config_enable_vertical_scaling(
sim_conf_obj,
l.split('=')[1].strip())
if "VERTICAL_SCALING_OPERATION" in l:
simobj.set_Config_vscale_operation(sim_conf_obj,
l.split('=')[1].strip())
# startup lag
if "MIN_STARTUP_LAG" in l:
simobj.set_Config_min_startup_lag(sim_conf_obj,
int(l.split('=')[1].strip()))
if "MAX_STARTUP_LAG" in l:
simobj.set_Config_max_startup_lag(sim_conf_obj,
int(l.split('=')[1].strip()))
# multi vms
if "VM_CONFIG_FILE" in l:
simobj.set_Config_vm_config_file(sim_conf_obj,
l.split('=')[1].strip())
if "VM_SELECTION_METHOD" in l:
simobj.set_Config_vm_selection_method(sim_conf_obj,
l.split('=')[1].strip())
# related to vm billing
if "VM_BILLING_TIME_UNIT" in l:
simobj.set_Config_billing_time_unit(sim_conf_obj,
l.split('=')[1].strip())
if "VM_BILLING_TIME_PERIOD" in l:
simobj.set_Config_billing_time_period(
sim_conf_obj, int(l.split('=')[1].strip()))
# storage system
if "MAX_CAPACITY_OF_STORAGE" in l:
simobj.set_Config_max_capacity_of_storage(
sim_conf_obj, int(l.split('=')[1].strip()))
# This is reserved -- 03122015
# if "MAX_NUM_OF_STORAGE_CONTAINER" in l:
# simobj.set_Config_max_num_of_storage_containers (sim_conf_obj, int(l.split('=')[1].strip()))
if "STORAGE_UNIT_COST" in l:
simobj.set_Config_storage_unit_cost(
sim_conf_obj, float(l.split('=')[1].strip()))
if "STORAGE_BILLING_TIME_UNIT" in l:
simobj.set_Config_storage_billing_unit_clock(
sim_conf_obj, int(l.split('=')[1].strip()))
# related to data-transfer
# data transfer performance
if "PERF_DATA_TRANSFER_CLOUD" in l:
perf_data_trans_cloud = float(l.split('=')[1].strip())
if "PERF_DATA_TRANSFER_IN" in l:
perf_data_trans_in = float(l.split('=')[1].strip())
if "PERF_DATA_TRANSFER_OUT" in l:
perf_data_trans_out = float(l.split('=')[1].strip())
# data transfer cost
if "COST_DATA_TRANSFER_CLOUD" in l:
cost_data_trans_cloud = float(l.split('=')[1].strip())
if "COST_DATA_TRANSFER_IN" in l:
cost_data_trans_in = float(l.split('=')[1].strip())
if "COST_DATA_TRANSFER_OUT" in l:
cost_data_trans_out = float(l.split('=')[1].strip())
# job failure model
if "PROB_JOB_FAILURE" in l:
simobj.set_Configure_prob_job_failure(
sim_conf_obj, float(l.split('=')[1].strip()))
if "JOB_FAILURE_POLICY" in l:
simobj.set_Configure_job_failure_policy(
sim_conf_obj,
l.split('=')[1].strip())
# system trace...
if "SIM_TRACE_INTERVAL" in l:
simobj.set_Config_sim_trace_interval(
sim_conf_obj, int(l.split('=')[1].strip()))
perf_data_transfer = []
perf_data_transfer.append(perf_data_trans_cloud)
perf_data_transfer.append(perf_data_trans_in)
perf_data_transfer.append(perf_data_trans_out)
simobj.set_Config_perf_data_transfer(sim_conf_obj, perf_data_transfer)
cost_data_transfer = []
cost_data_transfer.append(cost_data_trans_cloud)
cost_data_transfer.append(cost_data_trans_in)
cost_data_transfer.append(cost_data_trans_out)
simobj.set_Config_cost_data_transfer(sim_conf_obj, cost_data_transfer)
print "* Read Config - Done"
# check configuration
if sim_conf_obj.min_startup_lag > sim_conf_obj.max_startup_lag:
print "- [ERROR] Config.txt - MAX_STARTUP_LAG(%d) must be equal to or greater than MIN_STARTUP_LAG(%d)" % (
max_startup_lag, min_startup_lag)
exit()
# check max number of vms
if sim_conf_obj.job_assign_max_running_vms is None:
print "- [ERROR] Conf Error for MAX_NUM_OF_CONCURRENT_VMS! - It should be int [> 0] or 'UNLIMITED'"
exit()
# scale down policy check
if sim_conf_obj.vm_scale_down_policy == None:
print "- [ERROR] Conf Error for VM_SCALE_DOWN_POLICY_NAME! - \"%s\" is NOT valid configuration." % (
conf_txt_vm_sd_policy_name)
exit()
# set scale down unit simulation clock
upd_res = simobj.set_Config_vm_scale_down_policy_timer_unit(sim_conf_obj)
if upd_res is False:
print "- [ERROR] Set VM Scale Down Unit Timer Clock Failed!"
exit()
# set billing unit simulation clock
upd_ret = simobj.set_Config_billing_unit_clock(sim_conf_obj)
if upd_ret is False:
print "- [ERROR] Set Billing Unit Clock Failed!"
exit()
# vertical scaling check
if sim_conf_obj.enable_vertical_scaling == True and sim_conf_obj.job_assign_max_running_vms == sys.maxint:
print "- [ERROR] Vertical scaling can be activated when using limited # of VMs"
exit()
# job failure policy check
if sim_conf_obj.prob_job_failure > 0 and sim_conf_obj.job_failure_policy == None:
print "- [ERROR] Job Failure Probability (%s) or Job Failure Policy (%s) Error" % (
sim_conf_obj.prob_job_failure,
simgval.get_sim_code_str(sim_conf_obj.job_failure_policy))
exit()
def SEH_evt_ask_simentity_termination(q_msg):
evt_src = q_msg[2] # EVT_SRC
evt_code = q_msg[4] # EVT_CODE
baseline_block_id = simgval.gBLOCK_WORKLOAD_GEN
if evt_code != simgval.gEVT_ASK_SIMENTITY_TERMINATION:
g_log_handler.error("[SimEvent] %s EVT_CODE (%s) Error! => %s" %
(str(Global_Curr_Sim_Clock),
simgval.get_sim_code_str(evt_code), q_msg))
clib.sim_exit()
if evt_src == baseline_block_id:
g_log_handler.error("[SimEvent] %s EVT_CODE (%s) Error! - Invalid SRC Block (%s) => %s" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), simgval.get_sim_code_str(evt_src), q_msg))
clib.sim_exit()
print "[SimEvent] %s IN Sentout_Timer_Event_IDs => %s" % (
str(Global_Curr_Sim_Clock), str(Sentout_Timer_Event_IDs))
term_cfm_evt_code = None
# Workload Gen Sim Entity is Running
if g_Sim_Entity_Running_States[baseline_block_id] is True:
# cannot be terminated
g_log_handler.error("[SimEvent] %s EVT_CODE (%s) Processing - %s CANNOT be terminated! - %s [%s] is running!" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), simgval.get_sim_code_str(evt_src), simgval.get_sim_code_str(baseline_block_id), str(g_Sim_Entity_Running_States[baseline_block_id])))
# Send EVT_REJECT_SIMENTITY_TERMINATION to SRC BLOCK
term_cfm_evt_code = simgval.gEVT_REJECT_SIMENTITY_TERMINATION
# Workload Gen Block is not Running
else:
no_of_tmr_evts = get_number_of_imp_Timer_Events()
if no_of_tmr_evts < 1:
# termination confirm - no timer events and baseline block already terminated.
# Send gEVT_CONFIRM_SIMENTITY_TERMINATION to SRC BLOCK
g_log_handler.info("[SimEvent] %s EVT_CODE (%s) Processing - %s CAN be terminated! - %s [%s] is stopped and %d Timer Event(s) remain(s)!" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), simgval.get_sim_code_str(evt_src), simgval.get_sim_code_str(baseline_block_id), str(g_Sim_Entity_Running_States[baseline_block_id]), no_of_tmr_evts))
term_cfm_evt_code = simgval.gEVT_CONFIRM_SIMENTITY_TERMINATION
else:
# cannot be terminated --> timer events exits
g_log_handler.info("[SimEvent] %s EVT_CODE (%s) Processing - %s CANNOT be terminated! - %d Timer Event(s) remain(s)" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(evt_code), simgval.get_sim_code_str(evt_src), no_of_tmr_evts))
# Send EVT_REJECT_SIMENTITY_TERMINATION to SRC BLOCK
term_cfm_evt_code = simgval.gEVT_REJECT_SIMENTITY_TERMINATION
dst_block_id = evt_src
term_cfm_evt = clib.make_queue_event(Global_Curr_Sim_Clock, g_my_block_id,
dst_block_id, term_cfm_evt_code, None,
None)
r = send_EVT_to_Block(term_cfm_evt_code, dst_block_id, term_cfm_evt)
if r is not True:
g_log_handler.error("[SimEvent] %s Timer Event Send Out Error!!! - %s, %s" \
% (str(Global_Curr_Sim_Clock), simgval.get_sim_code_str(term_cfm_evt_code), term_cfm_evt))
clib.sim_exit()
print "[SimEvent] %s OUT Sentout_Timer_Event_IDs => %s" % (
str(Global_Curr_Sim_Clock), str(Sentout_Timer_Event_IDs))
def get_infos(self):
info_str = "<ID:%s, SC:%s, ON:Job-%s, SZ:%s KB, PR:$%s, ST:%s, DST:%s, PSZ:%s KB, CT:%s, AT:%s, DT:%s>" \
% (self.sfo_id, self.sfo_sc_id, self.sfo_owner, self.sfo_size, self.sfo_usage_price, simgval.get_sim_code_str(self.sfo_status), simgval.get_sim_code_str(self.sfo_data_status), self.sfo_planned_size, self.sfo_create_time, self.sfo_active_time, self.sfo_delete_time)
return info_str
