Example #1
0
    def __init__(self,**args):
        defaults={'sim':None,
                  'ID':'1',
                  'net':Network(),
                  'gcom': Gcom(),
                  'devt': {},
                  'refreshRSS':0.3,
                  'refreshTOA':0.3,
                  'mp':False
                  }
##       initialize attributes
        for key, value in defaults.items():
            if args.has_key(key):

                setattr(self, key, args[key])
            else:
                setattr(self, key, value)
                args[key]=value  
        self.args=args
        self.PN=self.net.node[self.ID]['PN']
        self.create_evt()

        Process.__init__(self,name='Rx-'+str(self.ID),sim=self.sim)

        Cf = ConfigParser.ConfigParser()
        Cf.read(pyu.getlong('agent.ini','ini'))
        for s in Cf.sections():
            try:
                d= dict(Cf.items(s))
                if d['id']==self.ID:
                    self.refreshRSS=eval(d['refreshrss'])
                    self.refreshTOA=eval(d['refreshtoa'])
                break
            except:
                pass
Example #2
0
    def __init__(self, model, proc_info):
        Process.__init__(self, name=proc_info.name, sim=model)
        self._model = model
        self._internal_id = Processor._identifier
        Processor._identifier += 1
        self.identifier = proc_info.identifier
        # EDIT currently running time partition
        self._time_part = False
        self._running_inst = None
        self._evts_inst = deque([])
        self._sched_part = None

        self._running = None
        self.was_running = None
        self._evts = deque([])
        self.sched = model.scheduler
        self.monitor = Monitor(name="Monitor" + proc_info.name, sim=model)
        self._caches = []
        self._penalty = proc_info.penalty
        self._cs_overhead = proc_info.cs_overhead
        self._cl_overhead = proc_info.cl_overhead
        self._migration_overhead = proc_info.migration_overhead
        self.set_caches(proc_info.caches)
        self.timer_monitor = Monitor(name="Monitor Timer" + proc_info.name,
                                     sim=model)
        self._speed = proc_info.speed
Example #3
0
    def __init__(self,**args):
        defaults={'net':Network(),
                  'L':[],
                  'net_updt_time':0.001,
                  'sim':None,
                  'show_sg':False,
                  'disp_inf':False,
                  'save':[]}

##       initialize attributes
        for key, value in defaults.items():
            if args.has_key(key):
                setattr(self, key, args[key])
            else:
                setattr(self, key, value)
                args[key]=value  
        self.args=args

        Process.__init__(self,name='PNetwork',sim=self.sim)
        self.cpt=self.sim.now()
        self.filename='pos'

        if 'mysql' in self.save:
           config = ConfigParser.ConfigParser()
           config.read(pyu.getlong('simulnet.ini','ini'))
           sql_opt = dict(config.items('Mysql'))
           self.net.db = Database(sql_opt['host'],sql_opt['user'],sql_opt['passwd'],sql_opt['dbname'])
Example #4
0
    def initialize(self):
        Process.__init__(self)
        CoreObject.initialize(self)
        self.waitToDispose=False    #flag that shows if the object waits to dispose an entity    
        
        self.Up=True                    #Boolean that shows if the object is in failure ("Down") or not ("up")
        self.currentEntity=None      
          
        self.totalFailureTime=0         #holds the total failure time
        self.timeLastFailure=0          #holds the time that the last failure of the object started
        self.timeLastFailureEnded=0          #holds the time that the last failure of the object Ended
        self.downTimeProcessingCurrentEntity=0  #holds the time that the object was down while processing the current entity
        self.downTimeInTryingToReleaseCurrentEntity=0 #holds the time that the object was down while trying 
                                                      #to release the current entity  
        self.downTimeInCurrentEntity=0                  #holds the total time that the object was down while holding current entity
        self.timeLastEntityLeft=0        #holds the last time that an entity left the object
                                                
        self.processingTimeOfCurrentEntity=0        #holds the total processing time that the current entity required                                               
                                                      

        
        self.totalBlockageTime=0        #holds the total blockage time
        self.totalWaitingTime=0         #holds the total waiting time
        self.totalWorkingTime=0         #holds the total working time
        self.completedJobs=0            #holds the number of completed jobs   
        
        self.timeLastEntityEnded=0      #holds the last time that an entity ended processing in the object     
        self.timeLastEntityEntered=0      #holds the last time that an entity ended processing in the object   
        self.timeLastFrameWasFull=0     #holds the time that the last frame was full, ie that assembly process started  
        self.nameLastFrameWasFull=""    #holds the name of the last frame that was full, ie that assembly process started
        self.nameLastEntityEntered=""   #holds the name of the last frame that entered processing in the object
        self.nameLastEntityEnded=""     #holds the name of the last frame that ended processing in the object            
        self.Res=Resource(1)    
        self.Res.activeQ=[]  
        self.Res.waitQ=[]  
