# Event Latency

Covers:

- Resources: Store

This example shows how to separate the time delay of events between processes from the processes themselves.

When Useful:

  When modeling physical things such as cables, RF propagation, etc. it better encapsulation to keep this propagation mechanism outside of the sending and receiving processes.

  Can also be used to interconnect processes sending messages

Example by:

  Keith Smith

    """
    Event Latency example

    Covers:

    - Resources: Store

    Scenario:
      This example shows how to separate the time delay of events between
      processes from the processes themselves.

    When Useful:
      When modeling physical things such as cables, RF propagation, etc.  it
      better encapsulation to keep this propagation mechanism outside of the
      sending and receiving processes.

      Can also be used to interconnect processes sending messages

    Example by:
      Keith Smith

    """
    import simpy

    SIM_DURATION = 100

    class Cable:
        """This class represents the propagation through a cable."""

        def __init__(self, env, delay):
            self.env = env
            self.delay = delay
            self.store = simpy.Store(env)

        def latency(self, value):
            yield self.env.timeout(self.delay)
            self.store.put(value)

        def put(self, value):
            self.env.process(self.latency(value))

        def get(self):
            return self.store.get()

    def sender(env, cable):
        """A process which randomly generates messages."""
        while True:
            # wait for next transmission
            yield env.timeout(5)
            cable.put(f'Sender sent this at {env.now}')

    def receiver(env, cable):
        """A process which consumes messages."""
        while True:
            # Get event for message pipe
            msg = yield cable.get()
            print(f'Received this at {env.now} while {msg}')

    # Setup and start the simulation
    print('Event Latency')
    env = simpy.Environment()

    cable = Cable(env, 10)
    env.process(sender(env, cable))
    env.process(receiver(env, cable))

    env.run(until=SIM_DURATION)

The simulation’s output:

    Event Latency
    Received this at 15 while Sender sent this at 5
    Received this at 20 while Sender sent this at 10
    Received this at 25 while Sender sent this at 15
    Received this at 30 while Sender sent this at 20
    Received this at 35 while Sender sent this at 25
    Received this at 40 while Sender sent this at 30
    Received this at 45 while Sender sent this at 35
    Received this at 50 while Sender sent this at 40
    Received this at 55 while Sender sent this at 45
    Received this at 60 while Sender sent this at 50
    Received this at 65 while Sender sent this at 55
    Received this at 70 while Sender sent this at 60
    Received this at 75 while Sender sent this at 65
    Received this at 80 while Sender sent this at 70
    Received this at 85 while Sender sent this at 75
    Received this at 90 while Sender sent this at 80
    Received this at 95 while Sender sent this at 85