Моделирование нагрузки

loadmodel.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Лабораторная работа №2 по курсу "Компьютерное моделирование"
# тема "Моделирование загрузки компьютерной системы"
# выполнил ст.3 к. ФIОТ, гр. IO-03 Веринов Антон
# Вариант: 3 задачи, 1 ядро; ГП, ВП, ISA, COM

from random import gauss, random
from operator import attrgetter, ne

def f_time_const(k=1):
    def inner():
        return k
    return inner

def f_time_gauss(mu):
    def inner():
        return int(abs(gauss(float(mu), mu*0.1)))
    return inner

class Task(object):
    def __init__(self, location):
        super(Task, self).__init__()
        self.location = location
        self.waiting = True
        self.processing_time = None
        self.toCPU = False

    def processed(self, time):
        if None != self.processing_time:
            self.processing_time -= time
            if 0.0 == self.processing_time:
                self.waiting = True
                self.processing_time = None
                self.location, self.toCPU = self.location.goto(self.toCPU)

    def __str__(self):
        if not self.waiting:
            return str(self.processing_time)+"@"+self.location.name
        else:
            return "@"+self.location.name

class Device(object):
    """
        name: Имя устройства
        f_time: Функция вычисления времени обработки задач
        north: Следующий на пути к процессору устройство
        bouncer: Отправляет ли устройство задачу обратно в ЦП
    """
    def __init__(self, name, f_time, north=None, bouncer=True):
        super(Device, self).__init__()
        self.name = name
        self.f_time = f_time
        self.occupied = False
        self.north = north
        self.bouncer = bouncer

    def set_paths(self, *paths):
        self.paths = paths

    def occupy(self):
        self.occupied = True

    def free(self):
        self.occupied = False

    def goto(self, toCPU):
        """
            toCPU: В сторону процессора?
            return tuple: Следующее устройство для задачи, В сторону ЦП?
        """
        self.free()
        # устройство не процессор и 
        # задача либо на пути к процессору, либо устройство её туда отправило
        if None != self.north and (toCPU or self.bouncer):
            return (self.north, True)
        else:
            r = random()
            way = 0.0
            for path in self.paths:
                way += path[0]
                if way > r:
                    return (path[1], False)

d_CPU = Device("CPU", f_time_const(), bouncer=False)    # центральный процессор
d_NBr = Device("NBr", f_time_const(5), d_CPU, False)    # северный мост
d_SBr = Device("SBr", f_time_const(20), d_NBr, False)   # южный мост
d_ISA = Device("ISA", f_time_gauss(50), d_SBr, False)   # ISA

d_RAM = Device("RAM", f_time_gauss(15), d_NBr)          # оперативная память
d_GPU = Device("GPU", f_time_gauss(50), d_NBr)          # графический процессор

d_ATA = Device("ATA", f_time_gauss(80), d_SBr)          # контроллер диска
d_VGA = Device("VGA", f_time_gauss(70), d_CPU)          # видеопроцессор
d_USB = Device("USB", f_time_gauss(100), d_SBr)         # USB-контроллер

d_COM = Device("COM", f_time_gauss(1000), d_ISA)        # COM-порт

d_CPU.set_paths((0.99, d_CPU), (0.01, d_NBr))
d_NBr.set_paths((0.65, d_RAM), (0.20, d_GPU), (0.15, d_SBr))
d_SBr.set_paths((0.45, d_ATA), (0.40, d_VGA), (0.15, d_USB))
d_ISA.set_paths((1.0, d_COM))

tasks = [Task(d_CPU), Task(d_CPU), Task(d_CPU)]

sum_time = 0
d_timer = {}
out_cycle = 0

while sum_time < 100000:
    for task in tasks:
        if task.waiting and not task.location.occupied:
            task.waiting = False
            task.location.occupy()
        if not task.waiting and None == task.processing_time:
            task.processing_time = task.location.f_time()

    tasks.sort(key=attrgetter("processing_time"))
    itasks = iter(tasks)
    first_task = itasks.next()
    while None == first_task.processing_time:
        first_task = itasks.next()

    jump_time = first_task.processing_time
    sum_time += jump_time
    try:
        d_timer[task.location.name] += jump_time
    except KeyError:
        d_timer[task.location.name] = jump_time
    for task in tasks:
        task.processed(jump_time)

    # отображение случайного отрезка выполнения моделирования
    if not out_cycle and random() > 0.99 and \
            all(map(lambda x: ne(x.location.name, "CPU"), tasks)):
        out_cycle = 20
    if out_cycle:
        print(str(sum_time)+"  "+" ".join(map(str, tasks)))
        out_cycle -= 1
        if 0 == out_cycle:
            print("-"*20)

print(sum_time)
for key in d_timer:
    print(key+" "+"*"*int(100*d_timer[key]/sum_time)+"   "+str(d_timer[key]))

# 11548  @RAM 2@RAM 58@USB
# 11550  @RAM @NBr 56@USB
# 11555  @CPU 12@RAM 51@USB
# 11556  @CPU 11@RAM 50@USB
# 11557  @CPU 10@RAM 49@USB
# 11558  @CPU 9@RAM 48@USB
# 11559  @CPU 8@RAM 47@USB
# 11560  @CPU 7@RAM 46@USB
# 11561  @CPU 6@RAM 45@USB
# 11562  @CPU 5@RAM 44@USB
# 11563  @CPU 4@RAM 43@USB
# 11564  @CPU 3@RAM 42@USB
# 11565  @CPU 2@RAM 41@USB
# 11566  @CPU 1@RAM 40@USB
# 11567  @CPU @NBr 39@USB
# 11568  @CPU 4@NBr 38@USB
# 11569  @CPU 3@NBr 37@USB
# 11570  @CPU 2@NBr 36@USB
# 11571  @CPU 1@NBr 35@USB
# 11572  @CPU @CPU 34@USB
# --------------------
# 46315  @NBr 11@SBr 56@ATA
# 46320  @RAM 6@SBr 51@ATA
# 46326  @NBr 10@RAM 45@ATA
# 46331  @CPU 5@RAM 40@ATA
# 46332  @CPU 4@RAM 39@ATA
# 46333  @CPU 3@RAM 38@ATA
# 46334  @CPU 2@RAM 37@ATA
# 46335  @CPU 1@RAM 36@ATA
# 46336  @CPU @NBr 35@ATA
# 46337  @CPU 4@NBr 34@ATA
# 46338  @CPU 3@NBr 33@ATA
# 46339  @CPU 2@NBr 32@ATA
# 46340  @CPU 1@NBr 31@ATA
# 46341  @CPU @CPU 30@ATA
# 46342  @CPU @CPU 29@ATA
# 46343  @CPU @CPU 28@ATA
# 46344  @CPU @CPU 27@ATA
# 46345  @CPU @CPU 26@ATA
# 46346  @CPU @CPU 25@ATA
# 46347  @CPU @CPU 24@ATA
# --------------------
# 100000
# SBr ***   3644
# USB **   2201
# ATA ****   4591
# NBr ******   6678
# RAM *******   7383
# VGA ***   3157
# GPU ********   8857
# CPU ***************************************************************   63489