Example #5
0
    def __init__(self, sim, task_info):
        """
        Args:

        - `sim`: :class:`Model <simso.core.Model>` instance.
        - `task_info`: A :class:`TaskInfo` representing the Task.

        :type sim: Model
        :type task_info: TaskInfo
        """
        Process.__init__(self, name=task_info.name, sim=sim)
        self.name = task_info.name
        self._task_info = task_info
        self._monitor = Monitor(name="Monitor" + self.name + "_states",
                                sim=sim)
        self._activations_fifo = deque([])
        self._sim = sim
        self.cpu = None
        self._etm = sim.etm
        self._job_count = 0
        self._last_cpu = None
        self._cpi_alone = {}
        self._jobs = []
        self.job = None
        self.last_skipped = 0
        self.reclaimed_budget = 0

        # EDIT added partition to which this task belongs
        self._part = None
Example #6
0
    def __init__(self, name, sim, task):
        Process.__init__(self, name=name, sim=sim)

        # number of the action
        self.q = 0

        # corresonding pycpa task
        self.task = task

        # the signal used to wake up the activation event
        self.signal_event = SimEvent(sim=sim)

        # workload left to consume
        self.workload = task.wcet

        # active segments of the execution of the form: [(0,1), (3,9)]
        self.exec_windows = list()

        # last recent start of a execution segment
        self.recent_window_start = None

        # actual response time
        self.response_time = 0

        # start time
        self.start_time = 0

        # finishing time
        self.finish_time = 0
Example #7
0
    def __init__(self, sim, task_info):
        """
        Args:

        - `sim`: :class:`Model <simso.core.Model>` instance.
        - `task_info`: A :class:`TaskInfo` representing the Task.

        :type sim: Model
        :type task_info: TaskInfo
        """
        Process.__init__(self, name=task_info.name, sim=sim)
        self.name = task_info.name
        self._task_info = task_info
        self._monitor = Monitor(name="Monitor" + self.name + "_states",
                                sim=sim)
        self._activations_fifo = deque([])
        self._sim = sim
        self.cpu = None
        self._etm = sim.etm
        self._job_count = 0
        self._last_cpu = None
        self._cpi_alone = {}
        self._jobs = []
        self.job = None
        # other tasks executed after it is preempted
        self._other_tasks = []
Example #8
0
 def __init__(self):
     Process.__init__(self)
     self._signals = {
         'kill' : SimEvent('kill'),
         'finish' : SimEvent('finish'),
     }
     self._finished = False
Example #9
0
    def __init__(self, **args):
        defaults = {"net": None, "L": None, "fname": "network", "fig": None, "ax": None, "sim": None}

        ##       initialize attributes
        for key, value in defaults.items():
            if key in args:
                setattr(self, key, args[key])
            else:
                setattr(self, key, value)
                args[key] = value
        self.args = args
        self.fname = self.args["fname"]

        Process.__init__(self, name="shownet", sim=self.args["sim"])

        self.fig = plt.figure(self.fname, figsize=(20, 5), dpi=100)
        self.fig.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.1)
        self.fig, self.ax = self.L.showGs(fig=self.fig)

        self.legend = True
        self.ion = True
        self.info = False

        self.coll_plot = {}
        self.C = ConfigParser.ConfigParser()
        self.C.read(pyu.getlong("show.ini", "ini"))
        self.RATcolor = dict(self.C.items("RATcolor"))
        self.RATes = dict(self.C.items("RATestyle"))
        self.update = dict(self.C.items("update"))
        self.option = dict(self.C.items("option"))
        self.cpt = self.sim.now()
Example #10
0
 def __init__(self, timer):
     Process.__init__(self, name="Timer", sim=timer.sim)
     self.function = timer.function
     self.args = timer.args
     self.delay = timer.delay
     self.one_shot = timer.one_shot
     self.cpu = timer.cpu
     self.running = False
