def simpleTest():
radix = 4
M = (2, 2, 4)
algo = "Optimal"
numL2Failure = 0
numL1Failure = 0
numLinkFailure = 1
router = Router(radix)
wiring = load_Wiring(M, algo)
etms = load_ETM(M)
l2fp = set(["c" + str(ci) for ci in range(numL2Failure)])
print("L2 FPS:", l2fp)
l1fps = getL1FP(wiring, numL1Failure)
print("L1 FPS:", l1fps)
linkfps = load_RepLinkFP(M, numLinkFailure, algo)
print("Link FPS:", linkfps)
for l1fp in l1fps:
for linkfp in linkfps:
router.setL2Failure(l2fp)
router.setL1Failure(l1fp)
router.setLinkFailure(linkfp)
scenario = {"router": router, "wiring": wiring, "M": M}
beta = verificationRouter(scenario)
print("Beta =", beta, ": L2-FP =", l2fp, ", L1-FP =", l1fp,
", LK-FP =", linkfp)
def test_L1Failure():
radix = 4
M = (2, 2, 4)
K = len(M)
algo = "Optimal"
wiring = load_Wiring(M, algo)
# Impose L1 switch failure
MRes = (2, 1, 3)
wiringRes = ((0, 0, 0), wiring[1], wiring[2], wiring[3])
print("MRes:", MRes)
print("wiringRes:", wiringRes)
# Impose link failure
lkfp = tuple()
flowSet = fractionalize(radix, MRes, wiringRes)
(flowCount, fgcd, upL1s, downL1s) = flowSet
effCap = 0.5
algoHash = "Optimal"
flowRoute = solveCompactWeight(radix, M, flowSet, lkfp, effCap, algoHash)
weights = resolveWeight(radix, MRes, wiringRes, flowSet, flowRoute)
print_hash_result(radix, M, wiringRes, flowSet, flowRoute, weights)
result = (flowSet, flowRoute, weights)
def computeCompactHash(radix, M, algo, algoHash, lkfp, effCap):
K = len(M)
wiring = load_Wiring(M, algo)
flowSet = fractionalize(radix, M, wiring)
flowRoute = solveCompactWeight(radix, M, flowSet, lkfp, effCap, algoHash)
weights = resolveWeight(radix, M, wiring, flowSet, flowRoute)
hashResult = (flowSet, flowRoute, weights)
return hashResult
def generateRepLinkFailurePatterns(radix, M, algo, minFailedLink,
maxFailedLink):
wiring = load_Wiring(M, algo)
FP = FailurePattern(radix, wiring)
assert minFailedLink >= 0
upperboundFailure = radix**2 / 2
assert maxFailedLink <= upperboundFailure
for numFailure in range(minFailedLink, maxFailedLink + 1):
t = time.time()
fps = FP.setNumFailure(numFailure)
repfps = set()
for fp in fps:
repfps.add(FP.getRepresentative(fp))
save_RepLinkFP(repfps, M, numFailure, algo)
def test_LKFailure():
radix = 4
M = (2, 2, 4)
K = len(M)
algo = "Optimal"
wiring = load_Wiring(M, algo)
flowSet = fractionalize(radix, M, wiring)
(flowCount, fgcd, upL1s, downL1s) = flowSet
# Impose link failure pattern
lkfp = (("e0", "c0"),)
lkfp_id = 0
effCap = 1
algoHash = "Optimal"
flowRoute = solveCompactWeight(radix, M, flowSet, lkfp, effCap, algoHash)
weights = resolveWeight(radix, M, wiring, flowSet, flowRoute)
print_hash_result(radix, M, wiring, flowSet, flowRoute, weights)
result = (flowSet, flowRoute, weights)
save_HashResultSingle(result, M, lkfp_id, algo, algoHash)
fps = set()
for c in comb:
if sum(c) == numFailure:
fps.add(tuple(c))
return fps
def getL1FP(wiring, numFailure):
(groups, gkeys) = deriveSubgroup(wiring)
dists = getL1FailurePatterns(groups, gkeys, numFailure)
fps = set()
for dist in dists:
fp = list()
for gid in xrange(len(groups)):
gk = gkeys[gid]
for i in range(dist[gid]):
fp.append("e" + str(groups[gk][i]))
fps.add(tuple(fp))
return fps
if __name__ == "__main__":
radix = 4
M = (2, 2, 4)
algo = "Optimal"
wiring = load_Wiring(M, algo)
for numFailure in range(radix + 1):
fps = getL1FP(wiring, numFailure)
print(numFailure, fps)