monero-project/research-lab
monero-project/research-lab
1
0
Fork 0
mirror of https://github.com/monero-project/research-lab.git synced 2024-12-22 11:39:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #25 from b-g-goodell/fish

Browse source 
OMG IT WORKED run Graph.py, transcript in output.csv
This commit is contained in:
Brandon Goodell 2018-02-08 16:41:30 -08:00 committed by GitHub
commit c27ea713db
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 65 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
source-code/Poisson-Graphs/Blockchain.py
View file

@ -43,10 +43,12 @@ class Blockchain(object):
for ident in self.leaves:
tempCumDiff = 0.0
thisBlockIdent = ident
tempCumDiff += self.blocks[thisBlockIdent].diff
if self.blocks[thisBlockIdent].diff is not None:
tempCumDiff += self.blocks[thisBlockIdent].diff
while self.blocks[thisBlockIdent].parent is not None:
thisBlockIdent = self.blocks[thisBlockIdent].parent
tempCumDiff += self.blocks[thisBlockIdent].diff
if self.blocks[thisBLockIdent].diff is not None:
tempCumDiff += self.blocks[thisBlockIdent].diff
if tempCumDiff > maxCumDiff:
# If more than one leaf ties for maxCumDiff, each node in the
# network should pick one of these two arbitrarily. Since we

5
source-code/Poisson-Graphs/Edge.py
View file

@ -29,6 +29,7 @@ class Edge(object):
class Test_Edge(unittest.TestCase):
def test_e(self):
params = None
nelly = Node(params)
milly = Node(params)
ed = Edge(params)
@ -36,5 +37,5 @@ class Test_Edge(unittest.TestCase):
self.assertEqual(len(self.nodes),2)
suite = unittest.TestLoader().loadTestsFromTestCase(Test_Edge)
unittest.TextTestRunner(verbosity=1).run(suite)
#suite = unittest.TestLoader().loadTestsFromTestCase(Test_Edge)
#unittest.TextTestRunner(verbosity=1).run(suite)

83
source-code/Poisson-Graphs/Graph.py
View file