Example #11
0
 def __init__(self, sender, simulation, circuit_id, flux_size, control_packet_offset):
     Process.__init__(self, sim=simulation)
     self.id = circuit_id
     self.sender = sender
     self.total_propagation_time = 0
     self.circuit_expiration = self.sim.now() + CIRCUIT_EXPIRATION_SECONDS
     self.offset = control_packet_offset
     self.dropped = False
    def __init__(self, actor):
        """
Constructor of the ActorProcess object,

arguments:
    Actor:             An instance of an Action object
"""
        Process.__init__(self)
        self.actor = actor
Example #13
0
    def __init__(self, actor):
        """
Constructor of the ActorProcess object,

arguments:
    Actor:             An instance of an Action object
"""
        Process.__init__(self)
        self.actor = actor
Example #14
0
 def __init__(self, timer):
     Process.__init__(self, name="Timer", sim=timer.sim)
     self.function = timer.function
     self.args = timer.args
     self.delay = timer.delay
     self.one_shot = timer.one_shot
     self.cpu = timer.cpu
     self.running = False
     self.overhead = timer.overhead
Example #15
0
    def __init__(self, task, sim):
        Process.__init__(self, name=task.name, sim=sim)
        # link to the pycpa model
        self.task = task

        # add a list to store the execution windows in the task
        self.task.q_exec_windows = list()

        # all activations that have been emitted
        self.activations = list()
 def __init__(self, max_wait, instance_type='m1.small', latency=0):
     self.terminated = False
     name = 'Server%d' % Server.counter.next()
     Process.__init__(self, name)
     self.max_wait = max_wait
     self.instance_type = instance_type
     self.latency = latency
     self.service_time_factor = 1.0 / COST_MODEL[self.instance_type][1]
     self.start_time = now()
     sys.stdout.write('+')
     sys.stdout.flush()
Example #17
0
    def __init__(self, sim, name="SPP", tasks=list()):

        assert sim != None
        Process.__init__(self, name=name, sim=sim)
        self.tasks = tasks
        self.pending = list()

        # list of simtasks
        self.simtasks = list()

        self.arrival_event = SimEvent('Arrival Event', sim=sim)
    def __init__(self, part, name, pred, monitor, etm, sim, can_donate = False):
        """
        Args:
            - `part`: The parent :class:`TimePartition <simso.core.TimePartition.TimePartition>`.
            - `name`: The name for this instance.
            - `pred`: If the partition is not periodic, pred is the partition instance that \
            released this one.
            - `monitor`: A monitor is an object that log in time.
            - `etm`: The execution time model.
            - `sim`: :class:`Model <simso.core.Model>` instance.

        :type part: PartitionInstance
        :type name: str
        :type pred: bool
        :type monitor: Monitor
        :type etm: AbstractExecutionTimeModel
        :type sim: Model
        """
        Process.__init__(self, name=name, sim=sim)
        self._part = part
        self._pred = pred
        self.instr_count = 0  # Updated by the cache model.
        self._computation_time = 0
        self._last_exec = None
        self._start_date = None
        self._end_date = None
        self._is_preempted = False
        self._donated = False
        self._activation_date = self.sim.now_ms()
        self._absolute_deadline = self.sim.now_ms() + part.deadline
        self._aborted = False
        self._sim = sim
        self._monitor = monitor
        self._etm = etm
        self._was_running_on = part.cpus
        self.can_donate = can_donate
        self._extra_budget = 0
        self._avail_budget = {}

        # Initialize WCB  for this partition
        self._WCB = {}
        self._WCB_tmr = {}
        for cpu in part.cpus:
            self._WCB[cpu] = part.length
            self._WCB_tmr[cpu] = None
            self._avail_budget[cpu] = 0

        # This is only required to get the execution speed. So pick
        # the first CPU in the list
        self.cpu = part.cpus[0]

        self._on_activate()

        self.context_ok = True  # The context is ready to be loaded.
