Extract code to graphs module

Signed-off-by: Andres Correa Casablanca <[email protected]>

Author: Andres Correa Casablanca

experiments/forking_simulation.py

@@ -65,9 +65,7 @@
 import test_framework.util as tf_util
 
 from experiments.graph import (
-    enforce_nodes_reconnections,
-    ensure_one_inbound_connection_per_node,
-    create_directed_graph,
+    create_network_graph,
     create_simple_dense_graph
 )
 from network.latencies import StaticLatencyPolicy
@@ -505,26 +503,11 @@ def define_network_topology(self, graph_model: str):
         """This function defines the network's topology"""
 
         self.logger.info('Defining network graph')
-
-        graph_edges, inbound_degrees = create_directed_graph(
+        self.graph_edges = create_network_graph(
             num_nodes=self.num_nodes,
             num_outbound_connections=NUM_OUTBOUND_CONNECTIONS,
             max_inbound_connections=NUM_INBOUND_CONNECTIONS,
-            model=graph_model
-        )
-
-        # We try to avoid having sink sub-graphs
-        graph_edges, inbound_degrees = enforce_nodes_reconnections(
-            graph_edges=graph_edges,
-            inbound_degrees=inbound_degrees,
-            num_reconnection_rounds=1,
-        )
-
-        # This fix the rare case where some nodes don't have inbound connections
-        self.graph_edges, _ = ensure_one_inbound_connection_per_node(
-            num_nodes=self.num_nodes,
-            graph_edges=graph_edges,
-            inbound_degrees=inbound_degrees,
+            graph_model=graph_model
         )
 
 

experiments/graph.py

@@ -213,6 +213,41 @@ def create_simple_dense_graph(
     return directed_edges
 
 
+def create_network_graph(
+    num_nodes: int,
+    num_outbound_connections: int,
+    max_inbound_connections: int,
+    graph_model: str = 'preferential_attachment',
+) -> Set[Tuple[int, int]]:
+    """
+    This function creates a graph ensuring that it holds some properties that
+    makes it suitable to represent a Unit-e network's topology without isolated
+    nor sink nodes.
+    """
+    graph_edges, inbound_degrees = create_directed_graph(
+        num_nodes=num_nodes,
+        num_outbound_connections=num_outbound_connections,
+        max_inbound_connections=max_inbound_connections,
+        model=graph_model
+    )
+
+    # We try to avoid having sink sub-graphs
+    graph_edges, inbound_degrees = enforce_nodes_reconnections(
+        graph_edges=graph_edges,
+        inbound_degrees=inbound_degrees,
+        num_reconnection_rounds=1,
+    )
+
+    # This fix the rare case where some nodes don't have inbound connections
+    graph_edges, _ = ensure_one_inbound_connection_per_node(
+        num_nodes=num_nodes,
+        graph_edges=graph_edges,
+        inbound_degrees=inbound_degrees,
+    )
+
+    return graph_edges
+
+
 def enforce_nodes_reconnections(
         graph_edges: Set[Tuple[int, int]],
         inbound_degrees: Dict[int, int],

test/experiments/test_graph.py

@@ -13,6 +13,7 @@
     create_simple_dense_graph,
     create_static_graph,
     create_growing_graph,
+    create_network_graph,
     create_preferential_attachment_graph,
     degrees_distribution,
     enforce_nodes_reconnections,
@@ -206,3 +207,31 @@ def test_create_simple_dense_graph():
             assert len({
                 (i, j) for i, j in graph if i == node_id
             }) == min(len(node_ids) - 1, outbound_degree)
+
+
+def test_create_network_graph():
+    for _ in range(10):
+        # Execute multiple times to take into account the randomness effects.
+        graph_edges = create_network_graph(
+            num_nodes=100,
+            num_outbound_connections=8,
+            max_inbound_connections=125,
+            graph_model='preferential_attachment'
+        )
+
+        # First, we'll check that every node has 8 outbound connections
+        outbound_peers_by_node = {
+            src: {dst for _src, dst in graph_edges if _src == src}
+            for src in {_src for _src, _dst in graph_edges}
+        }
+        for outbound_peers in outbound_peers_by_node.values():
+            assert 8 == len(outbound_peers)
+
+        # Second, we'll check that every node hast at least 1 inbound
+        # connection, and at most 125 inbound connections
+        inbound_peers_by_node = {
+            dst: {src for src, _dst in graph_edges if _dst == dst}
+            for dst in {_dst for _src, _dst in graph_edges}
+        }
+        for inbound_peers in inbound_peers_by_node.values():
+            assert 1 <= len(inbound_peers) <= 125