experiments: reformat python code

experiments/pyexps/e2e_automatic_split.py

@@ -22,12 +22,12 @@
 
 import typing as tp
 
+import simbricks.orchestration.e2e_components as e2e
 import simbricks.orchestration.experiments as exp
 import simbricks.orchestration.nodeconfig as node
 import simbricks.orchestration.simulators as sim
-import simbricks.orchestration.e2e_components as e2e
-from simbricks.orchestration.simulator_utils import create_tcp_cong_hosts
 from simbricks.orchestration.e2e_helpers import E2ELinkAssigner, E2ELinkType
+from simbricks.orchestration.simulator_utils import create_tcp_cong_hosts
 
 mtu = 1500
 congestion_control = e2e.CongestionControl.CUBIC

experiments/pyexps/e2e_cc.py

@@ -20,12 +20,12 @@
 # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+import simbricks.orchestration.e2e_components as e2e
 import simbricks.orchestration.experiments as exp
 import simbricks.orchestration.nodeconfig as node
 import simbricks.orchestration.simulators as sim
-import simbricks.orchestration.e2e_components as e2e
-from simbricks.orchestration.simulator_utils import create_tcp_cong_hosts
 from simbricks.orchestration.e2e_topologies import E2EDumbbellTopology
+from simbricks.orchestration.simulator_utils import create_tcp_cong_hosts
 
 # iperf TCP_multi_client test
 # naming convention following host-nic-net-app
@@ -48,9 +48,9 @@ num_simbricks_hosts = 1
 #max_k = 199680
 #k_step = 16640
 #k_step = 33280
-link_rate = 200 # in Mbps
-link_latency = 5 # in ms
-bdp = int(link_rate * link_latency / 1000 * 10**6) # Bandwidth-delay product
+link_rate = 200  # in Mbps
+link_latency = 5  # in ms
+bdp = int(link_rate * link_latency / 1000 * 10**6)  # Bandwidth-delay product
 cpu_freq = '5GHz'
 cpu_freq_qemu = '2GHz'
 sys_clock = '1GHz'  # if not set, default 1GHz
@@ -160,7 +160,7 @@ for congestion_control in types_of_congestion_control:
                 freq,
                 mtu,
                 congestion_control.gem5,
-                ip_start=2*num_ns3_hosts + num_simbricks_hosts + 1
+                ip_start=2 * num_ns3_hosts + num_simbricks_hosts + 1
             )
 
             for i, server in enumerate(servers, 1):

experiments/pyexps/e2e_split.py

@@ -20,10 +20,10 @@
 # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+import simbricks.orchestration.e2e_components as e2e
 import simbricks.orchestration.experiments as exp
 import simbricks.orchestration.nodeconfig as node
 import simbricks.orchestration.simulators as sim
-import simbricks.orchestration.e2e_components as e2e
 from simbricks.orchestration.simulator_utils import create_tcp_cong_hosts
 
 # iperf TCP_multi_client test

experiments/simbricks/orchestration/e2e_components.py

@@ -29,23 +29,23 @@ from enum import Enum
 
 
 class CongestionControl(Enum):
-    RENO = ("ns3::TcpLinuxReno", "reno")
-    WESTWOOD = ("ns3::TcpWestwoodPlus", "westwood")
-    BIC = ("ns3::TcpBic", "bic")
-    CUBIC = ("ns3::TcpCubic", "cubic")
-    HTCP = ("ns3::TcpHtcp", "htcp")
-    HYBLA = ("ns3::TcpHybla", "hybla")
-    VEGAS = ("ns3::TcpVegas", "vegas")
-    NV = ("", "nv")
-    SCALABLE = ("ns3::TcpScalable", "scalable")
-    LP = ("ns3::TcpLp", "lp")
-    VENO = ("ns3::TcpVeno", "veno")
-    YEAH = ("ns3::TcpYeah", "yeah")
-    ILLINOIS = ("ns3::TcpIllinois", "illinois")
-    DCTCP = ("ns3::TcpDctcp", "dctcp")
-    CDG = ("", "cdg")
-    BBR = ("ns3::TcpBbr", "bbr")
-    HIGHSPEED = ("ns3::TcpHighSpeed", "highspeed")
+    RENO = ('ns3::TcpLinuxReno', 'reno')
+    WESTWOOD = ('ns3::TcpWestwoodPlus', 'westwood')
+    BIC = ('ns3::TcpBic', 'bic')
+    CUBIC = ('ns3::TcpCubic', 'cubic')
+    HTCP = ('ns3::TcpHtcp', 'htcp')
+    HYBLA = ('ns3::TcpHybla', 'hybla')
+    VEGAS = ('ns3::TcpVegas', 'vegas')
+    NV = ('', 'nv')
+    SCALABLE = ('ns3::TcpScalable', 'scalable')
+    LP = ('ns3::TcpLp', 'lp')
+    VENO = ('ns3::TcpVeno', 'veno')
+    YEAH = ('ns3::TcpYeah', 'yeah')
+    ILLINOIS = ('ns3::TcpIllinois', 'illinois')
+    DCTCP = ('ns3::TcpDctcp', 'dctcp')
+    CDG = ('', 'cdg')
+    BBR = ('ns3::TcpBbr', 'bbr')
+    HIGHSPEED = ('ns3::TcpHighSpeed', 'highspeed')
 
     def __init__(self, ns3_str, gem5_str):
         self.ns3_str = ns3_str