Example #19
0
 def initialize(self):
     Process.__init__(self)
     CoreObject.initialize(self)
     self.Res=Resource(capacity=infinity)         
     
     self.Up=True                    #Boolean that shows if the object is in failure ("Down") or not ("up")
     self.currentEntity=None      
       
     self.totalBlockageTime=0        #holds the total blockage time
     self.totalFailureTime=0         #holds the total failure time
     self.totalWaitingTime=0         #holds the total waiting time
     self.totalWorkingTime=0         #holds the total working time
     self.completedJobs=0            #holds the number of completed jobs 
     
     self.timeLastEntityEnded=0      #holds the last time that an entity ended processing in the object
     self.nameLastEntityEnded=""     #holds the name of the last entity that ended processing in the object
     self.timeLastEntityEntered=0    #holds the last time that an entity entered in the object
     self.nameLastEntityEntered=""   #holds the name of the last entity that entered in the object
     self.timeLastFailure=0          #holds the time that the last failure of the object started
     self.timeLastFailureEnded=0          #holds the time that the last failure of the object Ended
     self.downTimeProcessingCurrentEntity=0  #holds the time that the object was down while processing the current entity
     self.downTimeInTryingToReleaseCurrentEntity=0 #holds the time that the object was down while trying 
                                                   #to release the current entity  
     self.downTimeInCurrentEntity=0                  #holds the total time that the object was down while holding current entity
     self.timeLastEntityLeft=0        #holds the last time that an entity left the object
                                             
     self.processingTimeOfCurrentEntity=0        #holds the total processing time that the current entity required                                   
                                                   
     self.waitToDispose=False    #shows if the object waits to dispose an entity  
     self.position=[]            #list that shows the position of the corresponding element in the conveyer
     self.timeLastMoveHappened=0   #holds the last time that the move was performed (in reality it is 
                                     #continued, in simulation we have to handle it as discrete)
                                     #so when a move is performed we can calculate where the entities should go
     self.timeToReachEnd=0           #if the conveyer has entities but none has reached the end of it, this calculates
                                     #the time when the first entity will reach the end and so it will be ready to be disposed
     self.timeToBecomeAvailable=0    #if the conveyer has entities on its back this holds the time that it will be again free
                                     #for an entity. of course this also depends on the length of the entity who requests it
     self.conveyerMover=ConveyerMover(self)      #process that is triggered at the times when an entity reached the end or
                                                 #a place is freed. It performs the move at this point, 
                                                 #so if there are actions to be carried they will
     self.call=False                             #flag that shows if the ConveyerMover should be triggered
     self.entityLastReachedEnd=None              #the entity that last reached the end of the conveyer
     self.timeBlockageStarted=now()              #the time that the conveyer reached the blocked state
                                                 #plant considers the conveyer blocked even if it can accept just one entity
                                                 #I think this is false 
     self.wasFull=False                          #flag that shows if the conveyer was full. So when an entity is disposed
                                                 #if this is true we count the blockage time and set it to false
     self.currentRequestedLength=0               #the length of the entity that last requested the conveyer
     self.currentAvailableLength=self.length     #the available length in the end of the conveyer
     
     self.predecessorIndex=0     #holds the index of the predecessor from which the Conveyer will take an entity next
     self.successorIndex=0       #holds the index of the successor where the Queue Conveyer dispose an entity next       
Example #20
0
    def __init__(self, sim, name="SPNP", tasks=list()):

        assert sim != None
        Process.__init__(self, name=name, sim=sim)

        # list of pending activations
        self.pending = list()

        # list of blocker activations (usually one lower priority activation)
        self.blockers = list()

        # list of simtasks
        self.simtasks = list()

        # signals a new activation
        self.arrival_event = SimEvent('Arrival Event', sim=sim)
 def __init__(self, max_wait, instance_type, latency, period, breach_duration, min_size, max_size, cooldown, lower_threshold, lower_breach_scale_increment, upper_threshold, upper_breach_scale_increment):
     Process.__init__(self, 'Watcher')
     self.max_wait = max_wait
     self.instance_type = instance_type
     self.latency = latency
     #
     # aws autoscale settings
     #
     self.period = period
     self.breach_duration = breach_duration
     self.min_size = min_size
     self.max_size = max_size
     self.cooldown = cooldown
     self.lower_threshold = lower_threshold
     self.lower_breach_scale_increment = lower_breach_scale_increment
     self.upper_threshold = upper_threshold
     self.upper_breach_scale_increment = upper_breach_scale_increment
    def __init__(self, sim, part_info):
        """
        Args:

        - `sim`: :class:`Model <simso.core.Model>` instance.
        - `part_info`: A :class:`TimePartitionInfo` representing the TimePartition.

        :type sim: Model
        :type task_info: TimePartitionInfo
        """
        Process.__init__(self, name=part_info.name, sim=sim)
        self.name = part_info.name
        self._part_info = part_info
        self._monitor = Monitor(name="Monitor" + self.name + "_states",
                                sim=sim)
        self._activations_fifo = deque([])
        self._sim = sim
        self.cpus = []
        self._etm = sim.etm
        self._last_cpus = None
        self._inst_count = 0
        self._insts = []
        self.inst = None
        self._task_evts = {}
        self._sched_info = part_info.task_scheduler_info
                        
        """
        This structure keeps track of which job is running on each cpu of
        a partition

        """
        self.running_jobs = {}

        # Create tasks for this partition
        self._tasks = []
        for task_info in part_info.task_infos:
            task = Task(sim, task_info)
            task.set_time_partition(self)
            self._tasks.append(task)
            sim.task_list.append(task)

        
        # Is budget donation active for this partition?
        self.can_donate = False
        if 'can_donate' in part_info.data:
            self.can_donate = part_info.data['can_donate']
