Debug inteferences

esds/simulator.py

@@ -19,10 +19,10 @@ class Simulator:
     Very important notes: 
     - When the simulator wakes up a node (changing is state to running) data that should be received by that node 
     on the current simulated time SHOULD be in the queue! Thus, the send event must be handle before the other event (priority equals to 1). 
-    Otherwise plugings such as the power states one may not gives accurate results because of missing entries in the nodes received queues.
+    Otherwise plugins such as the power states one may not gives accurate results because of missing entries in the nodes received queues.
     - The state of a node should always be updated (e.g node["state"]="running") BEFORE updating its 
     queue (e.g node.rqueue.put(("timeout_remove",0))
-    - Notify as the same behavior as timeout. Except it has the highest priority among all the events! This is particularly usefull for wait events which SHOULD
+    - Notify as the same behavior as timeout. Except it has the highest priority among all the events! This is particularly useful for wait events which SHOULD
     be handle before any other one. That way after a wait, nodes a ready perform receivet() with timeout=0.
     """
     
@@ -30,8 +30,8 @@ class Simulator:
         """
         Format of netmat: { "interface": {"bandwidth": numpy_matrix_2D, "latency": numpy_matrix_2D, "is_wired":bool}}
         For wireless interfaces the diagonals of the bandwidth and latency matrices are very important.
-        They determine the duration of the tranmission for THE SENDER. It allows to have a different tx duration per node and per interface.
-        Thus, at each wireless communication, an addionnal event is created for the sender that corresponds to a send to himself (diagonals of the matrices) used
+        They determine the duration of the transmission for THE SENDER. It allows to have a different tx duration per node and per interface.
+        Thus, at each wireless communication, an additional event is created for the sender that corresponds to a send to himself (diagonals of the matrices) used
         to unlock him from the api.send() call. Consequently, the duration of the transmission (by the sender) can be 
         different from the time at which the receivers actually receive the data (non-diagonal entries of the matrices).
         """
@@ -258,8 +258,7 @@ class Simulator:
 
     def handle_interferences(self,sender,receiver, interface):
         """
-        Interferences are detected by looking for conflicts between
-        new events and existing events.
+        Interferences are detected by looking for conflicts between new events and existing events.
         """
         status=False
         for event in self.events:
@@ -269,24 +268,17 @@ class Simulator:
                 com_sender=int(com[0])
                 com_receiver=int(com[1])
                 #### All CASES WHERE INTERFERENCES OCCUR
-                # receiver_is_sending
-                # 1) check if current com receiver already sending
-                # 2) ensure not dealing with the special com (where sender is the receiver)
-                receiver_is_sending=(receiver==com_sender and sender!=receiver)
-                # receiver_is_receiving
-                # 1) check if the current com receiver is already receiving (thus interference)
-                # 2) ensure not dealing with the special com (where sender is the receiver)
-                receiver_is_receiving=(com_receiver==receiver and sender!=com_sender)
-                # sender_is_receiving
-                # 1) check if current com receiver is the one who started sending
-                # 2) ensure not dealing with the special com (where sender is the receiver)
-                sender_is_receiving=(com_receiver==sender and com_sender!=com_sender)
+                receiver_is_sending=(com_sender==receiver) # Check current communication events interfere with the one passed in function argument
+                receiver_is_receiving=(com_receiver==receiver) # Check if the current com receiver is already receiving
+                sender_is_receiving=(com_receiver==sender) # Check if current communication events receiver is the one who started sending
                 ##### Update com return code
                 if receiver_is_sending or receiver_is_receiving or sender_is_receiving:
-                    status=True # receiver_is_sending is handled by return code (see self.communicate())
-                    # In the following test, we ignore the receiver_is_sending (see comment line above)
+                    status=True
+                    # The receiver_is_sending case is handled by return code (see self.communicate())
                     # By ignoring receiver_is_sending, we solve the interferences_bug1 (see tests)
-                    if not receiver_is_sending and com_sender != com_receiver:
+                    if receiver_is_sending:
+                        continue
+                    elif com_sender != com_receiver:  # We ensure we are not updating the sender feedback event (the special event)
                         event[2][10]=RCode.INTERFERENCES # Tell the sender/receiver interferences occurred
         return status
     
@@ -306,7 +298,7 @@ class Simulator:
                 if code!=RCode.SUCCESS:
                     node["state"]="running"
                     node.rqueue.put(("send",code))
-                    # Do not forget to collect the next event (since current event did not happend)
+                    # Do not forget to collect the next event (since current event did not happened)
                     # Be careful in node implementation to have no infinite loop when receiver_required=True
                     self.sync_node_non_blocking(node)
                     self.sync_node_blocking(node)
@@ -345,6 +337,7 @@ class Simulator:
             self.add_event(0,duration+self.time,(src,dst,interface,data,datasize,duration,datasize,self.time,self.nodes[dst]["turned_on"],receiver_required,RCode.SUCCESS))
         else:
             self.log("Send "+str(datasize)+" bytes on "+interface,node=nsrc)
+            evtsToAdd=list() # We do not want to interfere with self.handle_interferences() as we check for them in the next for loop
             for dst in self.list_receivers(nsrc,interface):
                 if interface in self.nodes[dst]["interfaces"] and self.nodes[dst]["turned_on"]:
                     duration=datasize*8/self.netmat[interface]["bandwidth"][src,dst]+self.netmat[interface]["latency"][src,dst]
@@ -354,9 +347,12 @@ class Simulator:
                     if src == dst:
                         # This event (where src == dst) is used to notify the sender when data is received!
                         # Correspond to the diagonal of the network matrices (bandwidth and latency)
-                        self.add_event(0,duration+self.time,(src,dst,interface,data,datasize,duration,datasize,self.time,True,False,RCode.SUCCESS))
+                        evtsToAdd.append((0,duration+self.time,(src,dst,interface,data,datasize,duration,datasize,self.time,True,False,RCode.SUCCESS)))
                     else:
-                        self.add_event(0,duration+self.time,(src,dst,interface,data,datasize,duration,datasize,self.time,True,False,rcode))
+                        evtsToAdd.append((0,duration+self.time,(src,dst,interface,data,datasize,duration,datasize,self.time,True,False,rcode)))
+            # Now we can actually add events
+            for e in evtsToAdd:
+                self.add_event(*e)
         return(RCode.SUCCESS)
     def list_receivers(self,node,interface):
         """