linearbandwidth.py now works for kernel switch.

examples/linearbandwidth.py

@@ -4,85 +4,92 @@
 Test bandwidth (using iperf) on linear networks of varying size, 
 using both kernel and user datapaths.
 
-Each network has N switches and N+1 hosts, connected as follows:
+We construct a network of N switches and N+1 hosts, connected as follows:
 
-h0 <-> s0 <-> s1 .. sN-1
+hN <-> s0 <-> s1 .. sN-1
         |      |     |
-        h1     h2    hN
+        hN+1   hN+2  hN+N
         
 Note: by default, the reference controller only supports 16
 switches, so this test WILL NOT WORK unless you have recompiled
 your controller to support 100 switches (or more.)
 """
-   
-from mininet.mininet import init, Network, defaultNames, Host, Switch
-from mininet.mininet import createLink, flush, iperf, pingTestVerbose, Cli
 
-class LinearNet( Network ):
+import sys
-   def __init__( self, switchCount, **kwargs ):
+flush = sys.stdout.flush
-      self.switchCount = switchCount
-      Network.__init__( self, **kwargs )
-   def makeNet( self, controller ):
-      snames, hnames, dpnames = defaultNames()
-      previous = None
-      hosts = []
-      switches = []
-      def newHost( switch ):
-         host = Host( hnames.next() )
-         createLink( host, switch )
-         print host.name, ; flush()
-         return [ host ]
-      print "*** Creating linear network of size", self.switchCount
-      for s in range( 0, self.switchCount ):
-         dp = dpnames.next() if self.kernel else None
-         switch = Switch( snames.next(), dp )
-         switches += [ switch ]
-         print switch.name, ; flush()
-         if not self.kernel: createLink( controller, switch )
-         if s == 0: hosts += newHost( switch )
-         hosts += newHost( switch)
-         if previous is not None: createLink( previous, switch)
-         previous = switch
-      return switches, hosts
    
+from mininet.net import init, Mininet
+from mininet.node import Host, KernelSwitch, UserSwitch
+from mininet.topo import Topo, Node
+from mininet.log import lg
+
+class LinearTopo( Topo ):
+    "Topology for a string of N switches and 1+N hosts."
+
+    def __init__( self, N ):
+    
+        # Add default members to class.
+        super( LinearTopo, self ).__init__()
+        
+        # Create switch and host nodes
+        switches = range( 0, N )
+        hosts = range( N, 2*N + 1 )
+        for id in switches:
+            self._add_node( id, Node( is_switch=True ) )
+        for id in hosts:
+            self._add_node( id, Node( is_switch=False ) )
+
+        # Connect switches
+        for s in switches[ :-1 ]:
+            self._add_edge( s, s + 1 )
+            
+        # Connect hosts
+        self._add_edge( hosts[ 0 ], switches[ 0 ] )
+        for s in switches:
+            self._add_edge( s, s + N + 1)
+            
+        # Consider all switches and hosts 'on'
+        self.enable_all()
+
 def linearBandwidthTest( lengths ):
 
-   "Check bandwidth at various lengths along a switch chain."
+    "Check bandwidth at various lengths along a switch chain."
-   
+
-   datapaths = [ 'kernel', 'user' ]
+    datapaths = [ 'kernel', 'user' ]
-   results = {}
+    results = {}
-   switchCount = max( lengths )
+    switchCount = max( lengths )
-   
+
-   for datapath in datapaths:
+    for datapath in datapaths:
-      k = datapath == 'kernel'
+        Switch = KernelSwitch if datapath == 'kernel' else UserSwitch
-      results[ datapath ] = []
+        results[ datapath ] = []
-      network = LinearNet( switchCount, kernel=k)
+        net = Mininet( topo=LinearTopo( switchCount ), switch=Switch )
-      network.start()
+        net.start()
-      for n in lengths:
+        print "*** testing basic connectivity"
-         def test( controllers, switches, hosts ):
+        net.ping( [ net.hosts[ 0 ], net.hosts[ -1 ] ] )
+        print "*** testing bandwidth"
+        for n in lengths:
             print "testing h0 <-> h" + `n`, ; flush()
-            result = iperf( [ hosts[ 0 ], hosts[ n ] ] )
+            bandwidth = net.iperf( [ net.hosts[ 0 ], net.hosts[ n ] ]  )
-            print result ; flush()
+            print bandwidth ; flush()
-            return result
+            results[ datapath ] += [ ( n, bandwidth ) ]
-         bandwidth = network.runTest( test )
+        net.stop()
-         results[ datapath ] += [ ( n, bandwidth ) ]
-      network.stop()
       
-   for datapath in datapaths:
+    for datapath in datapaths:
-      print
+        print
-      print "*** Linear network results for", datapath, "datapath:"
+        print "*** Linear network results for", datapath, "datapath:"
-      print
+        print
-      result = results[ datapath ]  
+        result = results[ datapath ]  
-      print "SwitchCount\tiperf Results"
+        print "SwitchCount\tiperf Results"
-      for switchCount, bandwidth in result:
+        for switchCount, bandwidth in result:
-         print switchCount, '\t\t', 
+            print switchCount, '\t\t', 
-         print bandwidth[ 0 ], 'server, ', bandwidth[ 1 ], 'client'
+            print bandwidth[ 0 ], 'server, ', bandwidth[ 1 ], 'client'
-      print
+        print
-   print
+    print
       
 if __name__ == '__main__':
-   init()
+    lg.setLogLevel( 'info' )
-   print "*** Running linearBandwidthTest"
+    init()
-   linearBandwidthTest( [ 1, 10, 20, 40, 60, 80, 100 ] )
+    print "*** Running linearBandwidthTest"
+    linearBandwidthTest( [ 1, 10 ] )