Example #23
0
    def start(self, sem=None, **kwargs):
        """Overloaded start to go to initial state.

        :param sem: State execution method.
        :param kwargs: Keyword arguments passed to `Process.start()`.

        State execution method (SEM) is a function that takes a `FSM` as its
        first argument. This function is like a Process execution method (PEM)
        in SimPy, but meant to be used exclusively with `FSM`.
        """
        if self.started: return
        assert ('pem' not in kwargs)
        if sem: self.__initstate = sem, (), {}
        # set initial state and start FSM
        ns, sargs, swargs = self.__initstate
        self.__started = True
        self.goto(ns, *sargs, **swargs)
        Process.start(self, pem=self.sem, **kwargs)
Example #24
0
 def __init__(self, stopwatch_seconds=60):
     Process.__init__(self)
     self.stopwatch_seconds = stopwatch_seconds
     tk = world().tk
     canvas, x_, y_ = tk.canvas, tk.x_, tk.y_
     cx, cy = 27, 136
     self.cx, self.cy = cx, cy
     canvas.create_oval(x_(cx - 5), y_(cy - 5), x_(cx + 5), y_(cy + 5), fill='white')
     steps = 60
     if stopwatch_seconds == 60:
         steps = 5
     for ii in range(0, stopwatch_seconds, steps):
         inner_radius = 4.2
         if steps == 5 and ii % 15 in (5, 10):
             inner_radius = 4.6
         radians = self.seconds_to_radians(ii)
         canvas.create_line(x_(cx + cos(radians) * inner_radius), y_(cy + sin(radians) * inner_radius),
                            x_(cx + cos(radians) * 5), y_(cy + sin(radians) * 5))
     self.hand = canvas.create_line(0, 0, 1, 1)
Example #25
0
    def __init__(self, task, name, pred, monitor, etm, sim, jobid, optional_part=False, override_wcet=None):
        """
        Args:
            - `task`: The parent :class:`task <simso.core.Task.Task>`.
            - `name`: The name for this job.
            - `pred`: If the task is not periodic, pred is the job that \
            released this one.
            - `monitor`: A monitor is an object that log in time.
            - `etm`: The execution time model.
            - `sim`: :class:`Model <simso.core.Model>` instance.

        :type task: GenericTask
        :type name: str
        :type pred: bool
        :type monitor: Monitor
        :type etm: AbstractExecutionTimeModel
        :type sim: Model
        """
        Process.__init__(self, name=name, sim=sim)
        self._task = task
        self._pred = pred
        self.instr_count = 0  # Updated by the cache model.
        self._computation_time = 0
        self._last_exec = None
        self._n_instr = task.n_instr
        self._start_date = None
        self._end_date = None
        self._is_preempted = False
        self._activation_date = self.sim.now_ms()
        self._absolute_deadline = self.sim.now_ms() + task.deadline
        self._aborted = False
        self._sim = sim
        self._monitor = monitor
        self._etm = etm
        self._was_running_on = task.cpu
        self.jobid = jobid
        self.timer_deadline = None
        self.optional_part = optional_part
        self.override_wcet = override_wcet

        self._on_activate()

        self.context_ok = True  # The context is ready to be loaded.
 def initialize(self, identifier, simInstance, peer=None, priority=0):
     """
     Initializes the object.
     @param identifier: identifier of simulation event
     @type identifier: str
     @param peerId: peerId of simulation event
     @type peerId: int
     @param priority: priority of simulation event.
     @type priority: int
     @rtype: None
     @note: All simulation events are initialized as unhandled.
     """
     
     Process.__init__(self, identifier,simInstance)
     
     self.__identifier = identifier
     self.__peer = peer
     self.__priority = priority
     self.__isIdentified = False
     SimulationProcessLogger().resgiterLoggingInfo("Initialize Simulation Process => %s"%self.__identifier)