@ -29,11 +29,13 @@ class Graph(object):
self.globalTime = deepcopy(self.startTime)
self.birthRate = params[7]
self.deathRate = params[8]
self.data = params[9]
self.filename = params[9]
self.data = params[10]
self.blankBlockchain = Blockchain()
self.blankBlockchain.targetRate = self.data["targetRate"]
self.blankBlockchain.mode = self.data["mode"]
self.blankBlockchain.targetRate = self.targetRate
self.blankBlockchain.mode = self.mode
self.blankBlockchain.diff = 1.0
self._createInit()
@ -41,28 +43,28 @@ class Graph(object):
def _createInit(self):
# For simplicity, all nodes will have a genesis block with t=0.0 and no offset
for i in range(self.numInitNodes):
offset = newOffset()
intens = newIntensity()
offset = newOffset(None)
intens = newIntensity(None)
name = newIdent(len(self.nodes))
dat = {"offset":offset, "intensity":intens, "blockchain":deepcopy(self.blankBlockchain)}
params = {"ident":name, "data":dat, "verbose":self.verbosity, "mode":self.mode, "targetRate":self.targetRate}
nelly = Node(params)
self.nodes.update({nelly.ident:nelly})
t = self.startTime
self.nodes[nelly.ident].generateBlock(t, i)
self.nodes[nelly.ident].generateBlock(t)
touched = {}
for xNode in self.nodes:
for yNode in self.nodes:
notSameNode = (xNode != yNode)
xNodeHasRoom = (len(self.nodes[xNode].edges) < self.maxNeighbors)
yNodeHasRoom = (len(self.ndoes[yNode].edges) < self.maxNeighbors)
yNodeHasRoom = (len(self.nodes[yNode].edges) < self.maxNeighbors)
xyNotTouched = ((xNode, yNode) not in touched)
yxNotTouched = ((yNode, xNode) not in touched)
if notSameNode and xNodeHasRoom and yNodeHasRoom and xyNotTouched and yxNotTouched:
touched.update({(xNode,yNode):True, (yNode,xNode):True})
if random.random() < self.probEdge:
params = [newIdent(len(self.edges)), {}, self.verbosity]
params = [newIdent(len(self.edges)), {"pendingBlocks":{}, "length":random.random()}, self.verbosity]
ed = Edge(params)
ed.nodes.update({xNode:self.nodes[xNode], yNode:self.nodes[yNode]})
self.edges.update({ed.ident:ed})
@ -76,13 +78,13 @@ class Graph(object):
for xNode in self.nodes:
xNodeHasRoom = (len(self.nodes[xNode].edges) < self.maxNeighbors)
iStillHasRoom = (len(neighbors) < self.maxNeighbors)
if xNodeHasRoom and and iStillHasRoom and random.random() < self.probEdge:
if xNodeHasRoom and iStillHasRoom and random.random() < self.probEdge:
neighbors.append(xNode)
newNodeName = newIdent(len(self.nodes))
offset = newOffset()
intens = newIntensity()
offset = newOffset(None)
intens = newIntensity(None)
dat = {"offset":offset, "intensity":intens, "blockchain":deepcopy(self.blankBlockchain)}
params = {"ident":newNodeName, "data":dat, "verbose":self.verbosity, "mode":self.mode, "targetRate":self.targetRate}
newNode = Node(params)
@ -108,7 +110,8 @@ class Graph(object):
leaver = self.nodes[leaverIdent]
neighbors = []
for ed in leaver.edges:
neighbors.append((ed.Ident, ed.getNeighbor(leaverIdent)))
edge = leaver.edges[ed]
neighbors.append((edge.ident, edge.getNeighbor(leaverIdent)))
for neighbor in neighbors:
edIdent = neighbor[0]
neiIdent = neighbor[1]
@ -125,19 +128,24 @@ class Graph(object):
self.nodes[discoIdent].propagate(t, blockIdent)
return out
def eventBlockArrival(self, destNodeIdent, edgeIdent, blockIdent, t):
out = str(t) + ",blockArriv," + str(destNodeIdent) + "," + str(edgeIdent) + "," + str(blockIdent) + ","
destNode = self.nodes[destNodeIdent]
def eventBlockArrival(self, pendingIdent, edgeIdent, t):
out = str(t) + ",blockArriv,"
edge = self.edges[edgeIdent]
block = deepcopy(edge.data["pendingBlocks"][blockIdent])
block.arrivTimestamp = t + self.nodes[destNodeIdent].data["offset"]
self.nodes[destNodeIdent].updateBlockchain({blockIdent:block})
pendingData = edge.data["pendingBlocks"][pendingIdent] # pendingDat = {"timeOfArrival":timeOfArrival, "destIdent":otherIdent, "block":blockToProp}
out += str(pendingData["destIdent"]) + "," + str(edgeIdent) + "," + str(pendingData["block"].ident)
destNode = self.nodes[pendingData["destIdent"]]
edge = self.edges[edgeIdent]
block = deepcopy(pendingData["block"])
block.arrivTimestamp = t + destNode.data["offset"]
destNode.updateBlockchain({block.ident:block})
del edge.data["pendingBlocks"][pendingIdent]
return out
def go(self):
with open(self.filename,"w") as writeFile:
writeFile.write("timestamp,eventId,eventData\n")
eventType = None
while self.globalTime - self.startTime< self.runTime:
u = -1.0*math.log(1.0-random.random())/self.birthRate
eventType = ("nodeJoins", None)
@ -158,30 +166,39 @@ class Graph(object):
edge = self.edges[edgeIdent]
pB = edge.data["pendingBlocks"]
for pendingIdent in pB:
pendingData = pB[pendingIdent] # pendingDat = {"timeOfArrival":timeOfArrival, "destIdent":otherIdent, "block":blockToProp}
pendingData = pB[pendingIdent]
if pendingData["timeOfArrival"] - self.globalTime < u:
eventTime = ("blockArriv", (pendingData["destIdent"], edgeIdent, pendingData["block"]))
eventType = ("blockArriv", pendingIdent, edgeIdent)
u = v
assert eventType is not None
self.globalTime += u
out = ""
if eventTime[0] == "nodeJoins":
if eventType[0] == "nodeJoins":
out = self.eventNodeJoins(self.globalTime)
elif eventTime[0] == "nodeLeaves":
elif eventType[0] == "nodeLeaves":
out = self.eventNodeLeaves(self.globalTime)
elif eventTime[0] == "blockDisco":
out = self.eventBlockDiscovery(eventTime[1], self.globalTime)
elif eventTime[0] == "blockArriv":
out = self.eventBlockArrival(eventTime[1], eventTime[2], eventTime[3], self.globalTime)
elif eventType[0] == "blockDisco":
out = self.eventBlockDiscovery(eventType[1], self.globalTime)
elif eventType[0] == "blockArriv":
out = self.eventBlockArrival(eventType[1], eventType[2], self.globalTime)
else:
print("WHAAAA")
with open(self.filename, "a") as writeFile:
writeFile.write(out + "\n")
mode = "Nakamoto"
targetRate = 1.0/600000.0
numInitNodes = 10
maxNeighbors = 8
probEdge = 0.1
verbosity = True
startTime = time.time()
runTime = 10.0
globalTime = startTime
birthRate = 1.0/10.0
deathRate = 0.99*1.0/10.0
filename = "output.csv"
greg = Graph([mode, targetRate, numInitNodes, maxNeighbors, probEdge, verbosity, runTime, birthRate, deathRate, filename, []])
greg.go()

14
source-code/Poisson-Graphs/Node.py
View file

@ -29,9 +29,9 @@ class Node(object):
t = discoTime
s = t+self.data["offset"]
diff = self.data["blockchain"].diff
params = {"ident":name, "disco":t, "arriv":s, "parent":None, "diff":diff}
params = {"ident":newName, "disco":t, "arriv":s, "parent":None, "diff":diff}
newBlock = Block(params)
self.data["blockchain"].addBlock(newBlock, mode, tr)
self.data["blockchain"].addBlock(newBlock)
return newName
def updateBlockchain(self, incBlocks):
@ -43,7 +43,7 @@ class Node(object):
if key in self.data["blockchain"].blocks:
del tempData[key]
elif incBlocks[key].parent in self.data["blockchain"].blocks or incBlocks[key].parent is None:
self.data["blockchain"].addBlock(incBlocks[key], self.mode, self.targetRate)
self.data["blockchain"].addBlock(incBlocks[key])
del tempData[key]
incBlocks = deepcopy(tempData)
while len(incBlocks)>0:
@ -58,13 +58,13 @@ class Node(object):
def propagate(self, timeOfProp, blockIdent):
for edgeIdent in self.edges:
edge = self.edges[edgeIdent]
length = e.data["length"]
length = edge.data["length"]
timeOfArrival = timeOfProp + length
otherIdent = e.getNeighbor(self.ident)
other = e.nodes[otherIdent]
otherIdent = edge.getNeighbor(self.ident)
other = edge.nodes[otherIdent]
bc = other.data["blockchain"]
if blockIdent not in bc.blocks:
pB = e.data["pendingBlocks"]
pB = edge.data["pendingBlocks"]
pendingIdent = newIdent(len(pB))
mybc = self.data["blockchain"]
blockToProp = mybc.blocks[blockIdent]