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