reformatting

Author: li-ch

Distribution/HDFS.py

@@ -1,13 +1,16 @@
 import sys
+
 sys.path.append("..")
 
 import random, math
 from Topology.FatTree import *
 
+
 class AllocChunks:
     """
     This class builds the chunks distribution in HDFS.
     """
+
     def __init__(self, M, d, n, topo):
         """
         M: the rank range of items, it indicates the number of distinct chunks in HDFS
@@ -102,5 +105,3 @@ def AllocatesNow(self):
 
     def __del__(self):
         pass
-
-

Distribution/PowerLawOnHDFS.py

@@ -1,9 +1,8 @@
-
-
 import sys
+
 sys.path.append("..")
 
-import random, getopt
+import getopt
 from HDFS import *
 from RandomGenerator.PowerLaw import *
 from RandomGenerator.Poisson import *
@@ -106,6 +105,7 @@ def AllocateFlows(topo, hdfs, pl, ps):
 
     f.close()
 
+
 def main():
     """
     Now we just provide allocation function for power-law distribution in traditional HDFS distribution.
@@ -124,5 +124,6 @@ def main():
     # allocates flows
     AllocateFlows(topo, hdfs, pl, ps)
 
+
 if __name__ == "__main__":
     main()

Distribution/WeightedChoice.py

@@ -2,6 +2,7 @@
 
 import random
 
+
 def weighted_choice(choices):
     total = sum([choices[c] for c in choices])
     r = random.uniform(0, total)
@@ -12,10 +13,11 @@ def weighted_choice(choices):
         upto += choices[c]
     assert False, "Shouldn't get here"
 
+
 # Usage example
-if __name__=="__main__":
+if __name__ == "__main__":
     choice = ['a', 'b', 'c', 'd']
     weight = [1, 2, 3, 4]
     css = dict(zip(choice, weight))
     for i in range(10):
-        print weighted_choice(css)
+        print weighted_choice(css)

Distribution/__init__.py

@@ -1 +0,0 @@
-

LoadBalance/Hedera_SpineLeaf.py

@@ -1,6 +1,3 @@
-
-
-
 class Hedera_SpineLeaf(object):
     def __init__(self):
         pass

LoadBalance/__init__.py

@@ -1 +0,0 @@
-

RandomGenerator/Poisson.py

@@ -1,7 +1,7 @@
+import random
+import math
 
 
-import random, math
-
 class PoissonRand:
     """
     This is used to generate poisson numbers.
@@ -12,6 +12,7 @@ class PoissonRand:
     Thus, we random generate a P in (0, 1) and calculate the delta_t by the equation above.
     Note that if P is extremely small, for example, P = 0, that leads to an infinite delta_t, therefore, we needs to set a bound.
     """
+
     def __init__(self, mean, bound):
         self.mean = mean
         self.bound = bound

RandomGenerator/PowerLaw.py

@@ -1,9 +1,9 @@
-
 class PowerLaw:
     """
     This class is used to generate power-law distribution.
     """
-    def __init__(self, alpha=1.0, totalNums = 1000, rank=100):
+
+    def __init__(self, alpha=1.0, totalNums=1000, rank=100):
         self.alpha = alpha
         self.N = totalNums
         self.rankRange = rank
@@ -40,4 +40,3 @@ def GetDistribution(self):
             else:
                 break
         return dist
-

RandomGenerator/__init__.py

@@ -1 +0,0 @@
-

Routing/ECMP_FatTree.py

@@ -1,17 +1,16 @@
-
-
 import sys
+
 sys.path.append("..")
 
 from Topology.FatTree import *
 from Src.Routing import *
 
-import gc
 
 class ECMP(Routing):
     """
     This routing approach is specific for fat-tree topology
     """
+
     def __init__(self, topo):
         Routing.__init__(self, topo)
         self.K = topo.K
@@ -33,7 +32,7 @@ def CalculateAllPath(self):
         Note that besides serverId, switch Id is required to convert into node id
         """
         for srcId in range(1, self.numOfServers + 1):
-            #gc.collect()        
+            # gc.collect()
             for dstId in range(1, self.numOfServers + 1):
                 self.CalculatePath(srcId=srcId, dstId=dstId)
 

Routing/ECMP_SpineLeaf.py

@@ -1,17 +1,16 @@
-
-
 import sys
+
 sys.path.append("..")
 
-from Topology.SpineLeaf import *
 from Src.Routing import *
 from random import choice
-import gc
+
 
 class ECMP(Routing):
     """
     This routing approach is specific for spine-leaf topology
     """
+
     def __init__(self, topo):
         Routing.__init__(self, topo)
         self.numOfServers = topo.numOfServers
@@ -31,7 +30,7 @@ def CalculateAllPath(self):
         For spine-leaf, choosing a path is essentially choosing a spine to traverse
         """
         for srcId in range(self.numOfServers):
-            #gc.collect()
+            # gc.collect()
             for dstId in range(self.numOfServers):
                 self.CalculatePath(srcId=srcId, dstId=dstId)
 
@@ -49,7 +48,8 @@ def CalculatePath(self, srcId, dstId, flow):
         # src-dst must traverse core
         else:
             # prick random core
-            rcore = choice(range(self.numOfServers + self.numOfToRs, self.numOfServers + self.numOfToRs + self.numOfCores))
+            rcore = choice(
+                range(self.numOfServers + self.numOfToRs, self.numOfServers + self.numOfToRs + self.numOfCores))
             self.pathList[srcId, dstId] = [srcId, srcToRId, rcore, dstToRId, dstId]
 
     def __del__(self):