@@ -56,10 +56,10 @@ class CongestionControl(Enum):
 
     @property
     def ns3(self):
-        if self.ns3_str == "":
+        if self.ns3_str == '':
             raise AttributeError(
-                f"There is no ns3 implementation for "
-                f"{self.name} available"
+                f'There is no ns3 implementation for '
+                f'{self.name} available'
             )
         return self.ns3_str
 
@@ -81,25 +81,25 @@ class SimbricksSyncMode(Enum):
 
 
 class Ns3LoggingLevel(Enum):
-    ERROR = "error"
-    LEVEL_ERROR = "level_error"
-    WARN = "warn"
-    LEVEL_WARN = "level_warn"
-    DEBUG = "debug"
-    LEVEL_DEBUG = "level_debug"
-    INFO = "info"
-    LEVEL_INFO = "level_info"
-    FUNCTION = "function"
-    LEVEL_FUNCTION = "level_function"
-    LOGIC = "logic"
-    LEVEL_LOGIC = "level_logic"
-    ALL = "all"
-    LEVEL_ALL = "level_all"
-    PREFIX_FUNC = "prefix_func"
-    PREFIX_TIME = "prefix_time"
-    PREFIX_NODE = "prefix_node"
-    PREFIX_LEVEL = "prefix_level"
-    PREFIX_ALL = "prefix_all"
+    ERROR = 'error'
+    LEVEL_ERROR = 'level_error'
+    WARN = 'warn'
+    LEVEL_WARN = 'level_warn'
+    DEBUG = 'debug'
+    LEVEL_DEBUG = 'level_debug'
+    INFO = 'info'
+    LEVEL_INFO = 'level_info'
+    FUNCTION = 'function'
+    LEVEL_FUNCTION = 'level_function'
+    LOGIC = 'logic'
+    LEVEL_LOGIC = 'level_logic'
+    ALL = 'all'
+    LEVEL_ALL = 'level_all'
+    PREFIX_FUNC = 'prefix_func'
+    PREFIX_TIME = 'prefix_time'
+    PREFIX_NODE = 'prefix_node'
+    PREFIX_LEVEL = 'prefix_level'
+    PREFIX_ALL = 'prefix_all'
 
 
 class E2EBase(ABC):
@@ -112,16 +112,16 @@ class E2EBase(ABC):
     def ns3_config(self) -> str:
         config_list = []
         for key, value in self.mapping.items():
-            if value == "":
+            if value == '':
                 continue
-            config_list.append(f"{key}:{value}")
-        config = ";".join(config_list)
+            config_list.append(f'{key}:{value}')
+        config = ';'.join(config_list)
 