Example #27
0
 def __init__(self, model, proc_info):
     Process.__init__(self, name=proc_info.name, sim=model)
     self._model = model
     self._internal_id = Processor._identifier
     Processor._identifier += 1
     self.identifier = proc_info.identifier
     self._running = None
     self.was_running = None
     self._evts = deque([])
     self.sched = model.scheduler
     self.monitor = Monitor(name="Monitor" + proc_info.name, sim=model)
     self._caches = []
     self._penalty = proc_info.penalty
     self._cs_overhead = proc_info.cs_overhead
     self._cl_overhead = proc_info.cl_overhead
     self._migration_overhead = proc_info.migration_overhead
     self.set_caches(proc_info.caches)
     self.timer_monitor = Monitor(name="Monitor Timer" + proc_info.name,
                                  sim=model)
     self._speed = proc_info.speed
Example #28
0
 def stored(self, buffer):
     """Overload to clear `eventsFired` when successfully stored."""
     test = self in buffer.putQ  # test = True -> put failed
     try:
         a = Process.stored(self, buffer)
     except AttributeError:
         # put action completed AND there was no renege clause
         errmsg = "[FSM]: Unexpected failure in stored()!"
         assert (not test), errmsg
         a = not test
     if a: self.eventsFired = []
     return a
Example #29
0
 def __init__(self, id, name, **kw):
     Process.__init__(self) 
     self.id = id
     self.objName = name
     #     lists that hold the previous and next objects in the flow
     self.next=[]                                #list with the next objects in the flow
     self.previous=[]                            #list with the previous objects in the flow
     self.nextIds=[]                             #list with the ids of the next objects in the flow
     self.previousIds=[]                         #list with the ids of the previous objects in the flow
     
     self.Failure=[]
     self.Working=[]
     self.Blockage=[]
     self.Waiting=[]
     self.OffShift=[]
     
     #default attributes set so that the CoreObject has them
     self.isPreemptive=False
     self.resetOnPreemption=False
     self.interruptCause=None
     self.gatherWipStat=False
Example #30
0
 def __init__(self, interval, name=None,
              until=infinite, drift=('fixed', 0)):
     Process.__init__(self)
     self.interval = interval
     if name is not None:
         eventname = name
     else:
         eventname = "a_SimEvent"
     self.event = SimEvent(eventname)
     self.until = until
     try:
         key, mean, cfg = drift
     except ValueError:
         key, mean = drift
         cfg = {}
     lb = cfg.get('lb', 0); ub = cfg.get('ub', interval)
     if lb < 0: raise ValueError('drift lb = %s >= 0' %lb)
     if ub > interval:
         raise ValueError('drift ub = %s < %s = interval' %interval)
     cfg['lb'] = lb; cfg['ub'] = ub
     self.rgen = RandInterval.get(key, mean, cfg)
Example #31
0
    def __init__(self, task, name, pred, monitor, etm, sim, wcet=None):
        """
        Args:
            - `task`: The parent :class:`task <simso.core.Task.Task>`.
            - `name`: The name for this job.
            - `pred`: If the task is not periodic, pred is the job that \
            released this one.
            - `monitor`: A monitor is an object that log in time.
            - `etm`: The execution time model.
            - `sim`: :class:`Model <simso.core.Model>` instance.

        :type task: GenericTask
        :type name: str
        :type pred: bool
        :type monitor: Monitor
        :type etm: AbstractExecutionTimeModel
        :type sim: Model
        """
        Process.__init__(self, name=name, sim=sim)
        self._task = task
        self._pred = pred
        self.instr_count = 0  # Updated by the cache model.
        self._computation_time = 0
        self._last_exec = None
        self._n_instr = task.n_instr
        self._start_date = None
        self._end_date = None
        self._is_preempted = False
        self._activation_date = self.sim.now_ms()
        self._absolute_deadline = self.sim.now_ms() + task.deadline
        self._aborted = False
        self._sim = sim
        self._monitor = monitor
        self._etm = etm
        self._was_running_on = task.cpu
        self._wcet = wcet

        self._on_activate()

        self.context_ok = True  # The context is ready to be loaded.
Example #32
0
    def __init__(self,**args):
        defaults={'sim':None,
                  'net': Network(),
                  'gcom': Gcom(),
                  'ID': 0,
                  'dcond':{},
                  'devt': {},
                  'lcst': []
                  }