Routing/FlowLB_SpineLeaf.py

@@ -1,63 +1,61 @@
-
-
 import sys
+
 sys.path.append("..")
 
-from Topology.SpineLeaf import *
 from Src.Routing import *
-from random import choice
-import gc
+
 
 class FlowLB(Routing):
     """
     This routing approach is specific for spine-leaf topology
     """
+
     def __init__(self, topo):
         Routing.__init__(self, topo)
-        #self.numOfServers = topo.numOfServers
-        #self.serverPerRack = topo.serverPerRack
-        #self.numOfToRs = topo.numOfToRs
-        #self.numOfCores = topo.numOfCores
-        self.topo=topo
+        # self.numOfServers = topo.numOfServers
+        # self.serverPerRack = topo.serverPerRack
+        # self.numOfToRs = topo.numOfToRs
+        # self.numOfCores = topo.numOfCores
+        self.topo = topo
 
     def BuildAllPath(self):
         self.CalculateAllPath()
 
     def BuildPath(self, srcId, dstId, flow, flows):
         self.CalculatePath(srcId, dstId, flow, flows)
 
-  #  def CalculateAllPath(self):
-  #      """
-  #      This function calculate path between each pair of servers by choosing a core switch with least traversing        flows. For spine-leaf, choosing a path is essentially choosing a spine to travers
-  #      """
-  #      for srcId in range(1, self.numOfServers + 1):
-  #          #gc.collect()
-  #          for dstId in range(1, self.numOfServers + 1):
-  #              self.CalculatePath(srcId=srcId, dstId=dstId)
+        #  def CalculateAllPath(self):
+        #      """
+        #      This function calculate path between each pair of servers by choosing a core switch with least traversing        flows. For spine-leaf, choosing a path is essentially choosing a spine to travers
+        #      """
+        #      for srcId in range(1, self.numOfServers + 1):
+        #          #gc.collect()
+        #          for dstId in range(1, self.numOfServers + 1):
+        #              self.CalculatePath(srcId=srcId, dstId=dstId)
 
-    def GetCoreLeastFlow(self, flows):                            
-        cores = []                                         
-        for i in range(self.topo.numOfCores):                   
-            cores.append(self.topo.GetCoreNode(i))            
-        # print "cores {}".format(cores)     
-        dc ={}
+    def GetCoreLeastFlow(self, flows):
+        cores = []
+        for i in range(self.topo.numOfCores):
+            cores.append(self.topo.GetCoreNode(i))
+            # print "cores {}".format(cores)
+        dc = {}
         for c in cores:
             fsize = 0.0
             for flowId in c.flowIds:
                 fsize += flows[flowId].remainSize
             dc[c] = fsize
-        #for key in dc.keys():
-            #print "key= ",key.nodeId," dc[key]= ",dc[key],"    "
-        #print "min of dc ",min(dc, key=dc.get).nodeId
-        return min(dc, key=dc.get)                         
-    
-    def GetCoreLeastQ(self):                               
-        cores = []                                         
-        for i in range(self.topo.numOfCores):                   
-            cores.append(self.topo.GetCoreNode(i))         
-        # print "cores {}".format(cores)                   
-        dc = dict([(c, len(c.qvalue)) for c in cores])     
-        return min(dc, key=dc.get)                         
+            # for key in dc.keys():
+            # print "key= ",key.nodeId," dc[key]= ",dc[key],"    "
+        # print "min of dc ",min(dc, key=dc.get).nodeId
+        return min(dc, key=dc.get)
+
+    def GetCoreLeastQ(self):
+        cores = []
+        for i in range(self.topo.numOfCores):
+            cores.append(self.topo.GetCoreNode(i))
+            # print "cores {}".format(cores)
+        dc = dict([(c, len(c.qvalue)) for c in cores])
+        return min(dc, key=dc.get)
 
     def CalculatePath(self, srcId, dstId, flow, flows):
         # only self id is contained, if destination is self
@@ -70,17 +68,16 @@ def CalculatePath(self, srcId, dstId, flow, flows):
         if srcToRId == dstToRId:
             self.pathList[srcId, dstId] = [srcId, srcToRId, dstId]
             return
-       # src-dst must traverse core
+            # src-dst must traverse core
         else:
             # prick random core
-           # rcore = choice(range(self.numOfServers+self.numOfToRs+1, self.numOfServers + self.numOfToRs + self.numOfCores + 1))
-           # if flow.coflowId == 0: 
-            rcore=self.GetCoreLeastFlow(flows)
-           #  else:
-           #     rcore=self.topo.GetCoreNode(flow.coflowId % self.topo.numOfCores)
-            rcoreId=rcore.nodeId
+            # rcore = choice(range(self.numOfServers+self.numOfToRs+1, self.numOfServers + self.numOfToRs + self.numOfCores + 1))
+            # if flow.coflowId == 0:
+            rcore = self.GetCoreLeastFlow(flows)
+            #  else:
+            #     rcore=self.topo.GetCoreNode(flow.coflowId % self.topo.numOfCores)
+            rcoreId = rcore.nodeId
             self.pathList[srcId, dstId] = [srcId, srcToRId, rcoreId, dstToRId, dstId]
-   
 
     def __del__(self):
         pass