From 43a5f338847e250dfc3357fec8b7c7eef8496c4a Mon Sep 17 00:00:00 2001 From: Enidsky Date: Sun, 21 Jan 2024 13:23:14 +0800 Subject: [PATCH] feat: add bbr,bic,qsccp,reno self compare --- scenarios/bbr_bbr.py | 110 +++++++++++++++++++++++++++++++++++++++ scenarios/bic_bic.py | 110 +++++++++++++++++++++++++++++++++++++++ scenarios/qsccp_qsccp.py | 109 ++++++++++++++++++++++++++++++++++++++ scenarios/reno_reno.py | 109 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 438 insertions(+) create mode 100644 scenarios/bbr_bbr.py create mode 100644 scenarios/bic_bic.py create mode 100644 scenarios/qsccp_qsccp.py create mode 100644 scenarios/reno_reno.py diff --git a/scenarios/bbr_bbr.py b/scenarios/bbr_bbr.py new file mode 100644 index 0000000..cb03e84 --- /dev/null +++ b/scenarios/bbr_bbr.py @@ -0,0 +1,110 @@ +import os +import time +import sys +from subprocess import PIPE + +from mininet.log import setLogLevel, info +from mininet.topo import Topo +from mininet.link import TCLink + +from minindn.minindn import Minindn +from minindn.apps.app_manager import AppManager +from minindn.util import MiniNDNCLI, getPopen +from minindn.apps.nfd import Nfd +from minindn.helpers.nfdc import Nfdc + + +def printOutput(output): + _out = output.decode("utf-8").split("\n") + for _line in _out: + info(_line + "\n") + + +def addRoute(ndn, node1: str, node2: str, prefix: str): + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + info(f"Setting up route from {node1} to {node2} with interface {interface.IP()} => {prefix}\n") + Nfdc.registerRoute(host1, prefix, interface.IP(), cost=0) + + +def run(): + Minindn.cleanUp() + Minindn.verifyDependencies() + + ndn = Minindn( + topoFile=os.path.join( + os.path.dirname(os.path.dirname(os.path.realpath(__file__))), + "topologies", + sys.argv[1], + ) + ) + ndn.start() + + # configure and start nfd on each node + info("Configuring NFD\n") + AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0) + + for link in ndn.topo.links(withInfo=True): + node1, node2, node_info = link + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + interface_ip = interface.IP() + bandwidth = interface.params.get("bw", 100) * 1000000 + info(f"Setting up route from {node1} to {node2} with bandwidth {bandwidth}\n") + Nfdc.createFace(host1, interface_ip) + + addRoute(ndn, "c1", "r1", "/A") + addRoute(ndn, "c2", "r1", "/B") + + addRoute(ndn, "r1", "r2", "/A") + addRoute(ndn, "r1", "r2", "/B") + + addRoute(ndn, "r2", "p1", "/A") + addRoute(ndn, "r2", "p2", "/B") + + # Start cc server + info("Starting cc...\n") + qsccp_server_log = open(f"{ndn.workDir}/p1/qsccp-server.log", "w") + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/A"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p2/qsccp-server.log", "w") + getPopen( + ndn.net["p2"], + "cc-producer --prefix {}".format("/B"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + + total_time = 120000 + + # start cc client + qsccp_client_log = open(f"{ndn.workDir}/c2/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c2"], + f"bbr-client --prefix /B --timingStop {total_time}", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c1"], + f"bbr-client --prefix /A --timingStop {total_time}", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + ping1.wait() + + info("\nExperiment Completed!\n") + # MiniNDNCLI(ndn.net) + ndn.stop() + + +if __name__ == "__main__": + setLogLevel("info") + run() diff --git a/scenarios/bic_bic.py b/scenarios/bic_bic.py new file mode 100644 index 0000000..e8e25b2 --- /dev/null +++ b/scenarios/bic_bic.py @@ -0,0 +1,110 @@ +import os +import time +import sys +from subprocess import PIPE + +from mininet.log import setLogLevel, info +from mininet.topo import Topo +from mininet.link import TCLink + +from minindn.minindn import Minindn +from minindn.apps.app_manager import AppManager +from minindn.util import MiniNDNCLI, getPopen +from minindn.apps.nfd import Nfd +from minindn.helpers.nfdc import Nfdc + + +def printOutput(output): + _out = output.decode("utf-8").split("\n") + for _line in _out: + info(_line + "\n") + + +def addRoute(ndn, node1: str, node2: str, prefix: str): + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + info(f"Setting up route from {node1} to {node2} with interface {interface.IP()} => {prefix}\n") + Nfdc.registerRoute(host1, prefix, interface.IP(), cost=0) + + +def run(): + Minindn.cleanUp() + Minindn.verifyDependencies() + + ndn = Minindn( + topoFile=os.path.join( + os.path.dirname(os.path.dirname(os.path.realpath(__file__))), + "topologies", + sys.argv[1], + ) + ) + ndn.start() + + # configure and start nfd on each node + info("Configuring NFD\n") + AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0) + + for link in ndn.topo.links(withInfo=True): + node1, node2, node_info = link + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + interface_ip = interface.IP() + bandwidth = interface.params.get("bw", 100) * 1000000 + info(f"Setting up route from {node1} to {node2} with bandwidth {bandwidth}\n") + Nfdc.createFace(host1, interface_ip) + + addRoute(ndn, "c1", "r1", "/A") + addRoute(ndn, "c2", "r1", "/B") + + addRoute(ndn, "r1", "r2", "/A") + addRoute(ndn, "r1", "r2", "/B") + + addRoute(ndn, "r2", "p1", "/A") + addRoute(ndn, "r2", "p2", "/B") + + # Start cc server + info("Starting cc...\n") + qsccp_server_log = open(f"{ndn.workDir}/p1/qsccp-server.log", "w") + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/A"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p2/qsccp-server.log", "w") + getPopen( + ndn.net["p2"], + "cc-producer --prefix {}".format("/B"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + + total_time = 120000 + + # start cc client + qsccp_client_log = open(f"{ndn.workDir}/c2/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c2"], + f"pcon-client --prefix /B --timingStop {total_time} --ccAlgorithm BIC", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c1"], + f"pcon-client --prefix /A --timingStop {total_time} --ccAlgorithm BIC", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + ping1.wait() + + info("\nExperiment Completed!\n") + # MiniNDNCLI(ndn.net) + ndn.stop() + + +if __name__ == "__main__": + setLogLevel("info") + run() diff --git a/scenarios/qsccp_qsccp.py b/scenarios/qsccp_qsccp.py new file mode 100644 index 0000000..4694152 --- /dev/null +++ b/scenarios/qsccp_qsccp.py @@ -0,0 +1,109 @@ +import os +import sys +from subprocess import PIPE + +from mininet.log import setLogLevel, info +from mininet.topo import Topo +from mininet.link import TCLink + +from minindn.minindn import Minindn +from minindn.apps.app_manager import AppManager +from minindn.util import MiniNDNCLI, getPopen +from minindn.apps.nfd import Nfd +from minindn.helpers.nfdc import Nfdc + + +def printOutput(output): + _out = output.decode("utf-8").split("\n") + for _line in _out: + info(_line + "\n") + + +def addRoute(ndn, node1: str, node2: str, prefix: str): + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + info(f"Setting up route from {node1} to {node2} with interface {interface.IP()} => {prefix}\n") + Nfdc.registerRoute(host1, prefix, interface.IP(), cost=0) + + +def run(): + Minindn.cleanUp() + Minindn.verifyDependencies() + + ndn = Minindn( + topoFile=os.path.join( + os.path.dirname(os.path.dirname(os.path.realpath(__file__))), + "topologies", + sys.argv[1], + ) + ) + ndn.start() + + # configure and start nfd on each node + info("Configuring NFD\n") + AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0) + + for link in ndn.topo.links(withInfo=True): + node1, node2, node_info = link + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + interface_ip = interface.IP() + bandwidth = interface.params.get("bw", 100) * 1000000 + info(f"Setting up route from {node1} to {node2} with bandwidth {bandwidth}\n") + Nfdc.createFace(host1, interface_ip, bandwidth=bandwidth) + + addRoute(ndn, "c1", "r1", "/A") + addRoute(ndn, "c2", "r1", "/B") + + addRoute(ndn, "r1", "r2", "/A") + addRoute(ndn, "r1", "r2", "/B") + + addRoute(ndn, "r2", "p1", "/A") + addRoute(ndn, "r2", "p2", "/B") + + # Start cc server + info("Starting cc...\n") + qsccp_server_log = open(f"{ndn.workDir}/p1/qsccp-server.log", "w") + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/A"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p2/qsccp-server.log", "w") + getPopen( + ndn.net["p2"], + "cc-producer --prefix {}".format("/B"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + + total_time = 120000 + + # start cc client + qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c1"], + f"qsccp-client --prefix /A --timingStop {total_time} --tos 5 --initialSendRate 50000", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + qsccp_client_log = open(f"{ndn.workDir}/c2/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c2"], + f"qsccp-client --prefix /B --timingStop {total_time} --tos 5 --initialSendRate 50000", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + ping1.wait() + + info("\nExperiment Completed!\n") + # MiniNDNCLI(ndn.net) + ndn.stop() + + +if __name__ == "__main__": + setLogLevel("info") + run() diff --git a/scenarios/reno_reno.py b/scenarios/reno_reno.py new file mode 100644 index 0000000..f9cce49 --- /dev/null +++ b/scenarios/reno_reno.py @@ -0,0 +1,109 @@ +import os +import sys +from subprocess import PIPE + +from mininet.log import setLogLevel, info +from mininet.topo import Topo +from mininet.link import TCLink + +from minindn.minindn import Minindn +from minindn.apps.app_manager import AppManager +from minindn.util import MiniNDNCLI, getPopen +from minindn.apps.nfd import Nfd +from minindn.helpers.nfdc import Nfdc + + +def printOutput(output): + _out = output.decode("utf-8").split("\n") + for _line in _out: + info(_line + "\n") + + +def addRoute(ndn, node1: str, node2: str, prefix: str): + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + info(f"Setting up route from {node1} to {node2} with interface {interface.IP()} => {prefix}\n") + Nfdc.registerRoute(host1, prefix, interface.IP(), cost=0) + + +def run(): + Minindn.cleanUp() + Minindn.verifyDependencies() + + ndn = Minindn( + topoFile=os.path.join( + os.path.dirname(os.path.dirname(os.path.realpath(__file__))), + "topologies", + sys.argv[1], + ) + ) + ndn.start() + + # configure and start nfd on each node + info("Configuring NFD\n") + AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0) + + for link in ndn.topo.links(withInfo=True): + node1, node2, node_info = link + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + interface_ip = interface.IP() + bandwidth = interface.params.get("bw", 100) * 1000000 + info(f"Setting up route from {node1} to {node2} with bandwidth {bandwidth}\n") + Nfdc.createFace(host1, interface_ip) + + addRoute(ndn, "c1", "r1", "/A") + addRoute(ndn, "c2", "r1", "/B") + + addRoute(ndn, "r1", "r2", "/A") + addRoute(ndn, "r1", "r2", "/B") + + addRoute(ndn, "r2", "p1", "/A") + addRoute(ndn, "r2", "p2", "/B") + + # Start cc server + info("Starting cc...\n") + qsccp_server_log = open(f"{ndn.workDir}/p1/qsccp-server.log", "w") + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/A"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p2/qsccp-server.log", "w") + getPopen( + ndn.net["p2"], + "cc-producer --prefix {}".format("/B"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + + total_time = 120000 + + # start cc client + qsccp_client_log = open(f"{ndn.workDir}/c2/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c2"], + f"pcon-client --prefix /B --timingStop {total_time} --ccAlgorithm AIMD", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + + qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c1"], + f"pcon-client --prefix /A --timingStop {total_time} --ccAlgorithm AIMD", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + ping1.wait() + + info("\nExperiment Completed!\n") + ndn.stop() + + +if __name__ == "__main__": + setLogLevel("info") + run()