-        child_configs = " ".join([
+        child_configs = ' '.join([
             child.ns3_config() for child in self.components
         ])
 
-        return f"--{self.category}=\"{config}\" {child_configs}"
+        return f'--{self.category}="{config}" {child_configs}'
 
     @abstractmethod
     def add_component(self, component: E2EComponent) -> None:
@@ -132,13 +132,13 @@ class E2EGlobalConfig(E2EBase):
 
     def __init__(self) -> None:
         super().__init__()
-        self.category = "Global"
-        self.stop_time = ""
+        self.category = 'Global'
+        self.stop_time = ''
         self.mac_start = 0
 
     def ns3_config(self) -> str:
         self.mapping.update({
-            "StopTime": self.stop_time, "MACStart": str(self.mac_start)
+            'StopTime': self.stop_time, 'MACStart': str(self.mac_start)
         })
         return super().ns3_config()
 
@@ -150,12 +150,12 @@ class E2ENs3Logging(E2EBase):
 
     def __init__(self) -> None:
         super().__init__()
-        self.category = "Logging"
+        self.category = 'Logging'
         self.logging: tp.Dict[str, tp.List[Ns3LoggingLevel]] = {}
 
     def ns3_config(self) -> str:
         for component, levels in self.logging.items():
-            levels_str = "|".join([level.value for level in levels])
+            levels_str = '|'.join([level.value for level in levels])
             self.mapping.update([(component, levels_str)])
         return super().ns3_config()
 
@@ -176,12 +176,12 @@ class E2EComponent(E2EBase):
         self.name = idd
         self.id = idd
         self.has_path = False
-        self.type = ""
+        self.type = ''
 
     def ns3_config(self) -> str:
-        if self.id == "" or self.type == "":
-            raise AttributeError("Id or Type cannot be empty")
-        self.mapping.update({"Id": self.id, "Type": self.type})
+        if self.id == '' or self.type == '':
+            raise AttributeError('Id or Type cannot be empty')
+        self.mapping.update({'Id': self.id, 'Type': self.type})
 
         return super().ns3_config()
 
@@ -191,12 +191,12 @@ class E2EComponent(E2EBase):
     def resolve_paths(self) -> None:
         self.has_path = True
         for component in self.components:
-            path = f"{self.id}/{component.id}"
+            path = f'{self.id}/{component.id}'
             if component.has_path:
                 raise AttributeError(
-                    f"Component {component.id} was already "
-                    f"added to another component (while trying "
-                    f"to assign {path})."
+                    f'Component {component.id} was already '
+                    f'added to another component (while trying '
+                    f'to assign {path}).'
                 )
             component.id = path
             component.resolve_paths()
@@ -206,7 +206,7 @@ class E2ETopologyNode(E2EComponent):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.category = "TopologyNode"
+        self.category = 'TopologyNode'
         self.network = None
 
 
@@ -214,12 +214,12 @@ class E2ESwitchNode(E2ETopologyNode):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.type = "Switch"
-        self.mtu = ""
+        self.type = 'Switch'
+        self.mtu = ''
 
     def ns3_config(self) -> str:
         self.mapping.update({
-            "Mtu": self.mtu,
+            'Mtu': self.mtu,
         })
         return super().ns3_config()
 
@@ -228,49 +228,49 @@ class E2ETopologyChannel(E2EComponent):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.category = "TopologyChannel"
+        self.category = 'TopologyChannel'
 
 
 class E2ESimpleChannel(E2ETopologyChannel):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.type = "Simple"
-        self.data_rate = ""
-        self.queue_type = "ns3::DropTailQueue"
-        self.queue_size = ""
-        self.channel_type = "ns3::SimpleChannel"
-        self.delay = ""
+        self.type = 'Simple'
+        self.data_rate = ''
+        self.queue_type = 'ns3::DropTailQueue'
+        self.queue_size = ''
+        self.channel_type = 'ns3::SimpleChannel'
+        self.delay = ''
         self.left_node: E2ETopologyNode
         self.right_node: E2ETopologyNode
 
     def ns3_config(self) -> str:
         if self.left_node is None or self.right_node is None:
-            raise AttributeError(f"Not all nodes for channel {self.id} given")
+            raise AttributeError(f'Not all nodes for channel {self.id} given')
         self.mapping.update({
-            "Device-DataRate": self.data_rate,
-            "QueueType": self.queue_type,
-            "Queue-MaxSize": self.queue_size,
-            "ChannelType": self.channel_type,
-            "Channel-Delay": self.delay,
-            "LeftNode": self.left_node.id,
-            "RightNode": self.right_node.id,
+            'Device-DataRate': self.data_rate,
+            'QueueType': self.queue_type,
+            'Queue-MaxSize': self.queue_size,
+            'ChannelType': self.channel_type,
+            'Channel-Delay': self.delay,
+            'LeftNode': self.left_node.id,
+            'RightNode': self.right_node.id,
         })
         return super().ns3_config()
 
     def add_device_attr(self, key: str, value: str) -> None:
-        if not key.startswith("Device-"):
-            key = f"Device-{key}"
+        if not key.startswith('Device-'):
+            key = f'Device-{key}'
         self.mapping.update({key: value})
 
     def add_queue_attr(self, key: str, value: str) -> None:
-        if not key.startswith("Queue-"):
-            key = f"Queue-{key}"
+        if not key.startswith('Queue-'):
+            key = f'Queue-{key}'
         self.mapping.update({key: value})
 
     def add_channel_attr(self, key: str, value: str) -> None:
-        if not key.startswith("Channel-"):
-            key = f"Channel-{key}"
+        if not key.startswith('Channel-'):
+            key = f'Channel-{key}'
         self.mapping.update({key: value})
 
 
@@ -278,7 +278,7 @@ class E2ENetwork(E2EComponent):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.category = "Network"
+        self.category = 'Network'
         self.peer = None
 
     def set_peer(self, peer: E2ENetwork):
@@ -290,14 +290,14 @@ class E2ENetworkSimbricks(E2ENetwork):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.type = "Simbricks"
+        self.type = 'Simbricks'
         self.adapter_type = SimbricksAdapterType.NETWORK
-        self.unix_socket = ""
-        self.sync_delay = ""
-        self.poll_delay = ""
-        self.eth_latency = ""
+        self.unix_socket = ''
+        self.sync_delay = ''
+        self.poll_delay = ''
+        self.eth_latency = ''
         self.listen: tp.Optional[bool] = None
-        self.shm_path = ""
+        self.shm_path = ''
         self.sync: SimbricksSyncMode = SimbricksSyncMode.SYNC_OPTIONAL
 
         self.simbricks_component = None
@@ -305,16 +305,16 @@ class E2ENetworkSimbricks(E2ENetwork):
     def ns3_config(self) -> str:
         if self.listen is None:
             raise AttributeError(
-                f"Listen mode not specified for simbricks adapter {self.id}"
+                f'Listen mode not specified for simbricks adapter {self.id}'
             )
         self.mapping.update({
-            "UnixSocket": self.unix_socket,
-            "SyncDelay": self.sync_delay,
-            "PollDelay": self.poll_delay,
-            "EthLatency": self.eth_latency,
-            "Listen": "true" if self.listen else "false",
-            "ShmPath": self.shm_path,
-            "Sync": "" if self.sync is None else f"{self.sync.value}",
+            'UnixSocket': self.unix_socket,
+            'SyncDelay': self.sync_delay,
+            'PollDelay': self.poll_delay,
+            'EthLatency': self.eth_latency,
+            'Listen': 'true' if self.listen else 'false',
+            'ShmPath': self.shm_path,
+            'Sync': '' if self.sync is None else f'{self.sync.value}',
         })
         return super().ns3_config()
 
@@ -323,30 +323,30 @@ class E2EHost(E2EComponent):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.category = "Host"
+        self.category = 'Host'
 
 
 class E2ESimbricksHost(E2EHost):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.type = "Simbricks"
+        self.type = 'Simbricks'
         self.adapter_type = SimbricksAdapterType.NIC
-        self.unix_socket = ""
-        self.sync_delay = ""
-        self.poll_delay = ""
-        self.eth_latency = ""
+        self.unix_socket = ''
+        self.sync_delay = ''
+        self.poll_delay = ''
+        self.eth_latency = ''
         self.sync: SimbricksSyncMode = SimbricksSyncMode.SYNC_OPTIONAL
 
         self.simbricks_component = None
 
     def ns3_config(self) -> str:
         self.mapping.update({
-            "UnixSocket": self.unix_socket,
-            "SyncDelay": self.sync_delay,
-            "PollDelay": self.poll_delay,
-            "EthLatency": self.eth_latency,
-            "Sync": "" if self.sync is None else f"{self.sync.value}",
+            'UnixSocket': self.unix_socket,
+            'SyncDelay': self.sync_delay,
+            'PollDelay': self.poll_delay,
+            'EthLatency': self.eth_latency,
+            'Sync': '' if self.sync is None else f'{self.sync.value}',
         })
         return super().ns3_config()
 
@@ -355,44 +355,44 @@ class E2ESimpleNs3Host(E2EHost):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.type = "SimpleNs3"
-        self.data_rate = ""
-        self.queue_type = "ns3::DropTailQueue"
-        self.queue_size = ""
-        self.channel_type = "ns3::SimpleChannel"
-        self.delay = ""
+        self.type = 'SimpleNs3'
+        self.data_rate = ''
+        self.queue_type = 'ns3::DropTailQueue'
+        self.queue_size = ''
+        self.channel_type = 'ns3::SimpleChannel'
+        self.delay = ''
         self.congestion_control: CongestionControl = None
-        self.ip = ""
+        self.ip = ''
 
     def ns3_config(self) -> str:
         if self.congestion_control is None:
-            cc = ""
+            cc = ''
         else:
             cc = self.congestion_control.ns3
         self.mapping.update({
-            "Device-DataRate": self.data_rate,
-            "QueueType": self.queue_type,
-            "Queue-MaxSize": self.queue_size,
-            "ChannelType": self.channel_type,
-            "Channel-Delay": self.delay,
-            "CongestionControl": cc,
-            "Ip": self.ip,
+            'Device-DataRate': self.data_rate,
+            'QueueType': self.queue_type,
+            'Queue-MaxSize': self.queue_size,
+            'ChannelType': self.channel_type,
+            'Channel-Delay': self.delay,
+            'CongestionControl': cc,
+            'Ip': self.ip,
         })
         return super().ns3_config()
 
     def add_device_attr(self, key: str, value: str) -> None:
-        if not key.startswith("Device-"):
-            key = f"Device-{key}"
+        if not key.startswith('Device-'):
+            key = f'Device-{key}'
         self.mapping.update({key: value})
 
     def add_queue_attr(self, key: str, value: str) -> None:
-        if not key.startswith("Queue-"):
-            key = f"Queue-{key}"
+        if not key.startswith('Queue-'):
+            key = f'Queue-{key}'
         self.mapping.update({key: value})
 
     def add_channel_attr(self, key: str, value: str) -> None:
-        if not key.startswith("Channel-"):
-            key = f"Channel-{key}"
+        if not key.startswith('Channel-'):
+            key = f'Channel-{key}'
         self.mapping.update({key: value})
 
 
@@ -400,14 +400,14 @@ class E2EApplication(E2EComponent):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.category = "App"
-        self.start_time = ""
-        self.stop_time = ""
+        self.category = 'App'
+        self.start_time = ''
+        self.stop_time = ''
 
     def ns3_config(self) -> str:
         self.mapping.update({
-            "StartTime": self.start_time,
-            "StopTime": self.stop_time,
+            'StartTime': self.start_time,
+            'StopTime': self.stop_time,
         })
         return super().ns3_config()
 
@@ -416,14 +416,14 @@ class E2EPacketSinkApplication(E2EApplication):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.type = "PacketSink"
-        self.protocol = "ns3::TcpSocketFactory"
-        self.local_ip = ""
+        self.type = 'PacketSink'
+        self.protocol = 'ns3::TcpSocketFactory'
+        self.local_ip = ''
 
     def ns3_config(self) -> str:
         self.mapping.update({
-            "Protocol": self.protocol,
-            "Local": self.local_ip,
+            'Protocol': self.protocol,
+            'Local': self.local_ip,
         })
         return super().ns3_config()
 
@@ -432,14 +432,14 @@ class E2EBulkSendApplication(E2EApplication):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.type = "BulkSender"
-        self.protocol = "ns3::TcpSocketFactory"
-        self.remote_ip = ""
+        self.type = 'BulkSender'
+        self.protocol = 'ns3::TcpSocketFactory'
+        self.remote_ip = ''
 
     def ns3_config(self) -> str:
         self.mapping.update({
-            "Protocol": self.protocol,
-            "Remote": self.remote_ip,
+            'Protocol': self.protocol,
+            'Remote': self.remote_ip,
         })
         return super().ns3_config()
 
@@ -447,12 +447,12 @@ class E2EBulkSendApplication(E2EApplication):
 class E2ENs3RandomVariable(ABC):
 
     def __init__(self) -> None:
-        self.type_id = ""
+        self.type_id = ''
 
     def get_config(self) -> str:
         params = self.get_parameters()
         if params:
-            return f"{self.type_id}[{params}]"
+            return f'{self.type_id}[{params}]'
         else:
             return self.type_id
 
@@ -465,55 +465,55 @@ class E2ENs3ConstantRandomVariable(E2ENs3RandomVariable):
 
     def __init__(self) -> None:
         super().__init__()
-        self.type_id = "ns3::ConstantRandomVariable"
+        self.type_id = 'ns3::ConstantRandomVariable'
         self.constant: tp.Optional[float] = None
 
     def get_parameters(self) -> str:
         params = []
         if self.constant:
-            params.append(f"Constant={self.constant}")
-        return "|".join(params)
+            params.append(f'Constant={self.constant}')
+        return '|'.join(params)
 
 
 class E2ENs3UniformRandomVariable(E2ENs3RandomVariable):
 
     def __init__(self) -> None:
         super().__init__()
-        self.type_id = "ns3::UniformRandomVariable"
+        self.type_id = 'ns3::UniformRandomVariable'
         self.min: tp.Optional[float] = None
         self.max: tp.Optional[float] = None
 
     def get_parameters(self) -> str:
         params = []
         if self.min:
-            params.append(f"Min={self.min}")
+            params.append(f'Min={self.min}')
         if self.max:
-            params.append(f"Max={self.max}")
-        return "|".join(params)
+            params.append(f'Max={self.max}')
+        return '|'.join(params)
 
 
 class E2ENs3ExponentialRandomVariable(E2ENs3RandomVariable):
 
     def __init__(self) -> None:
         super().__init__()
-        self.type_id = "ns3::ExponentialRandomVariable"
+        self.type_id = 'ns3::ExponentialRandomVariable'
         self.mean: tp.Optional[float] = None
         self.bound: tp.Optional[float] = None
 
     def get_parameters(self) -> str:
         params = []
         if self.mean:
-            params.append(f"Mean={self.mean}")
+            params.append(f'Mean={self.mean}')
         if self.bound:
-            params.append(f"Bound={self.bound}")
-        return "|".join(params)
+            params.append(f'Bound={self.bound}')
+        return '|'.join(params)
 
 
 class E2ENs3NormalRandomVariable(E2ENs3RandomVariable):
 
     def __init__(self) -> None:
         super().__init__()
-        self.type_id = "ns3::NormalRandomVariable"
+        self.type_id = 'ns3::NormalRandomVariable'
         self.mean: tp.Optional[float] = None
         self.variance: tp.Optional[float] = None
         self.bound: tp.Optional[float] = None
@@ -521,24 +521,24 @@ class E2ENs3NormalRandomVariable(E2ENs3RandomVariable):
     def get_parameters(self) -> str:
         params = []
         if self.mean:
-            params.append(f"Mean={self.mean}")
+            params.append(f'Mean={self.mean}')
         if self.variance:
-            params.append(f"Variance={self.variance}")
+            params.append(f'Variance={self.variance}')
         if self.bound:
-            params.append(f"Bound={self.bound}")
-        return "|".join(params)
+            params.append(f'Bound={self.bound}')
+        return '|'.join(params)
 
 
 class E2EOnOffApplication(E2EApplication):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.type = "OnOff"
-        self.protocol = "ns3::TcpSocketFactory"
-        self.remote_ip = ""
-        self.data_rate = ""
-        self.max_bytes = ""
-        self.packet_size = ""
+        self.type = 'OnOff'
+        self.protocol = 'ns3::TcpSocketFactory'
+        self.remote_ip = ''
+        self.data_rate = ''
+        self.max_bytes = ''
+        self.packet_size = ''
         self.on_time: tp.Optional[E2ENs3RandomVariable] = None
         self.off_time: tp.Optional[E2ENs3RandomVariable] = None
 
@@ -546,19 +546,19 @@ class E2EOnOffApplication(E2EApplication):
         if self.on_time:
             on = self.on_time.get_config()
         else:
-            on = ""
+            on = ''
         if self.off_time:
             off = self.off_time.get_config()
         else:
-            off = ""
+            off = ''
         self.mapping.update({
-            "Protocol": self.protocol,
-            "Remote": self.remote_ip,
-            "DataRate": self.data_rate,
-            "MaxBytes": self.max_bytes,
-            "PacketSize": self.packet_size,
-            "OnTime": on,
-            "OffTime": off,
+            'Protocol': self.protocol,
+            'Remote': self.remote_ip,
+            'DataRate': self.data_rate,
+            'MaxBytes': self.max_bytes,
+            'PacketSize': self.packet_size,
+            'OnTime': on,
+            'OffTime': off,
         })
         return super().ns3_config()
 
@@ -567,7 +567,7 @@ class E2EProbe(E2EComponent):
 
     def __init__(self, idd: str) -> None:
         super().__init__(idd)
-        self.category = "Probe"
+        self.category = 'Probe'
 
 
 class E2EPeriodicSampleProbe(E2EProbe):
@@ -575,18 +575,18 @@ class E2EPeriodicSampleProbe(E2EProbe):
     def __init__(self, idd: str, probe_type: str) -> None:
         super().__init__(idd)
         self.type = probe_type
-        self.file = ""
-        self.header = ""
-        self.unit = ""
-        self.start = ""
-        self.interval = ""
+        self.file = ''
+        self.header = ''
+        self.unit = ''
+        self.start = ''
+        self.interval = ''
 
     def ns3_config(self) -> str:
         self.mapping.update({
-            "File": self.file,
-            "Header": self.header,
-            "Unit": self.unit,
-            "Start": self.start,
-            "Interval": self.interval
+            'File': self.file,
+            'Header': self.header,
+            'Unit': self.unit,
+            'Start': self.start,
+            'Interval': self.interval
         })
         return super().ns3_config()

experiments/simbricks/orchestration/e2e_helpers.py

@@ -51,14 +51,14 @@ class E2ELinkAssigner():
         create_link: bool = True
     ):
         if create_link and link_type is None:
-            raise RuntimeError("Cannot create a link without link type")
+            raise RuntimeError('Cannot create a link without link type')
         if idd in self.links:
-            raise RuntimeError(f"Link {idd} already exists")
+            raise RuntimeError(f'Link {idd} already exists')
         link = {
-            "left": left_switch,
-            "right": right_switch,
-            "type": link_type,
-            "created": create_link
+            'left': left_switch,
+            'right': right_switch,
+            'type': link_type,
+            'created': create_link
         }
         if create_link:
             self._create_link(idd, link)
@@ -76,42 +76,40 @@ class E2ELinkAssigner():
 
     # TODO: set properties like latency
     def _create_link(self, idd: str, link):
-        left_switch = link["left"]
-        right_switch = link["right"]
-        link_type = link["type"]
+        left_switch = link['left']
+        right_switch = link['right']
+        link_type = link['type']
         if link_type == E2ELinkType.SIMBRICKS:
-            left_adapter = e2e.E2ENetworkSimbricks(f"_{idd}_left_adapter")
+            left_adapter = e2e.E2ENetworkSimbricks(f'_{idd}_left_adapter')
             left_adapter.listen = False
             left_switch.add_component(left_adapter)
-            link["left_adapter"] = left_adapter
-            right_adapter = e2e.E2ENetworkSimbricks(
-                f"_{idd}_right_adapter"
-            )
+            link['left_adapter'] = left_adapter
+            right_adapter = e2e.E2ENetworkSimbricks(f'_{idd}_right_adapter')
             right_adapter.listen = True
             right_switch.add_component(right_adapter)
-            link["right_adapter"] = right_adapter
+            link['right_adapter'] = right_adapter
         elif link_type == E2ELinkType.NS3_SIMPLE_CHANNEL:
-            ns3link = e2e.E2ESimpleChannel(f"_{idd}_link")
+            ns3link = e2e.E2ESimpleChannel(f'_{idd}_link')
             ns3link.left_node = left_switch
             ns3link.right_node = right_switch
-            link["ns3link"] = ns3link
+            link['ns3link'] = ns3link
 
     def set_link_type(self, idd: str, link_type: E2ELinkType):
         if idd not in self.links:
-            raise RuntimeError(f"Link {idd} not found")
+            raise RuntimeError(f'Link {idd} not found')
         link = self.links[idd]
-        if link["created"]:
-            raise RuntimeError("Cannot change type of already existing link")
-        link["type"] = link_type
+        if link['created']:
+            raise RuntimeError('Cannot change type of already existing link')
+        link['type'] = link_type
 
     def create_missing_links(self):
         for idd, link in self.links.items():
-            if link["created"]:
+            if link['created']:
                 continue
-            if link["type"] is None:
-                raise RuntimeError(f"Link {idd} has no type")
+            if link['type'] is None:
+                raise RuntimeError(f'Link {idd} has no type')
             self._create_link(idd, link)
-            link["created"] = True
+            link['created'] = True
 
     def assign_networks(self) -> tp.List[NS3E2ENet]:
         networks = []
@@ -119,7 +117,7 @@ class E2ELinkAssigner():
         while len(self.connected_switches) > 0:
             # create network and take next (random) switch
             net = NS3E2ENet()
-            net.name = f"_network_{len(networks)}"
+            net.name = f'_network_{len(networks)}'
             networks.append(net)
             next_switches = set()
             next_switches.add(self.connected_switches.pop())
@@ -129,28 +127,28 @@ class E2ELinkAssigner():
                 switch = next_switches.pop()
                 net.add_component(switch)
                 for link in self.switch_links[switch]:
-                    if link["type"] == E2ELinkType.SIMBRICKS:
-                        if link["left"] == switch:
-                            link["right_adapter"].simbricks_component = net
+                    if link['type'] == E2ELinkType.SIMBRICKS:
+                        if link['left'] == switch:
+                            link['right_adapter'].simbricks_component = net
                         else:
-                            assert link["right"] == switch
-                            link["left_adapter"].simbricks_component = net
-                    elif link["type"] == E2ELinkType.NS3_SIMPLE_CHANNEL:
+                            assert link['right'] == switch
+                            link['left_adapter'].simbricks_component = net
+                    elif link['type'] == E2ELinkType.NS3_SIMPLE_CHANNEL:
                         not_visited_switches = 0
-                        if link["left"] in self.connected_switches:
-                            next_switches.add(link["left"])
-                            self.connected_switches.remove(link["left"])
+                        if link['left'] in self.connected_switches:
+                            next_switches.add(link['left'])
+                            self.connected_switches.remove(link['left'])
                             not_visited_switches += 1
-                        if link["right"] in self.connected_switches:
-                            next_switches.add(link["right"])
-                            self.connected_switches.remove(link["right"])
+                        if link['right'] in self.connected_switches:
+                            next_switches.add(link['right'])
+                            self.connected_switches.remove(link['right'])
                             not_visited_switches += 1
                         assert not_visited_switches < 2
                         # if only one switch has been visited (namely the
                         # current switch), we see this link for the first time
                         if not_visited_switches == 1:
-                            net.add_component(link["ns3link"])
+                            net.add_component(link['ns3link'])
                     else:
-                        raise RuntimeError("Unknown link type")
+                        raise RuntimeError('Unknown link type')
 
         return networks

experiments/simbricks/orchestration/e2e_topologies.py

@@ -38,9 +38,9 @@ class E2ETopology(ABC):
 class E2EDumbbellTopology(E2ETopology):
 
     def __init__(self):
-        self.left_switch = e2e.E2ESwitchNode("_leftSwitch")
-        self.right_switch = e2e.E2ESwitchNode("_rightSwitch")
-        self.link = e2e.E2ESimpleChannel("_link")
+        self.left_switch = e2e.E2ESwitchNode('_leftSwitch')
+        self.right_switch = e2e.E2ESwitchNode('_rightSwitch')
+        self.link = e2e.E2ESimpleChannel('_link')
         self.link.left_node = self.left_switch
         self.link.right_node = self.right_switch
 

experiments/simbricks/orchestration/experiment/experiment_environment.py

@@ -102,7 +102,9 @@ class ExpEnv(object):
         return f'{self.shm_base}/dev.shm.{sim.name}'
 
     def n2n_eth_path(
-        self, sim_l: 'simulators.Simulator', sim_c: 'simulators.Simulator',
+        self,
+        sim_l: 'simulators.Simulator',
+        sim_c: 'simulators.Simulator',
         suffix=''
     ) -> str:
         return f'{self.workdir}/n2n.eth.{sim_l.name}.{sim_c.name}.{suffix}'

experiments/simbricks/orchestration/nodeconfig.py

@@ -378,8 +378,7 @@ class I40eTCPCongNode(NodeConfig):
         return super().prepare_post_cp() + [
             'modprobe i40e',
             'ethtool -G eth0 rx 4096 tx 4096',
-            'ethtool -K eth0 tso off',
-            # 'ip link set eth0 txqueuelen 13888',
+            'ethtool -K eth0 tso off',  # 'ip link set eth0 txqueuelen 13888',
             f'ip link set dev eth0 mtu {self.mtu} up',
             f'ip addr add {self.ip}/{self.prefix} dev eth0',
         ]

experiments/simbricks/orchestration/runners.py

@@ -187,7 +187,7 @@ class ExperimentBaseRunner(ABC):
         assert self.profile_int
         while True:
             await asyncio.sleep(self.profile_int)
-            for (_,sc) in self.running:
+            for (_, sc) in self.running:
                 await sc.sigusr1()
 
     async def run(self) -> ExpOutput:

experiments/simbricks/orchestration/simulators.py

@@ -26,10 +26,10 @@ from __future__ import annotations
 import math
 import typing as tp
 
+from simbricks.orchestration import e2e_components as e2e
+from simbricks.orchestration.e2e_topologies import E2ETopology
 from simbricks.orchestration.experiment.experiment_environment import ExpEnv
 from simbricks.orchestration.nodeconfig import NodeConfig
-from simbricks.orchestration.e2e_topologies import E2ETopology
-from simbricks.orchestration import e2e_components as e2e
 
 
 class Simulator(object):