##       initialize attributes
        for key, value in defaults.items():
            if args.has_key(key):

                setattr(self, key, args[key])
            else:
                setattr(self, key, value)
                args[key]=value  
        self.args=args
        self.PN=self.net.node[self.ID]['PN']
        self.evt_create()
        self.c_init()
        Process.__init__(self,name='Tx'+str(self.ID),sim=self.sim)
Example #33
0
    def __init__(self, initstate=None, start=False, **kwargs):
        """Constructor.

        :param initstate: Initial state to `goto`.
        :param start: Boolean; if true, `start()` immediately.
        :param kwargs: Keywords passed to `Traceable` constructor.
        """
        Traceable.__init__(self, **kwargs)
        Process.__init__(self, name=self.name)
        self.__sem = None
        self.__state = None
        self.__started = False
        self.__initstate = self.HALT, (), {}
        # patch SimPy to fix hold
        if not FSM._fixsimhold:
            self.sim._dispatch[fsmhold] = fsmholdfunc
            self.sim._commandcodes = self.sim._dispatch.keys()
            self.sim._commandwords[fsmhold] = 'fsmhold'
            self.sim.reactivate = lambda *args, **kwargs: _fixreactivate(self.sim, *args, **kwargs)
            FSM._fixsimhold = True
        # continue initializing FSM
        if initstate: self.goto(initstate)
        if start: self.start()
Example #34
0
    def __init__(self, **args):

        defaults = {"net": None, "fname": "table", "lAg": None, "fig": None, "ax": None, "sim": None}

        ##       initialize attributes
        for key, value in defaults.items():
            if key in args:
                setattr(self, key, args[key])
            else:
                setattr(self, key, value)
                args[key] = value
        self.args = args
        self.fname = self.args["fname"]

        self.fig = plt.figure(self.fname, figsize=(30, 15), dpi=50)
        self.fig.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.1)
        self.ax1 = self.fig.add_subplot(111, frame_on=False)
        self.ax1.xaxis.set_visible(False)
        self.ax1.yaxis.set_visible(False)

        self.fig2 = plt.figure(self.fname + str(2), figsize=(30, 15), dpi=50)
        self.ax2 = self.fig2.add_subplot(111, frame_on=False)
        self.ax2.xaxis.set_visible(False)
        self.ax2.yaxis.set_visible(False)

        self.coll_plot = {}
        self.colLabels1 = ("RAT", "Node link", "TOA ", "TOA std", "Pr", "Pr std", "distance")
        self.colLabels2 = ("name", "pos x", "pos y ", "vel x", "vel y", "acc x", "acc y")
        self.cellText = []
        self.C = ConfigParser.ConfigParser()
        self.C.read(pyu.getlong("show.ini", "ini"))
        self.RATcolor = dict(self.C.items("RATcolor"))
        self.RATes = dict(self.C.items("RATestyle"))
        self.update = dict(self.C.items("update"))

        Process.__init__(self, name="PShowTable", sim=self.args["sim"])
Example #35
0
 def acquired(self, buf):
     """Overload to clear `eventsFired` when successfully acquired."""
     try:
         a = Process.acquired(self, buf)
     except AttributeError:
         # get action completed AND there was no renege clause
         if isinstance(buf, Resource): test = self in buf.activeQ
         elif isinstance(buf, Store):  test = len(self.got)
         elif isinstance(buf, Level):  test = not (self.got is None)
         else:                         test = False
         errmsg = "[FSM]: Unexpected failure in acquired()!"
         assert (test), errmsg
         a = test
     if a: self.eventsFired = []
     return a
Example #36
0
 def __init__(self, name):
     Process.__init__(self, name)
Example #37
0
 def __init__(self, lives=1, name='ImaTarget'):
     Process.__init__(self, name)
     self.lives = lives
     # provide Player objects with a "damage" property
     self.damage = 0
Example #38
0
 def __init__(self, myBus):
     Process.__init__(self, name='Breakdown ' + myBus.name)
     self.bus = myBus
Example #39
0
 def __init__(self, epidemic, ind_id, health_status='susceptible'):
     Process.__init__(self)
     self.ind_id = ind_id
     self.e = epidemic
     self.health_status = health_status
     self.e.all_individuals.append(self)
Example #40
0
 def __init__(self, name, cc):
     Process.__init__(self, name=name)
     self.cc = cc
