def host_monitor(shared_list: list):
logging.basicConfig(filename='./log/host-monitor.log',
filemode='a',
format='%(asctime)s %(levelname)s:%(message)s',
datefmt='%d/%m/%Y %H:%M:%S',
level=logging.INFO)
host = Host()
while True:
logging.info(
'========================================================')
logging.debug('Starting Host Monitor')
start_time = datetime.now()
try:
update_lat_init = datetime.now()
host.update()
host.container_active_list = shared_list[0]
host.container_inactive_list = shared_list[1]
#host.core_allocation = shared_list[2]
#host.update_containers()
host.update_containers2()
update_lat_end = datetime.now()
logging.info('Get Host + Containers Info Latency: %f',
(update_lat_end - update_lat_init).total_seconds())
#print('Monitor:\n', 'AC:', host.container_active_list, 'IC:', host.container_inactive_list, 'Core:', host.core_allocation)
publish_lat_init = datetime.now()
container_list = host.container_active_list + host.container_inactive_list
logging.info('Container List:' + str(container_list))
for container in container_list:
if container.checkContainer():
logging.debug('Publish Container %s Info', container.name)
#database.publish_local_container_history(container)
nosqlbase.publish_container_history(container)
publish_lat_end = datetime.now()
logging.info('Local publish Container Info Latency: %f',
(publish_lat_end - publish_lat_init).total_seconds())
send_lat_init = datetime.now()
logging.debug('Send Monitoring Data to Manager')
logging.debug('Sended Host Data: %s', vars(host))
communication.send_monitor_data(host)
send_lat_end = datetime.now()
logging.info('Send Host Info to CM Latency: %f',
(send_lat_end - send_lat_init).total_seconds())
host.remove_finished_containers()
#shared_list[2] = host.core_allocation
except Exception as err:
logging.error('Monitor error: %s', err)
stop_time = datetime.now()
monitor_time = (stop_time - start_time).total_seconds()
logging.info('Monitor Total Time: %f, Next Sleep Time: %f',
monitor_time, (1 - monitor_time))
logging.info(
'========================================================')
if monitor_time < 1:
logging.debug('Host Monitor Sleeping')
time.sleep(1 - monitor_time)
def container_manager2(shared_list: list,
entry_queue: mp.Queue): # Algorithm 1
logCM = logging.getLogger('Container_Manager')
logCM.setLevel(logging.INFO)
format = logging.Formatter(fmt='%(asctime)s %(levelname)s %(message)s',
datefmt='%d/%m/%Y %H:%M:%S')
file_handler = logging.FileHandler(filename='./log/container-manager2.log',
mode='a')
file_handler.setFormatter(format)
file_handler.setLevel(logging.INFO)
logCM.addHandler(file_handler)
config = ConfigParser()
config.read('./config/local-config.txt')
host = Host()
scheduler = VEMOC()
scheduler.long_interval = int(config['Scheduler']['sched_interval'])
scheduler.short_interval = max(int(scheduler.long_interval / 2), 3)
scheduler.mem_write_rate = 9999
scheduler.swapout_rate = 33000
scheduler.swapin_rate = 7000
#scheduler.MUE = float(config['Scheduler']['MUE'])
HMUT = round((22.8 * 2**30) / mmap.PAGESIZE)
#maxMU = float(config['Scheduler']['MUE'])
maxMU = 0.997
scheduler.latency = 0.1
sched_counter = 1
while True:
start_time = datetime.now()
logCM.info('========================================================')
logCM.info('Sched counter: %d', sched_counter)
logCM.info('Sched init timestamp: %s', start_time)
scheduler.reset()
scheduler.sched_interval = scheduler.long_interval
scheduler.sched_start_time = start_time
# Add Created Containers
while not entry_queue.empty():
container = entry_queue.get()
logCM.info('New Container: %s', container.name)
container.inactive_time = datetime.now()
container.setContainerState('QUEUED')
host.container_inactive_list.append(container)
# Count Inactive Container Memory
inactive_memory = 0
host.update()
host.update_containers2()
#host.remove_finished_containers()
for container in host.container_inactive_list:
if container.state == 'QUEUED':
inactive_memory += container.getMinMemoryLimitPG()
elif container.state == 'SUSPENDED':
inactive_memory += container.getMemoryLimitPG(
) + container.getDeltaMemory()
#scheduler.setNAHM(host.get_available_limit())
#HAM = host.memory.available
#TCML = host.get_container_total_limit()
TCML, NAHM, HAM = host.get_host_memory_info()
scheduler.setNAHM(NAHM)
#scheduler.MUE = min(maxMU, maxMU - (HAM + TCML - HMUT) / (20 * 10 ** 9))
if HAM < 262144:
scheduler.setMUE(
min(
maxMU, maxMU - (HAM + TCML - HMUT) /
((20 * 10**9) / mmap.PAGESIZE)))
else:
scheduler.setMUE(maxMU)
scheduler.spare_mem_cap = round(
scheduler.mem_write_rate *
(scheduler.sched_interval + scheduler.latency))
logCM.info('NAHM: %d, HAM: %d, TCML: %d', scheduler.NAHM, HAM, TCML)
logCM.info('MUE: %f, spare_mem_cap: %d, latency: %f', scheduler.MUE,
scheduler.spare_mem_cap, scheduler.latency)
logCM.info('Active List: ' + str(host.container_active_list))
logCM.info('Inactive List: ' + str(host.container_inactive_list))
# Call algorithm 2
if len(host.container_active_list) > 0:
logCM.info(
'---------------------------------------------------------')
logCM.info('Executing Demand Estimation:')
scheduler.mem_demand_estimation2(host)
# Call algorithm 5
if scheduler.getNAHM() < (
scheduler.getMemoryNeeded() + scheduler.getMemoryUrgent() +
scheduler.getPauseDemand() + inactive_memory):
logCM.info(
'---------------------------------------------------------')
logCM.info('Executing Passive Memory Reduction:' +
str(scheduler.provider_list))
scheduler.passive_memory_reduction2()
# Call algorithm 6
if scheduler.getNAHM() < (scheduler.getMemoryNeeded() +
scheduler.getMemoryUrgent() +
scheduler.getPauseDemand()):
logCM.info(
'---------------------------------------------------------')
logCM.info('Executing Active Memory Reduction:' +
str(scheduler.provider_list))
scheduler.active_memory_recovery3()
# Call algorithm 7
if (scheduler.getMemoryUrgent() >
0) or (scheduler.getMemoryNeeded() >
0) or (scheduler.getPauseDemand() > 0):
logCM.info(
'---------------------------------------------------------')
logCM.info('Executing Container Limits Adjusts:')
scheduler.increase_container_memory_limits(host)
#end_lat = datetime.now()
#scheduler.latency = (end_lat - start_time).total_seconds()
# Call algorithm 8
if (scheduler.getMemoryUrgent() >
0) or (scheduler.getMemoryNeeded() >
0) or (scheduler.getPauseDemand() > 0):
logCM.info(
'---------------------------------------------------------')
logCM.info('Executing Pause/Suspend Running Containers:')
scheduler.pause_suspend_running_containers(host)
# Call algorithm 10
elif (scheduler.getStealCheck()
== False) and (len(host.container_inactive_list) != 0):
logCM.info(
'---------------------------------------------------------')
logCM.info('Executing Start/Resume Inactive Containers:')
scheduler.start_resume_inactive_container(host)
# Host Updates
host.update()
host.update_containers2()
shared_list[0] = host.container_active_list
shared_list[1] = host.container_inactive_list
shared_list[2] = host.core_allocation
# Calculate process sleep time
stop_time = datetime.now()
#sched_time = (stop_time - start_time).total_seconds()
scheduler.latency = (stop_time - start_time).total_seconds()
logCM.info('Sched end timestamp: %s', stop_time)
logCM.info('New Sched Latency: %f', scheduler.latency)
#logCM.info('Sched Time: %f seconds, Sleep time: %f seconds', sched_time, (scheduler.sched_interval - sched_time))
logCM.info('Sleep time: %f seconds',
scheduler.sched_interval - scheduler.latency - 0.007)
logCM.info('========================================================')
sched_counter += 1
#if (sched_time < scheduler.sched_interval):
# time.sleep(scheduler.sched_interval - sched_time)
if (scheduler.latency < scheduler.sched_interval):
time.sleep(scheduler.sched_interval - scheduler.latency - 0.007)
def no_manager(shared_list: list, entry_queue: mp.Queue):
logNM = logging.getLogger('Container_Manager')
logNM.setLevel(logging.INFO)
format = logging.Formatter(fmt='%(asctime)s %(levelname)s %(message)s',
datefmt='%d/%m/%Y %H:%M:%S')
file_handler = logging.FileHandler(filename='./log/no-manager.log',
mode='a')
file_handler.setFormatter(format)
file_handler.setLevel(logging.DEBUG)
logNM.addHandler(file_handler)
sched = Basic()
config = ConfigParser()
config.read('./config/local-config.txt')
sched.setLevel(config['QoS']['level'])
host = Host()
sched_counter = 1
while True:
start_time = datetime.now()
logNM.info('========================================================')
logNM.info('Sched counter: %d', sched_counter)
logNM.info('Sched init timestamp: %s', start_time)
print(sched_counter, datetime.now())
# Add Created Containers
while not entry_queue.empty():
container = entry_queue.get()
logNM.info('New Container: %s', container.name)
container.inactive_time = datetime.now()
container.setContainerState('QUEUED')
host.container_inactive_list.append(container)
host.update()
host.update_containers2()
TCML, NAHM, HAM = host.get_host_memory_info()
sched.setNAHM(NAHM)
logNM.info('NAHM: %d, HAM: %d, TCML: %d', sched.getNAHM(), HAM, TCML)
logNM.info('Active List: %s', host.container_active_list)
logNM.info('Inactive List: %s', host.container_inactive_list)
logNM.info('QoS Test: %s', sched.getLevel())
if (host.inactive_list_counter() != 0):
logNM.info(
'---------------------------------------------------------')
logNM.info('Executing Limit Redistribution Policy:')
sched.qos_share_limit_policy(host)
logNM.info(
'---------------------------------------------------------')
logNM.info('Executing Start Inactive Containers:')
sched.qos_start_policy(host)
else:
if (sched.getNAHM() > 0) and (sched.getLevel() in [
'BEST', 'FAIR'
]) and (host.active_list_counter() > 0):
logNM.info(
'---------------------------------------------------------'
)
logNM.info('Executing NAHM Redistribution:')
sched.qos_recovery_limit_policy(host)
host.update()
host.update_containers2()
shared_list[0] = host.container_active_list
shared_list[1] = host.container_inactive_list
stop_time = datetime.now()
logNM.info('Sched end timestamp: %s', stop_time)
latency = (stop_time - start_time).total_seconds()
logNM.info('New Sched Latency: %f', latency)
logNM.info('Sleep time: %f seconds', 1 - latency)
logNM.info('========================================================')
sched_counter += 1
if (latency < 1):
time.sleep(1 - latency)