def cmd_runeval(argv):
assert argv[0] == "runeval"
if len(argv) < 3:
print "usage: %s [--weighted] <number of pairs> <graph file path> [<graph file path> ...]" % (argv[0])
print " <number of pairs> can be <= 0 to mean: all possible non-ordered pairs (the graph should not be too big)."
sys.exit(-1)
pass
startdateSecs = int(time.time())
print "start date: [%s]" % (time.ctime())
print "eval3.Revision: [%s]" % (Revision)
print "utils.Revision: [%s]" % (utils.Revision)
print "approach2.Revision: [%s]" % (approach2.Revision)
weighted = False
argvidx = 1
if argv[argvidx] == "--weighted":
weighted = True
argvidx += 1
pass
numberOfPairsToTry = int(argv[argvidx])
argvidx += 1
print "number of pairs to try: [%d]\n" % numberOfPairsToTry
fileResults3 = []
for filename in argv[argvidx:]:
fileResult3 = evalOneFile(
filename, numberOfPairsToTry=numberOfPairsToTry, pairIsOrdered=False, weighted=weighted
)
fileResults3.append(fileResult3)
pass
enddateSecs = int(time.time())
evalResult3 = EvalResult3(
numberOfPairsToTry,
False,
startdateSecs,
enddateSecs,
fileResults3,
revision=Revision,
utilsRevision=utils.Revision,
approach2Revision=approach2.Revision,
weighted=weighted,
)
pickleFilename = "detourDistributionResult.pickle_%s" % (
time.strftime("%m%d%y_%H%M%S", time.localtime(startdateSecs))
)
utils.pickleStuff(pickleFilename, evalResult3)
pass
def evalOneFile(filename, headerLengthThreshold, partialResultSize, outputDir,
numberOfPairsToTry=None, pairIsOrdered=False,
weighted=False,
srcStartIdx=None, srcEndIdx=None,
):
def addHdrLen(countsDict, hdrlen):
if hdrlen in countsDict:
countsDict[hdrlen] += 1
pass
else:
countsDict[hdrlen] = 1
pass
return
def evalOnePair(s, d, hdrLenCounts, pairsWithLargeEncodings):
pp, dp = approach2.getDg(g, s, d, weighted)
if (not pp):
print 'no path: s,d="%s","%s"' % (s,d)
return
if dp == None:
dp = {}
pass
hdrLen4 = codec4.encode(
pp, dp, lli, s, d,
roundUpToMultipleBits=8)
if hdrLen4 > headerLengthThreshold:
pairsWithLargeEncodings.append((s,d))
pass
addHdrLen(hdrLenCounts, hdrLen4)
return
#########
startdateSecs = int(time.time())
print '''
_______________________________________________
filename: [%s]
start date: [%s]
''' % (filename, time.ctime(startdateSecs))
g, lli = utils.textToG(filename, useInt=False)
allNodes = tuple(sorted(g.nodes()))
numNodes = len(allNodes)
i = 0
assert (numberOfPairsToTry != None) ^ (srcStartIdx != None or srcEndIdx != None)
pairsWithLargeEncodings = []
hdrLenCounts = {}
if numberOfPairsToTry != None and numberOfPairsToTry > 0:
srcDstPairs = set()
while i < numberOfPairsToTry:
# this is crypto random integer
idx1 = (struct.unpack('I', os.urandom(4))[0]) % numNodes
idx2 = (struct.unpack('I', os.urandom(4))[0]) % numNodes
while idx2 == idx1:
idx2 = (struct.unpack('I', os.urandom(4))[0]) % numNodes
pass
s,d = allNodes[idx1], allNodes[idx2]
if (s,d) in srcDstPairs:
# definitely skip
print 'pair (%s,%s) already encountered -> skip' % (s,d)
continue
elif (d,s) in srcDstPairs:
# not seen (s,d) yet but seen (d,s), should skip or not?
if not pairIsOrdered:
print 'pairs are not ordered, and (%s,%s) already encountered -> skip' % (d,s)
continue
pass
# do this so we know we have seen this (s, d) pair
srcDstPairs.add((s, d))
print 's,d="%s","%s"' % (s,d)
evalOnePair(s,d, hdrLenCounts, pairsWithLargeEncodings)
i += 1
pass # end while i < numberOfPairsToTry
pass # end if numberOfPairsToTry > 0
elif numberOfPairsToTry != None and numberOfPairsToTry <= 0:
# numberOfPairsToTry is <= 0, so we do all (un-ordered)
# pairs. the graph'd better be not too big.
for i in xrange(numNodes):
for j in xrange(i + 1, numNodes):
s = allNodes[i]
d = allNodes[j]
print 's,d="%s","%s"' % (s,d)
evalOnePair(s, d, hdrLenCounts, pairsWithLargeEncodings)
pass
pass
pass
else:
assert srcStartIdx != None or srcEndIdx != None
if srcStartIdx == None:
srcStartIdx = 0
pass
assert 0 <= srcStartIdx < numNodes
if srcEndIdx == None:
srcEndIdx = numNodes - 1
pass
assert 0 <= srcEndIdx < numNodes
assert srcStartIdx <= srcEndIdx
numSrcsProcessed = 0
curPartialSrcRange = []
for si in xrange(srcStartIdx, srcEndIdx+1):
s = allNodes[si]
if len(curPartialSrcRange) == 0:
curPartialSrcRange.append(si)
startdateSecs = int(time.time())
pass
for d in allNodes:
if d != s:
evalOnePair(s, d, hdrLenCounts, pairsWithLargeEncodings)
pass
pass
numSrcsProcessed += 1
if numSrcsProcessed == partialResultSize:
# pickle the partial result and re-init the vars
curPartialSrcRange.append(si)
enddateSecs = int(time.time())
pr = PartialResult(
filename, startdateSecs, enddateSecs,
pairsWithLargeEncodings,
hdrLenCounts=hdrLenCounts,
srcIdxRange=(curPartialSrcRange[0], curPartialSrcRange[1]),
)
pickleFilepath = '%s/partialResult_%u_%u' % (
outputDir, curPartialSrcRange[0], curPartialSrcRange[1])
utils.pickleStuff(pickleFilepath, pr)
# re-init
del hdrLenCounts, pairsWithLargeEncodings, curPartialSrcRange
hdrLenCounts = {}
# be < 256 (bytes)
pairsWithLargeEncodings = []
curPartialSrcRange = []
numSrcsProcessed = 0
pass
pass
# the last bunch might not have reached partialResultSize
if len(hdrLenCounts) > 0:
curPartialSrcRange.append(si)
enddateSecs = int(time.time())
pr = PartialResult(
filename, startdateSecs, enddateSecs,
pairsWithLargeEncodings,
hdrLenCounts=hdrLenCounts,
srcIdxRange=(curPartialSrcRange[0], curPartialSrcRange[1]),
)
pickleFilepath = '%s/partialResult_%u_%u' % (
outputDir, curPartialSrcRange[0], curPartialSrcRange[1])
utils.pickleStuff(pickleFilepath, pr)
pass
pass
return
# pickle the partial result and re-init the vars
enddateSecs = int(time.time())
partialResultNum += 1
pr = PartialResult(
filename, startdateSecs, enddateSecs,
codec2HdrLen_stretchToCounts=codec2HdrLen_stretchToCounts,
codec4HdrLen_stretchToCounts=codec4HdrLen_stretchToCounts,
singlePath_encodingLen_counts=singlePath_encodingLen_counts,
dagSize_stretchToCounts=dagSize_stretchToCounts,
pairsWithLargeCodec4Encodings=pairsWithLargeCodec4Encodings,
lowerBoundCounts=lowerBoundCounts,
pairsWithDagSizeSmallerThanLowerBound=pairsWithDagSizeSmallerThanLowerBound,
argv=argv, seed=seed, weighted=weighted)
pickleFilepath = '%s/partialResult_srcIdx_%u_%u_num_%u' % (
outputDir, srcStartIdx, srcEndIdx, partialResultNum)
utils.pickleStuff(pickleFilepath, pr)
# re-init
startdateSecs = enddateSecs
lowerBoundCounts = {}
pairsWithLargeCodec4Encodings = {}
pairsWithDagSizeSmallerThanLowerBound = {}
dagSize_stretchToCounts = {}
codec2HdrLen_stretchToCounts = {}
codec4HdrLen_stretchToCounts = {}
singlePath_encodingLen_counts = {}
for stretch in stretches:
dagSize_stretchToCounts[stretch] = {}
codec2HdrLen_stretchToCounts[stretch] = {}
codec4HdrLen_stretchToCounts[stretch] = {}
pairsWithLargeCodec4Encodings[stretch] = []
pairsWithDagSizeSmallerThanLowerBound[stretch] = []
def evalOneFile(filename, headerLengthThreshold,
numberOfPairsToTry, pairIsOrdered,
partialResultSize, outputDir,
argv,
weighted, seed=None,
srcStartIdx=None, srcEndIdx=None,
):
def addValueCount(countsDict, value):
if value in countsDict:
countsDict[value] += 1
pass
else:
countsDict[value] = 1
pass
return
#####
def evalOnePair(g, lli, s, d,
lowerBoundCounts,
dagSize_stretchToCounts,
pairsWithDagSizeSmallerThanLowerBound,
codec2HdrLen_stretchToCounts,
codec4HdrLen_stretchToCounts,
pairsWithLargeCodec4Encodings,
M):
lowerBound = None
for stretch in stretches:
pp, dp = getDgWithStretch(g, s, d, weighted, stretch)
if (not pp):
print 'no path: s,d="%s","%s"' % (s,d)
return
if dp == None:
dp = {}
pass
dag, virtualDetourPaths = approach2.getDagWithVnodes(
pp, dp, returnDetourPathsWithVNodes=True)
codec2HdrLen = codec2.encode(
dag, pp, virtualDetourPaths, lli, False, s, d,
useLinkIdLenPrefix=False,
roundUpToMultipleBits=8)[0]
addValueCount(codec2HdrLen_stretchToCounts[stretch], codec2HdrLen)
codec4HdrLen = codec4.encode(
pp, dp, lli, s, d, roundUpToMultipleBits=8)
addValueCount(codec4HdrLen_stretchToCounts[stretch], codec4HdrLen)
dagSize = dag.number_of_edges()
addValueCount(dagSize_stretchToCounts[stretch], dagSize)
if codec4HdrLen > headerLengthThreshold:
pairsWithLargeCodec4Encodings[stretch].append((s,d))
pass
if lowerBound is None:
lowerBound = computeBounds(g, s, d, pp, M, weighted)
addValueCount(lowerBoundCounts, lowerBound)
pass
if dagSize < lowerBound:
pairsWithDagSizeSmallerThanLowerBound[stretch].append((s,d))
pass
pass
return
#########
startdateSecs = int(time.time())
print '''
_______________________________________________
filename: [%s]
start date: [%s]
''' % (filename, time.ctime(startdateSecs))
g, lli = utils.textToG(filename, useInt=False, ignoreWeights=False)
allNodes = tuple(g.nodes())
numNodes = len(allNodes)
i = 0
assert pairIsOrdered, 'un-ordered currently not supported'
srcDstPairs = set()
assert (numberOfPairsToTry != None)
if not seed:
seed = int(time.time())
pass
randObj = random.Random(seed)
if srcStartIdx is None:
srcStartIdx = 0
pass
else:
assert srcStartIdx >= 0
pass
if srcEndIdx is None:
srcEndIdx = numNodes - 1
pass
else:
assert srcEndIdx <= numNodes - 1
pass
assert srcStartIdx <= srcEndIdx
# calculate M for computeBounds()
if weighted:
weights = map(lambda (u, v, edgeData): edgeData['weight'],
g.edges(data=True))
maxWeight = max(weights)
minWeight = min(weights)
assert minWeight > 0
M = float(maxWeight) / float(minWeight)
pass
else:
M = float(1)
pass
lowerBoundCounts = {}
pairsWithLargeCodec4Encodings = {}
pairsWithDagSizeSmallerThanLowerBound = {}
dagSize_stretchToCounts = {}
codec2HdrLen_stretchToCounts = {}
codec4HdrLen_stretchToCounts = {}
for stretch in stretches:
dagSize_stretchToCounts[stretch] = {}
codec2HdrLen_stretchToCounts[stretch] = {}
codec4HdrLen_stretchToCounts[stretch] = {}
pairsWithLargeCodec4Encodings[stretch] = []
pairsWithDagSizeSmallerThanLowerBound[stretch] = []
pass
if numberOfPairsToTry > 0:
# must be <= the number of possible ordered pairs
assert numberOfPairsToTry <= ((srcEndIdx - srcStartIdx + 1) * (numNodes - 1)), '%u must be <= than %u' % (numberOfPairsToTry, ((srcEndIdx - srcStartIdx + 1) * (numNodes - 1)))
numPairsProcessed = 0
partialResultNum = 0
i = 0
startdateSecs = int(time.time())
while i < numberOfPairsToTry:
idx1 = randObj.randint(srcStartIdx, srcEndIdx) # inclusive
idx2 = randObj.randint(0, numNodes - 1)
while idx2 == idx1:
idx2 = randObj.randint(0, numNodes - 1)
pass
s,d = allNodes[idx1], allNodes[idx2]
if (s,d) in srcDstPairs:
# definitely skip
print 'pair (%s,%s) already encountered -> skip' % (s,d)
continue
## elif (d,s) in srcDstPairs:
## # not seen (s,d) yet but seen (d,s), should skip or not?
## if not pairIsOrdered:
## print 'pairs are not ordered, and (%s,%s) already encountered -> skip' % (d,s)
## continue
## pass
# do this so we know we have seen this (s, d) pair
srcDstPairs.add((s, d))
print 's,d="%s","%s"' % (s,d)
evalOnePair(g=g, lli=lli, s=s, d=d,
lowerBoundCounts=lowerBoundCounts,
dagSize_stretchToCounts=dagSize_stretchToCounts,
pairsWithDagSizeSmallerThanLowerBound=pairsWithDagSizeSmallerThanLowerBound,
codec2HdrLen_stretchToCounts=codec2HdrLen_stretchToCounts,
codec4HdrLen_stretchToCounts=codec4HdrLen_stretchToCounts,
pairsWithLargeCodec4Encodings=pairsWithLargeCodec4Encodings,
M=M)
numPairsProcessed += 1
if 0 == (numPairsProcessed % partialResultSize):
# pickle the partial result and re-init the vars
enddateSecs = int(time.time())
partialResultNum += 1
pr = PartialResult(
filename, startdateSecs, enddateSecs,
codec2HdrLen_stretchToCounts=codec2HdrLen_stretchToCounts,
codec4HdrLen_stretchToCounts=codec4HdrLen_stretchToCounts,
dagSize_stretchToCounts=dagSize_stretchToCounts,
pairsWithLargeCodec4Encodings=pairsWithLargeCodec4Encodings,
lowerBoundCounts=lowerBoundCounts,
pairsWithDagSizeSmallerThanLowerBound=pairsWithDagSizeSmallerThanLowerBound,
argv=argv, seed=seed, weighted=weighted)
pickleFilepath = '%s/partialResult_srcIdx_%u_%u_num_%u' % (
outputDir, srcStartIdx, srcEndIdx, partialResultNum)
utils.pickleStuff(pickleFilepath, pr)
# re-init
startdateSecs = enddateSecs
lowerBoundCounts = {}
pairsWithLargeCodec4Encodings = {}
pairsWithDagSizeSmallerThanLowerBound = {}
dagSize_stretchToCounts = {}
codec2HdrLen_stretchToCounts = {}
codec4HdrLen_stretchToCounts = {}
for stretch in stretches:
dagSize_stretchToCounts[stretch] = {}
codec2HdrLen_stretchToCounts[stretch] = {}
codec4HdrLen_stretchToCounts[stretch] = {}
pairsWithLargeCodec4Encodings[stretch] = []
pairsWithDagSizeSmallerThanLowerBound[stretch] = []
pass
pass
i += 1
pass # end while i < numberOfPairsToTry
pass # end if numberOfPairsToTry > 0
else:
# numberOfPairsToTry is <= 0, so we do all (ordered)
# pairs. the graph'd better be not too big.
numPairsProcessed = 0
partialResultNum = 0
startdateSecs = int(time.time())
for i in xrange(srcStartIdx, srcEndIdx + 1):
s = allNodes[i]
for j in xrange(numNodes):
if j == i:
continue
d = allNodes[j]
print 's,d="%s","%s"' % (s,d)
evalOnePair(g=g, lli=lli, s=s, d=d,
lowerBoundCounts=lowerBoundCounts,
dagSize_stretchToCounts=dagSize_stretchToCounts,
pairsWithDagSizeSmallerThanLowerBound=pairsWithDagSizeSmallerThanLowerBound,
codec2HdrLen_stretchToCounts=codec2HdrLen_stretchToCounts,
codec4HdrLen_stretchToCounts=codec4HdrLen_stretchToCounts,
pairsWithLargeCodec4Encodings=pairsWithLargeCodec4Encodings,
M=M)
numPairsProcessed += 1
if 0 == (numPairsProcessed % partialResultSize):
# pickle the partial result and re-init the vars
enddateSecs = int(time.time())
partialResultNum += 1
pr = PartialResult(
filename, startdateSecs, enddateSecs,
codec2HdrLen_stretchToCounts=codec2HdrLen_stretchToCounts,
codec4HdrLen_stretchToCounts=codec4HdrLen_stretchToCounts,
dagSize_stretchToCounts=dagSize_stretchToCounts,
pairsWithLargeCodec4Encodings=pairsWithLargeCodec4Encodings,
lowerBoundCounts=lowerBoundCounts,
pairsWithDagSizeSmallerThanLowerBound=pairsWithDagSizeSmallerThanLowerBound,
argv=argv, seed=seed, weighted=weighted)
pickleFilepath = '%s/partialResult_srcIdx_%u_%u_num_%u' % (
outputDir, srcStartIdx, srcEndIdx, partialResultNum)
utils.pickleStuff(pickleFilepath, pr)
# re-init
startdateSecs = enddateSecs
lowerBoundCounts = {}
pairsWithLargeCodec4Encodings = {}
pairsWithDagSizeSmallerThanLowerBound = {}
dagSize_stretchToCounts = {}
codec2HdrLen_stretchToCounts = {}
codec4HdrLen_stretchToCounts = {}
for stretch in stretches:
dagSize_stretchToCounts[stretch] = {}
codec2HdrLen_stretchToCounts[stretch] = {}
codec4HdrLen_stretchToCounts[stretch] = {}
pairsWithLargeCodec4Encodings[stretch] = []
pairsWithDagSizeSmallerThanLowerBound[stretch] = []
pass
pass
pass
pass
pass
# the last bunch might not have reached partialResultSize
if len(lowerBoundCounts) > 0:
enddateSecs = int(time.time())
partialResultNum += 1
pr = PartialResult(
filename, startdateSecs, enddateSecs,
codec2HdrLen_stretchToCounts=codec2HdrLen_stretchToCounts,
codec4HdrLen_stretchToCounts=codec4HdrLen_stretchToCounts,
dagSize_stretchToCounts=dagSize_stretchToCounts,
pairsWithLargeCodec4Encodings=pairsWithLargeCodec4Encodings,
lowerBoundCounts=lowerBoundCounts,
pairsWithDagSizeSmallerThanLowerBound=pairsWithDagSizeSmallerThanLowerBound,
argv=argv, seed=seed, weighted=weighted)
pickleFilepath = '%s/partialResult_srcIdx_%u_%u_num_%u' % (
outputDir, srcStartIdx, srcEndIdx, partialResultNum)
utils.pickleStuff(pickleFilepath, pr)
pass
return