Example #41
0
 def __init__(self, name):
     Process.__init__(self, name=name)
     self.doneSignal = SimEvent()
Example #42
0
 def __init__(self, i, len):
     Process.__init__(self, name='Message' + str(i))
     self.i = i
     self.len = len
Example #43
0
 def initialize(self):
     Process.__init__(self)
Example #44
0
 def __init__(self, simulation, burst_id, burst_size, burst_header_offset):
     Process.__init__(self, sim=simulation)
     self.id = burst_id
     self.burst_size = burst_size
     self.offset = burst_header_offset
Example #45
0
    def initialize(self):
        # XXX why call super.__init__ outside of __init__ ?
        Process.__init__(self) 
        self.Up=True                                    #Boolean that shows if the machine is in failure ("Down") or not ("up")
        self.onShift=True
        self.currentEntity=None      
        # ============================== total times ===============================================
        self.totalBlockageTime=0                        #holds the total blockage time
        self.totalFailureTime=0                         #holds the total failure time
        self.totalWaitingTime=0                         #holds the total waiting time
        self.totalWorkingTime=0                         #holds the total working time
        self.totalOffShiftTime=0                        #holds the total off-shift time
        self.completedJobs=0                            #holds the number of completed jobs 
        # ============================== Entity related attributes =================================
        self.timeLastEntityEnded=0                      #holds the last time that an entity ended processing in the object
        self.nameLastEntityEnded=""                     #holds the name of the last entity that ended processing in the object
        self.timeLastEntityEntered=0                    #holds the last time that an entity entered in the object
        self.nameLastEntityEntered=""                   #holds the name of the last entity that entered in the object

        # ============================== shift related times =====================================
        self.timeLastShiftStarted=0                     #holds the time that the last shift of the object started
        self.timeLastShiftEnded=0                       #holds the time that the last shift of the object ended
        self.offShiftTimeTryingToReleaseCurrentEntity=0 #holds the time that the object was off-shift while trying 
                                                        #to release the current entity  
        # ============================== failure related times =====================================
        self.timeLastFailure=0                          #holds the time that the last failure of the object started
        self.timeLastFailureEnded=0                     #holds the time that the last failure of the object ended
        self.downTimeProcessingCurrentEntity=0          #holds the time that the machine was down while 
                                                        #processing the current entity
        self.downTimeInTryingToReleaseCurrentEntity=0   #holds the time that the object was down while trying 
                                                        #to release the current entity                                                          
        self.downTimeInCurrentEntity=0                  #holds the total time that the 
                                                        #object was down while holding current entity
        self.timeLastEntityLeft=0                       #holds the last time that an entity left the object
        
        self.processingTimeOfCurrentEntity=0            #holds the total processing time that the current entity required                                               
        # ============================== waiting flag ==============================================                                      
        self.waitToDispose=False                        #shows if the object waits to dispose an entity   

        # ============================== the below are currently used in Jobshop =======================   
        self.giver=None                                 #the CoreObject that the activeObject will take an Entity from
        if len(self.previous)>0:
            self.giver=self.previous[0]
        self.receiver=None                              #the CoreObject that the activeObject will give an Entity to
        if len(self.next)>0:
            self.receiver=self.next[0]
        # ============================== variable that is used for the loading of machines =============
        self.exitAssignedToReceiver = False             # by default the objects are not blocked 
                                                        # when the entities have to be loaded to operatedMachines
                                                        # then the giverObjects have to be blocked for the time
                                                        # that the machine is being loaded 
        # ============================== lists to hold statistics of multiple runs =====================
        self.totalTimeWaitingForOperator=0 
        self.operatorWaitTimeCurrentEntity=0 
        self.totalTimeInCurrentEntity=0
        self.operatorWaitTimeCurrentEntity=0
        self.totalProcessingTimeInCurrentEntity=0
        self.failureTimeInCurrentEntity=0
        self.setupTimeCurrentEntity=0
 
        self.shouldPreempt=False    #flag that shows that the machine should preempt or not
        
        self.lastGiver=None         # variable that holds the last giver of the object, used by machine in case of preemption    
        # initialize the wipStatList - 
        # TODO, think what to do in multiple runs
        # TODO, this should be also updated in Globals.setWIP (in case we have initial wip)
        self.wipStatList=[[0,0]]
Example #46
0
 def __init__(self):
     Process.__init__(self)
Example #47
0
 def __init__(self):
     Process.__init__(self)
     self.prts = []