def settInnNode(self, node):
if len(self._listeRacks) == 0:
self._listeRacks.append(Rack())
self._listeRacks[-1].settInn(node)
elif self._noderPerRack > self._listeRacks[-1].getAntNoder():
self._listeRacks[-1].settInn(node)
else:
self._listeRacks.append(Rack())
self._listeRacks[-1].settInn(node)
def settInnNode(self, node):
# sjekker hvis det er ledig plass inn i rack og hvis ikke oppretter jeg en ny
if len(self._rack) == 0:
self._rack.append(Rack())
self._rack[0].settInn(node)
else:
for rack in self._rack:
if rack.getAntNoder() < self._noderPerRack:
rack.settInn(node)
elif self._rack.index(rack) == len(self._rack) - 1:
self._rack.append(Rack())
def settInnNode(self, node):
nyttRack = Rack()
# Lager et nytt rack om det ikke er noen racks i regneklyngen.
if self.antRacks() == 0:
self._regneklynge.append(nyttRack)
# lastRack blir lik det siste rack objektet i self._regneklynge.
lastRack = self._regneklynge[-1]
# Sjekker først om nodene i lastRack er lik maksimum noder per rack.
# Hvis ja, legger jeg til et rack-objekt i regneklynge og setter inn et
# node-objekt.
if lastRack.getAntNoder() == self._noderPerRack:
self._regneklynge.append(nyttRack)
nyttRack.settInn(node)
# Deretter sjekker jeg om nodene i lastRack er færre enn maksimum noder
# per rack.
# Hvis ja, legger jeg til et node-objekt i lastRack.
elif lastRack.getAntNoder() < self._noderPerRack:
lastRack.settInn(node)
# Til slutt, sjekker jeg om nodene i lastRack er flere enn maksimum
# noder per rack.
# Hvis ja, legger jeg til et rack-objekt i regneklynge og setter inn et
# node-objekt i lastRack.
elif lastRack.getAntNoder() > self._noderPerRack:
self._regneklynge.append(nyttRack)
lastRack.settInn(node)
def __init__(self, fabric_config_dict):
if fabric_config_dict.has_key("fabric"):
for key in self.required_keys:
if not fabric_config_dict['fabric'].has_key(key):
util.log_error_and_exit(
"Fabric configuration file is missing " + key)
try:
self.edge_facing_capacity = int(
fabric_config_dict["fabric"]["edge_facing_capacity"])
except ValueError:
util.log_error_and_exit(
"Invalid value found for total edge facing capacity in provided fabric configuration"
)
for rack in fabric_config_dict['fabric']['racks']:
rack['rack_id'] = self.rack_id
self.total_racks += rack['rack_count']
self.racks.append(Rack(rack))
self.rack_facing_capacity += self.racks[
self.
rack_id].total_required_fabric_network_capacity * self.racks[
self.rack_id].rack_count
self.rack_id += 1
self.network_addressing = Network_addressing(
fabric_config_dict['fabric']['addressing'])
print "Total rack facing capacity required: " + str(
self.rack_facing_capacity)
print "Total edge facing capacity required: " + str(
self.edge_facing_capacity)
def settInnNode(self, node):
added = False
if len(self._klynge) < 1:
etRack = Rack()
etRack.settInn(node)
self._klynge.append(etRack)
else:
for rack in self._klynge:
if rack.getAntNoder() < self._noderPerRack:
rack.settInn(node)
added = True
if added == False:
etRack = Rack()
etRack.settInn(node)
self._klynge.append(etRack)
def add_node(self, node):
# Add a new rack if other racks are full
if not self.racks[self.rack_index].has_capacity():
self.racks.append(Rack(self.nodes_per_rack))
self.rack_index += 1
self.racks[self.rack_index].add_node(node)
def __init__(self, id:int):
self.screen_w, self.screen_h = Play.screen.get_size()
self.recipe_id = id
self.__set_level()
self.counter = Counter(self.screen_w, self.screen_h, (0.00, 0.7, 1, 1))
self.rack = Rack(self.screen_w, self.screen_h, self.recipe_id)
self.label = TextBox(self.screen_w // 2, 20, "wybierz produkty według listy i przeciągnij je na ladę",
color=(200, 200, 200))
def settInnNode(self, node):
for j in range(len(self._rk)):
if self._rk[j].getAntNoder() < self.npr:
self._rk[j].settInn(node)
break
elif j == len(
self._rk) - 1 and self._rk[j].getAntNoder() >= self.npr:
self._rk.append(Rack())
self._rk[-1].settInn(node)
def generateThreeLayer(k):
# initialize essential parameters
num_ports_per_switch = k # number of ports per switch
num_pod = k # number of pods
num_servers = int(k/2) # number of hosts under a ToR switch
num_tor = int(k/2) # number of ToR switches in a pod
num_agg = int(k/2) # number of aggregation switches in a pod
num_core = int((k**2)/4) # number of core switches
total_servers = int((k**3)/4) # number of total servers
# initialize component generation
num_racks = num_pod * num_tor
list_of_racks = []
cpu_cores = 16
for i in range(num_racks):
rack = Rack(str(i))
for j in range(num_servers):
server = Server(i*(num_servers)+j,"server"+str(i)+"-"+str(j), cpu_cores)
rack.accumulate(server)
list_of_racks.append(rack)
list_of_tors = []
for i in range(num_tor * num_pod):
tor = Switch("ToR"+str(i), "ToR", k)
list_of_tors.append(tor)
list_of_agg= []
for i in range(num_agg * num_pod):
agg = Switch("Agg"+ str(i), "Agg", k)
list_of_agg.append(agg)
list_of_core = []
for i in range(num_core):
core = Switch("Core"+str(i), "Core", k)
list_of_core.append(core)
list_of_links = []
num_links = int(3 * (k**3) / 4)
capacity = 1024 # Mbits
delay = 1 # ms
for i in range(num_links):
link = Link("link"+str(i), capacity, delay)
list_of_links.append(link)
return list_of_racks, list_of_tors, list_of_agg, list_of_core, list_of_links
def settInnNode(self, node):
"""
Plasserer en node inn i et rack med ledig plass, eller i et nytt
Tar parameter node som er referanse til noden som skal settes inn i datastrukturen
"""
# hvis siste index(rack objekt) har liste som har ikke plass.
#(Den kaller paa metode for rack getAntNoder som sjekker hvor mange noder er i rack)
# Og hvis den lik grense til hvor mange noder det er per Rack. Saa lages det ny rack objekt
# Som har ny liste for noder. Deretter velger den igjen siste objekt i listeRack (dvs. den nyeste
# objekt med tumt liste) Og legger til node
# Men hvis siste rack objekt i _listeRack har plass i sin liste med noder
# saa settes node objekt i den rack objekt liste
if self._listeRacs[-1].getAntNoder() == self._noderPerRack:
self._listeRacs.append(Rack())
self._listeRacs[-1].settInn(node)
elif self._listeRacs[-1].getAntNoder() < self._noderPerRack:
self._listeRacs[-1].settInn(node)
def __init__(self, clusterfile):
#Tar inn txt fila med spisfikasjonene
self._allNodes = clusterfile
#Lager en liste som skal inneholde alle racks, den starter med å lage et rack Objekt
self._listOfRacks = []
self._counter = 0
#Går igjennom alle linjene i tekstfila
for line in self._allNodes:
#Sjekker om det er første linje, da den setter max noder i en rack
if self._counter == 0:
self._maxNodes = int(line)
#Lager en liste som skal inneholde alle racks, den starter med å lage et rack Objekt
self._listOfRacks.append(Rack(self._maxNodes))
#Setter counter = 1 så den kjører else: for resten av fila
self._counter = 1
else:
#Setter nodeMemoProc som en liste med [node, minne, prosessorer]
nodeMemoProc = line.split()
for i in range(int(nodeMemoProc[0])):
self.addNode(int(nodeMemoProc[1]), int(nodeMemoProc[2]))
def leggTilNode(self, prosessorerINode, minneGBINode):
#Opprett nytt Node-objekt m/gjevne verdiar
node = Node(prosessorerINode, minneGBINode)
#sett ingen racks er ledige
ledigeRacks = False
#For kvart element i lista _racks...
for i in self._racks:
#Viss elementet, racket, har ledig plass...
if i.sjekkLedigPlass():
#Legg til noden i racket
i.leggTilNode(node)
#sett at det er ledige racks
ledigeRacks = True
#Om ingen racks er ledige...
if not ledigeRacks:
#Lag eit nytt rack m/kapasitet _noderPerRack
rack = Rack(self._noderPerRack)
#Legg det nye racket inn i lista _racks
self._racks.append(rack)
#Legg noden inn i det nye racket
rack.leggTilNode(node)
def results(tiles, dd, t, rows):
rack = Rack(tiles, dd, t)
cutoffs = {0: 15, 1: 10, 2: 7, 3: 0}
time_0 = time.time()
if rack.num_letters >= cutoffs[min(rack.num_blanks, 3)]:
res = rack.frequency_solve()
solver = 'F'
else:
res = rack.permute_solve()
solver = 'P'
time_1 = time.time()
time_ms = 1000 * (time_1 - time_0)
if len(res) < 1:
print("\nNo valid words found. ({}-Solve runtime: {:.2f} ms)".format(
solver, time_ms))
return
entries = [] # cells of the table
lines = [""] * rows # rows of the table
pad_wc, pad_bc = 4, 8 # padding within column, padding between columns
shift = pad_wc + len(res[0])
for play in res:
spaces = shift - len(play) if len(play) < 10 else shift - 1 - len(play)
entries.append(play + (" " * spaces) + str(len(play)))
print("\nLongest words: ({}-Solve runtime: {:.2f} ms)".format(
solver, time_ms))
for i, entry in enumerate(entries):
spaces = " " * pad_bc if i >= rows else ""
lines[i % rows] += spaces + entry
for line in lines:
if line:
print(line)
def __init__(self, file_name):
self.nodes_per_rack = 0
self.racks = []
# =============================================
# Til deg som retter:
# =============================================
# Spar deg selv og hopp over denne kreften her!
# c':
# ---------------------------------------------
cluster_file = open(file_name)
for line in cluster_file:
if not line.startswith("#") and line.strip():
line = line.split()
if len(line) == 1:
self.nodes_per_rack = int(line[0])
self.racks.append(Rack(self.nodes_per_rack))
self.rack_index = 0
if len(line) == 3:
for i in range(int(line[0])):
self.add_node(Node(int(line[1]), int(line[2])))
cluster_file.close()
def generateTwoLayer(num_of_servers, num_of_racks, num_of_core):
list_of_racks = []
cpu_cores = 1
total_ram = 1.0
total_storage = 1.0
for i in range(num_of_racks):
rack = Rack(str(i))
for j in range(num_of_servers):
server = Server(i*(num_of_servers)+j,"server"+str(i)+"-"+str(j), cpu_cores, total_ram, total_storage)
server.tor = "ToR"+str(i)
rack.accumulate(server)
list_of_racks.append(rack)
list_of_tors = []
for i in range(num_of_racks):
tor = Switch("ToR"+str(i), "ToR", num_of_servers+num_of_core)
list_of_tors.append(tor)
list_of_core = []
for i in range(num_of_core):
core = Switch("Core"+str(i), "Core", num_of_racks)
list_of_core.append(core)
list_of_links = []
num_of_tor_links = int(num_of_servers*num_of_racks)
capacity_tor = 1000 # Mbits
num_of_other_links = int(num_of_racks*num_of_core)
capacity_other = 10000 # Mbits
delay = 90
for i in range(num_of_tor_links):
link = Link("link"+str(i), capacity_tor, delay)
list_of_links.append(link)
for i in range(num_of_other_links):
link = Link("link"+str(num_of_tor_links+i), capacity_other, delay)
list_of_links.append(link)
return list_of_racks, list_of_tors, list_of_core, list_of_links
def __init__(self, filnavn):
"""
Oppretter tom regneklynge for racks
Leser data om regneklynge fra fil, bygger datastrukturen
Tar parameter filnavn, som er navn til fil med data for regneklyngen
"""
self._listeRacs = [
] # liste med alle racks objekter i regneklynge objekt
# Her appender jeg rack objekt, for aa lage den forste rack objekt
# Det hjelper aa lage looper videre, som sjekker om det er nok plass i rack liste.
self._listeRacs.append(Rack())
fil = open(filnavn)
# For loopemn som gaar gjennom alle linjer i fil
self._noderPerRack = int(fil.readline())
for linje in fil:
biter = linje.strip().split() # liste med alle deler i linje
# loopen som gaar gjennom antall noder (biter[0] for antall noder)
for i in range(int(biter[0])):
# node objekt lik Node(minne, prosessorer) - biter[1],biter[2] tok jeg fra liste som ble lagt tidligere
node = Node(int(biter[1]), int(biter[2]))
self.settInnNode(
node
) # bruker metode settInnNode som jobber med de node objektene videre
def newRack(self):
self._listOfRacks.append(Rack(self._maxNodes))
def __init__(self, maksNoder): self._rackListe = [] self._maksNoder = maksNoder self._rackListe.append(Rack(self._maksNoder))
def leggTilNode(self, minne, prosessorer): if self._rackListe[-1].ledigPlass(): self._rackListe[-1].leggTilNode(minne, prosessorer) else: self._rackListe.append(Rack(self._maksNoder)) self._rackListe[-1].leggTilNode(minne, prosessorer)
def solve_tiles(tiles, dd, pref, suff, substring, includes, t=100):
time_0 = time.time()
def get_runtime():
return round(1000 * (time.time() - time_0), 2)
for c in tiles:
if not (65 <= ord(c) <= 90) and not (97 <= ord(c) <= 122) and c != '?':
return ['Invalid Input', get_runtime(), []]
for x in [pref, suff, substring]:
for c in x:
if not (65 <= ord(c) <= 90) and not (97 <= ord(c) <=
122) and c != '-':
return ['Invalid Input', get_runtime(), []]
for c in includes:
if not (65 <= ord(c) <= 90) and not (97 <= ord(c) <= 122):
return ['Invalid Input', get_runtime(), []]
for c in pref + suff + substring:
if c != '-':
tiles += c
rack = Rack(tiles, dd, t, pref, suff, substring, includes)
cutoffs = {0: 15, 1: 10, 2: 7, 3: 0}
if rack.num_letters >= cutoffs[min(rack.num_blanks, 3)]:
res = rack.frequency_solve()
solver = 'F'
else:
res = rack.permute_solve()
solver = 'P'
if len(res) < 1:
return ['No Valid Words', get_runtime(), []]
def blanks(s, r):
nb = r.num_blanks
pool = Counter(r.tiles + r.pref + r.suff + r.substring)
b = ''
res = []
for c in s:
if c not in pool:
b += c
else:
if pool[c] > 0:
pool[c] -= 1
else:
b += c
j = 0
for i in range(len(s)):
if j + 1 > len(b):
return res
if s[i] == b[j]:
j += 1
res.append(i)
return res
return [
'{}-Solve'.format(solver),
get_runtime(),
[[word, len(word), set(blanks(word, rack))] for word in res[:t]]
]
def __init__(self, noderPerRack):
self._rk = [Rack()]
self.npr = noderPerRack # @param noderPerRack max antall noder som kan plasseres i et rack
def handle_config(cmd_parts):
global hardware, hardware_configs
global images, image_configs
global flavors, flavor_configs
global curr_command, racks, instances, instance_on_server, server_instances, machines_on_racks
global hardware_configs_fixed
if (len(cmd_parts) != 4):
sys.stderr.write("ERROR: Invalid command.")
logger.info(curr_command + ": Failure")
return
if (cmd_parts[2] == "--hardware"):
file = cmd_parts[3]
my_file = "../p1_config/" + file
if (os.path.exists(my_file)):
if hardware:
hardware_configs = {}
racks = {}
instances = {}
instance_on_server = {}
server_instances = {}
machines_on_racks = {}
racks = {}
instances = {}
instance_on_server = {}
server_instances = {}
machines_on_racks = {}
hardware_configs_fixed = {}
hardware = True
with open(my_file) as f:
lines = f.readlines()
num_racks = int(lines[0])
for x in range(1, num_racks + 1):
rack = lines[x].split(" ")
r = Rack(rack[0], rack[1])
racks[rack[0]] = r
num_configs = int(lines[num_racks + 1])
for x in range(num_racks + 2, num_racks + num_configs + 2):
cfg = lines[x].split(" ")
h = NewHardware(cfg[0], cfg[1], cfg[2], cfg[3], cfg[4], cfg[5])
hf = NewHardware(cfg[0], cfg[1], cfg[2], cfg[3], cfg[4],
cfg[5])
hardware_configs[cfg[0]] = h
hardware_configs_fixed[cfg[0]] = hf
if machines_on_racks.get(cfg[1]) == None:
machines_on_racks[cfg[1]] = []
machines_on_racks[cfg[1]].append(cfg[0])
sys.stdout.write(
str(len(hardware_configs)) +
' physical servers now available.' + "\n")
logger.info(curr_command + ": Success")
else:
sys.stderr.write("ERROR: File you specified does not exist." +
"\n")
logger.info(curr_command + ": Failure")
elif (cmd_parts[2] == "--images"):
file = cmd_parts[3]
my_file = "../p1_config/" + file
if (os.path.exists(my_file)):
images = True
with open(my_file) as f:
lines = f.readlines()
num_configs = int(lines[0])
for x in range(1, num_configs + 1):
cfg = lines[x].split(" ")
img = NewImage(cfg[0], cfg[1], cfg[2])
image_configs[cfg[0]] = img
sys.stdout.write(
str(len(image_configs)) + ' images now available.' + "\n")
logger.info(curr_command + ": Success")
else:
sys.stderr.write("ERROR: File you specified does not exist." +
"\n")
logger.info(curr_command + ": Failure")
elif (cmd_parts[2] == "--flavors"):
file = cmd_parts[3]
my_file = "../p1_config/" + file
if (os.path.exists(my_file)):
flavors = True
with open(my_file) as f:
lines = f.readlines()
num_configs = int(lines[0])
for x in range(1, num_configs + 1):
cfg = lines[x].split(' ')
flv = Flavor(cfg[0], cfg[1], cfg[2], cfg[3])
flavor_configs[cfg[0]] = flv
sys.stdout.write(
str(len(flavor_configs)) + ' VM flavors now available.' + "\n")
logger.info(curr_command + ": Success")
else:
sys.stderr.write("ERROR: File you specified does not exist." +
"\n")
logger.info(curr_command + ": Failure")
else:
sys.stderr.write("ERROR: Invalid command." + "\n")
logger.info(curr_command + ": Failure")
