Skip to content

Timer

gradysim.simulator.handler.timer.TimerHandler

Bases: INodeHandler

Adds timers to the simulation. This allows nodes to set timers which is a very important feature when implementing distributed algorithms. Nodes can schedule timers through their providers.

Source code in gradysim/simulator/handler/timer.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
class TimerHandler(INodeHandler):
    """
    Adds timers to the simulation. This allows nodes to set timers
    which is a very important feature when implementing distributed
    algorithms. Nodes can schedule timers through their providers.
    """
    _event_loop: EventLoop

    _timer_id: int
    _pending_timers: Dict[int, Dict[str, Set[int]]]
    """Timers pending for each node. A dict of nodes where the value is a dict of messages and their identifiers."""

    def __init__(self):
        """
        Constructs a TimerHandler, no configuration is necessary.
        """
        self._registed_nodes: Set[Node] = set()
        self._timer_id = 0
        self._pending_timers = defaultdict(lambda : defaultdict(set))

    def get_current_time(self):
        return self._event_loop.current_time

    @staticmethod
    def get_label() -> str:
        return "timer"

    def inject(self, event_loop: EventLoop) -> None:
        self._event_loop = event_loop

    def register_node(self, node: Node) -> None:
        self._registed_nodes.add(node)

    def fire_timer(self, message: str, node: Node, identifier: int):
        """
        Fires a timer. Should be called by the event loop.
        """
        if identifier not in self._pending_timers[node.id][message]:
            return

        node.protocol_encapsulator.handle_timer(message)
        self._pending_timers[node.id][message].remove(identifier)

    def set_timer(self, message: str, timestamp: float, node: Node):
        """
        Sets a timer. Should be called by the nodes' providers. Node needs to be
        registered and timer needs to be set in the future.
        """
        if node not in self._registed_nodes:
            raise TimerException(f"Could not set timer: Node {node.id} not registered")

        if timestamp < self._event_loop.current_time:
            raise TimerException("Could not set timer: Timer cannot be set in the past")

        identifier = self._timer_id
        self._event_loop.schedule_event(timestamp,
                                        lambda: self.fire_timer(message, node, identifier),
                                        label_node(node) + " handle_timer")
        self._pending_timers[node.id][message].add(identifier)
        self._timer_id += 1

    def cancel_timer(self, message: str, node: Node):
        """
        Cancels a timer. Should be called by the nodes' providers. Node needs to be
        registered.
        """
        if node not in self._registed_nodes:
            raise TimerException(f"Could not cancel timer: Node {node.id} not registered")

        self._pending_timers[node.id][message].clear()

__init__()

Constructs a TimerHandler, no configuration is necessary.

Source code in gradysim/simulator/handler/timer.py 
26
27
28
29
30
31
32
def __init__(self):
    """
    Constructs a TimerHandler, no configuration is necessary.
    """
    self._registed_nodes: Set[Node] = set()
    self._timer_id = 0
    self._pending_timers = defaultdict(lambda : defaultdict(set))

cancel_timer(message, node)

Cancels a timer. Should be called by the nodes' providers. Node needs to be registered.

Source code in gradysim/simulator/handler/timer.py 
75
76
77
78
79
80
81
82
83
def cancel_timer(self, message: str, node: Node):
    """
    Cancels a timer. Should be called by the nodes' providers. Node needs to be
    registered.
    """
    if node not in self._registed_nodes:
        raise TimerException(f"Could not cancel timer: Node {node.id} not registered")

    self._pending_timers[node.id][message].clear()

fire_timer(message, node, identifier)

Fires a timer. Should be called by the event loop.

Source code in gradysim/simulator/handler/timer.py 
47
48
49
50
51
52
53
54
55
def fire_timer(self, message: str, node: Node, identifier: int):
    """
    Fires a timer. Should be called by the event loop.
    """
    if identifier not in self._pending_timers[node.id][message]:
        return

    node.protocol_encapsulator.handle_timer(message)
    self._pending_timers[node.id][message].remove(identifier)

set_timer(message, timestamp, node)

Sets a timer. Should be called by the nodes' providers. Node needs to be registered and timer needs to be set in the future.

Source code in gradysim/simulator/handler/timer.py 
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
def set_timer(self, message: str, timestamp: float, node: Node):
    """
    Sets a timer. Should be called by the nodes' providers. Node needs to be
    registered and timer needs to be set in the future.
    """
    if node not in self._registed_nodes:
        raise TimerException(f"Could not set timer: Node {node.id} not registered")

    if timestamp < self._event_loop.current_time:
        raise TimerException("Could not set timer: Timer cannot be set in the past")

    identifier = self._timer_id
    self._event_loop.schedule_event(timestamp,
                                    lambda: self.fire_timer(message, node, identifier),
                                    label_node(node) + " handle_timer")
    self._pending_timers[node.id][message].add(identifier)
    self._timer_id += 1