def testGetYaoGraph(self):
# test algorytmu log star MIS dla grafu Yao
n = 200
k = 10
matrix = getYaoGraph(n, k)
# tworzenie sieci
network = Network(matrix)
alg = LogStar(network)
nodes = network.ndList
for node in nodes:
alg.initiateNode(node)
alg.execute()
# sprawdzanie faili
for node in nodes:
# sprawdzanie mozliwosci faila #1
neighIndices = node.neighbors
if node.memory['state'] == 'dominator':
for neighIndex in neighIndices:
self.failIf(nodes[neighIndex].memory['state'] == 'dominator')
elif node.memory['state'] == 'dominated':
dominatedList = [nodes[n].memory['state'] == 'dominated' for n in neighIndices]
self.failIf(all(dominatedList))
else:
self.fail(''.join(['incorrect state after algorithm execution:', node.memory['state']]))
def testUnitDiskGraph(self):
# prosty test na stwierdzenie czy macierz wyglada tak jak trzeba
n = 150
matrix = getUnitDiskGraph(n)
# tworzenie sieci
network = Network(matrix)
alg = LogStar(network)
nodes = network.ndList
for node in nodes:
alg.initiateNode(node)
alg.execute()
# sprawdzanie faili
for node in nodes:
# sprawdzanie mozliwosci faila #1
neighIndices = node.neighbors
if node.memory['state'] == 'dominator':
for neighIndex in neighIndices:
self.failIf(nodes[neighIndex].memory['state'] == 'dominator')
elif node.memory['state'] == 'dominated':
dominatedList = [nodes[n].memory['state'] == 'dominated' for n in neighIndices]
self.failIf(all(dominatedList))
else:
self.fail(''.join(['incorrect state after algorithm execution:', node.memory['state']]))
def testAnswerRequest1(self):
# 1 - tworzenie sieci
adjacencyMatrix = [[0, 1, 1, 1],
[1, 0, 1, 1],
[1, 1, 0, 1],
[1, 1, 1, 0]]
# tworzenie sieci
network = Network(adjacencyMatrix)
# 2 - zapytania do kazdego wezla
alg = LogStar(network)
nodes = network.ndList
for n in nodes:
n.memory['r'] = n.ID
n.memory['state'] = 'competitor'
for n in nodes:
message = alg.answerRequest1(n, Message(0, 0, {}))
if message.infoDict['answer for request 1'] != n.ID:
self.fail()
def testProperMIScomputation(self):
# test sprawdza czy algorytm wylicza MIS bez zadnych faili:
# fail #1 - jesli dwa wezly kolo siebie sa w MIS (sa dominatorami)
# fail #2 - jesli wezel jest otoczony wezlami zdominowanymi i sam jest zdominowany
adjacencyMatrix = getUnitDiskGraph(200)
# tworzenie sieci
network = Network(adjacencyMatrix)
alg = LogStar(network)
nodes = network.ndList
for node in nodes:
alg.initiateNode(node)
alg.execute()
for node in nodes:
# sprawdzanie mozliwosci faila #1
neighIndices = node.neighbors
if node.memory['state'] == 'dominator':
for neighIndex in neighIndices:
self.failIf(nodes[neighIndex].memory['state'] == 'dominator')
elif node.memory['state'] == 'dominated':
dominatedList = [nodes[n].memory['state'] == 'dominated' for n in neighIndices]
self.failIf(all(dominatedList))
else:
self.fail(''.join(['incorrect state after algorithm execution:', node.memory['state']]))
def testCheckIfComputedMIS(self):
adjacencyMatrix = [[0, 1, 1, 1],
[1, 0, 1, 1],
[1, 1, 0, 1],
[1, 1, 1, 0]]
# tworzenie sieci
network = Network(adjacencyMatrix)
alg = LogStar(network)
nodes = network.ndList
# najpierw wszystkie wezly beda nie w MIS
for node in nodes:
node.memory['state'] = 'ruler'
# sprawdzenie
self.failUnless(alg.checkIfComputedMIS(nodes) == False)
# teraz wezel 2 jest dominowany
nodes[2].memory['state'] = 'dominator'
# sprawdzenie
self.failUnless(alg.checkIfComputedMIS(nodes) == False)
# teraz wszystkie wezly sa zdominowane
for node in nodes:
node.memory['state'] = 'dominated'
self.failUnless(alg.checkIfComputedMIS(nodes) == True)
def compute():
MIN = 50
MAX =5000
step = 500
repetitions = 100
adjMatrix = []
alg = None
network = None
tempCommSum = 0
commTimes = []
tempAlgSum = 0
algTimes= []
for n in range(MIN, MAX, step):
tempCommSum = 0
tempAlgSum = 0
for k in range(repetitions):
adjMatrix = getYaoGraph(n, 8)
network = Network(adjMatrix)
alg = LogStar(network)
for node in network.ndList:
alg.initiateNode(node)
alg.execute()
print k
tempAlgSum += alg.roundCounter
tempCommSum += network.algCommRoundCounter
print n, 'time: ', datetime.now()
algTimes.append(tempAlgSum/float(repetitions))
commTimes.append(tempCommSum/float(repetitions))
# print times
fileName = '/home/julka/100_reps/log_star_MIS_yao_graph_comm.txt'
save(commTimes, fileName)
fileName = '/home/julka/100_reps/log_star_MIS_yao_graph_alg.txt'
save(algTimes, fileName)
def testAnswerRequest3(self):
# 1 - tworzenie sieci
adjacencyMatrix = [[0, 1, 1, 1],
[1, 0, 1, 1],
[1, 1, 0, 1],
[1, 1, 1, 0]]
# tworzenie sieci
network = Network(adjacencyMatrix)
# 2 - zapytania do kazdego wezla
alg = LogStar(network)
nodes = network.ndList
# wezel 0 bedzie competitorem
nodes[0].memory['state'] = 'competitor'
message = alg.answerRequest3(nodes[0], Message(0, 0, {}))
if message.infoDict['answer for request 3'] != 'competitor':
self.fail()
# wezel 1 bedzie dominatorem
nodes[1].memory['state'] = 'dominator'
message = alg.answerRequest3(nodes[1], Message(0, 0, {}))
if message.infoDict['answer for request 3'] != 'dominator':
self.fail()
# wezel 2 bedzie zdominowany
nodes[2].memory['state'] = 'dominated'
message = alg.answerRequest3(nodes[2], Message(0, 0, {}))
if message.infoDict['answer for request 3'] != 'dominated':
self.fail()
# wezel 3 bedzie rulerem
nodes[3].memory['state'] = 'ruler'
message = alg.answerRequest3(nodes[3], Message(0, 0, {}))
if message.infoDict['answer for request 3'] != 'ruler':
self.fail()
def testRoundForNode_part1(self):
adjacencyMatrix = [[0, 1, 1, 1],
[1, 0, 1, 1],
[1, 1, 0, 1],
[1, 1, 1, 0]]
# tworzenie sieci
network = Network(adjacencyMatrix)
alg = LogStar(network)
nodes = network.ndList
# 1 - sprawdzenie czy inicjalizacja sie powiodla
network.algorithm = alg
for node in nodes:
alg.initiateNode(node)
for node in nodes:
self.failUnless(node.memory['state'] == 'competitor')
self.failUnless(node.memory['activity'] == 'initiate loop')
def testComputingNewR(self):
# przypadek 1 - wezel ma miec najmniejsze id
nodeID = 10
competitorsID = 12
alg = LogStar(None)
result = alg.computeNewR(nodeID, competitorsID)
self.failUnless(result == 0)
# przypadek 2 - wezel ma miec wieksze id
# 10 to binarnie 10010
# 12 to binarnie 1100
# najwieksa [ozycja na jakiej sie roznia to 3 ( bo praca wymusza liczenie indeksow od 1)
nodeID, competitorsID = competitorsID, nodeID
result = alg.computeNewR(nodeID, competitorsID)
self.failUnless(result == 3)
def testAnswerRequest2(self):
# 1 - tworzenie sieci
adjacencyMatrix = [[0, 1, 1, 1],
[1, 0, 1, 1],
[1, 1, 0, 1],
[1, 1, 1, 0]]
# tworzenie sieci
network = Network(adjacencyMatrix)
# 2 - zapytania do kazdego wezla
alg = LogStar(network)
nodes = network.ndList
for n in nodes:
n.memory['r'] = n.ID
n.memory['state'] = 'competitor'
nodes[1].memory['state'] = 'ruler'
# zakladam, ze wezel nr 0 jest competitorem
# a wezel nr 1 nie jest
# wezel nr 0 ma zwrocic swoje r
# a wezel 1 ma zwrocic None
message = alg.answerRequest2(nodes[0], Message(0, 0, {}))
self.failUnless(message.infoDict['answer for request 2'] == 0)
# drugi test
message = alg.answerRequest2(nodes[1], Message(0, 0, {}))
self.failUnless(message == None)
from algorithm.log_star_MIS import LogStar
from network.network import Network
from graph_tool.all import *
from graph_generators.n_unit_disk_graph import getUnitDiskGraph
n = 30
adjacencyMatrix = getUnitDiskGraph(n)
# tworzenie sieci
network = Network(adjacencyMatrix)
alg = LogStar()
network.algorithm = alg
alg.network = network
nodes = network.ndList
for node in nodes:
alg.initiateNode(node)
network.executeAlgorithm()
# czesc rysujaca
g = Graph(directed=False)
# dodawanie wezlow - indeksowanie bedzie sie zgadzalo
for node in nodes:
g.add_vertex()
# dodawanie krawedzi - tu trzeba isc po macierzy incydencji
