def plotCorpus(tests=["KCOV", "RAMINDEX"]):
datas = {}
tmax = 0
cmax = 0
for test in tests:
data = {}
#__data, t, c = __processTest(test);
__data, t, c = loadDataCached("corpus_%s.cache", test, __processTest)
tmax = max(tmax, t)
cmax = max(cmax, c)
if len(__data) < 1:
continue
data[test] = [(v[0], v[1], v[2]) for v in __data]
data[test + " FP"] = [(v[0], v[1], v[3]) for v in __data]
datas[test] = data
for test in datas:
datas[test][test].insert(0, (0, 0, 0))
datas[test][test + " FP"].insert(0, (0, 0, 0))
datas[test][test].append((cmax, tmax, datas[test][test][-1][2]))
datas[test][test + " FP"].append(
(cmax, tmax, datas[test][test + " FP"][-1][2]))
plot(datas[test],
1,
2,
xlabel="Time elapsed (s)",
ylabel="# of corpus",
title="",
outfile="corpus_%s.png" % test,
xmax=tmax)
def __plotWork(test):
# __data = __processTest(test);
__data, exec_time = loadDataCached("work_%s.cache", test, __processTest)
if len(__data) <= 1:
return
# Execute time percentile
for i in range(3):
print(
i, np.percentile(exec_time[i],
50), np.percentile(exec_time[i], 75),
np.percentile(exec_time[i], 90), np.percentile(exec_time[i], 95),
np.percentile(exec_time[i],
99), 2 * np.percentile(exec_time[i], 75) -
np.percentile(exec_time[i], 25))
exec_time_all = exec_time[0] + exec_time[1] + exec_time[2]
print(
"All", np.percentile(exec_time_all, 50),
np.percentile(exec_time_all, 75), np.percentile(exec_time_all, 90),
np.percentile(exec_time_all, 95), np.percentile(exec_time_all, 99),
2 * np.percentile(exec_time_all, 75) -
np.percentile(exec_time_all, 25))
data = {}
for i, key in enumerate(keys):
data[key] = []
for j in range(len(__data)):
# if __data[j][0] < 350000:
data[key].append((__data[j][0], __data[j][1], __data[j][i + 2]))
#plot(data, 0, 2, xlabel="# of executions", ylabel="# of executions", title="", outfile="work_%s.png" % test, ylogscale=False);
plot(data,
1,
2,
xlabel="Time elapsed (hr)",
ylabel="# of executions",
title="",
outfile="work_time_%s.png" % test,
ylogscale=False,
xunit=3600.0)
def plotMAB(tests=["RAMINDEX", "KCOV"]):
data = {}
weight = {}
# Determine whether we should split by module
splitByModule = False
for test in tests:
print(test)
#if not "MAB" in test:
# continue
try:
__data, GLC = loadDataCached('mab_%s.cache', test, __processTest);
print(test, len(__data), __data[-1] if len(__data) > 0 else -1)
print(GLC[0][-1], GLC[1][-1], GLC[2][-1])
name, module, run = getTestParams(test)
print(name, module, run)
if not module in data:
data[module] = {}
if not name in data[module]:
data[module][name] = []
data[module][name].append(__data);
# Pring GLC CDF
'''
label = ["Gain", "Loss", "Cost", "NormGain", "NormLoss", "NormCost"]
for i in range(6):
cdf_data = {
"Generate": [v[i] for v in GLC[0]],
"Mutate": [v[i] for v in GLC[1]],
"Triage": [v[i] for v in GLC[2]],
}
plotCDF(cdf_data, xlabel=label[i], outfile="mab_%s_cdf_%s.png" % (label[i].lower(), test))
'''
except:
traceback.print_exc();
pass;
for module in data:
tmp = {}
keys = ["MABOverhead", "MABSync", "MABDequeue", "MABPoll", "MABUpdate"]
for k in keys:
for name in data[module]:
tmp[name] = averageData(data[module][name], key="ts", value=k, median=False)
plot(tmp, 0, 1, xlabel="Time elapsed (hr)", ylabel=k, outfile="mab_%s_%s.png" % (module, k), xunit=3600.0, xstep=4);
# Per module overhead
for name in data[module]:
tmp = {"Sync": [], "Update": []}
tmp["Sync"] = averageData(data[module][name], key="ts", value="MABSync", median=False)
tmp["Update"] = averageData(data[module][name], key="ts", value="MABUpdate", median=False)
plot(tmp, 0, 1, xlabel="Time elapsed (hr)", ylabel="Overhead (min)", outfile="mab_%s_%s.png" % (module, name), xunit=3600.0, yunit=60.0, xstep=4);
# MAB Prob
mab_prob_tri = {}
mab_prob_mg = {}
for name in data[module]:
if not "TS" in name:
continue
# Probability
mab_prob = {"Generate": [], "Mutate": [], "Triage": []}
mab_prob_tri[name] = []
mab_prob_mg[name] = []
tri = []
mg = []
prob = [[], [], []]
for i in range(len(data[module][name])):
d = data[module][name][i]
for v in d:
ts = v["ts"]
prob[0].append((ts, v["MABProbability"][0]))
prob[1].append((ts, v["MABProbability"][1]))
prob[2].append((ts, v["MABProbability"][2]))
if v["MABProbability"][2] > 0:
tri.append((ts, v["MABProbability"][2]))
if v["MABProbability"][0] > 0 and v["MABProbability"][1] > 0:
mg.append((ts, math.log(v["MABProbability"][1] / v["MABProbability"][0], 10)))
mab_prob["Generate"].append(prob[0])
mab_prob["Mutate"].append(prob[1])
mab_prob["Triage"].append(prob[2])
mab_prob_tri[name].append(tri)
print(tri[-1])
mab_prob_mg[name].append(mg)
for arm in mab_prob:
mab_prob[arm] = averageData(mab_prob[arm], key=0, value=1, bin_size=1800.0, bin_avg=True, median=False)
mab_prob_mg[name] = averageData(mab_prob_mg[name], key=0, value=1, bin_size=1800.0, bin_avg=False, median=False)
mab_prob_tri[name] = averageData(mab_prob_tri[name], key=0, value=1, bin_size=1800.0, bin_avg=False, median=False)
plot(mab_prob, 0, 1, xlabel="Time elapsed (hr)", ylabel="log(Weight)", title="MAB Probability", outfile="mab_probability_%s.png" % name, xunit=3600.0, xstep=4);
plot(mab_prob_tri, 0, 1, xlabel="Time elapsed (hr)", ylabel="Probability", title="", outfile="mab_probability_tri.png", xunit=3600.0, xstep=4);
plot(mab_prob_mg, 0, 1, xlabel="Time elapsed (hr)", ylabel="log(Pr(Mutate) / Pr(Generate))", title="", outfile="mab_probability_mg.png", xunit=3600.0, xstep=4);
def plotWork(tests=["KCOV", "RAMINDEX"]):
'''
for test in tests:
try:
__plotWork(test)
except:
traceback.print_exc()
'''
modules = {}
# Determine whether we should split by module
for test in tests:
print(test)
name, module, run = getTestParams(test)
if not module in modules:
modules[module] = []
modules[module].append(test)
for module in modules:
data = {}
exec_time = []
for test in modules[module]:
try:
__data, exec_time = loadDataCached('work_%s.cache', test,
__processTest)
print(test, len(__data), __data[-1] if len(__data) > 0 else -1)
name, module, run = getTestParams(test)
print(name, module, run)
if not name in data:
data[name] = []
data[name].append(__data)
# Time distribution
tmp = {
"Median": {},
#"99 Percentile": {},
"Q3+IQR": {},
}
__keys = ["Generate", "Mutate", "Triage", "All"]
exec_time.append(exec_time[0] + exec_time[1] + exec_time[2])
print("Percentile: ", percentileofscore(exec_time[3], 1.0))
for i in range(4):
tmp["Median"][__keys[i]] = np.percentile(exec_time[i], 50)
#tmp["99 Percentile"][__keys[i]] = np.percentile(exec_time[i], 99)
tmp["Q3+IQR"][__keys[i]] = 2 * np.percentile(
exec_time[i], 75) + np.percentile(exec_time[i], 25)
print(tmp)
# plotBar1(tmp, ylabel="Time (s)", outfile="work_time_percentile_%s.png" % test)
except:
traceback.print_exc()
continue
# Average / median result
# Time Total
tmp = {}
for name in data:
for job in ["Generate", "Mutate", "Triage"]:
tmp[name + "_" + job] = averageData(data[name],
key="Time_Elapsed",
value="Total_Time_" + job,
bin_size=600)
plot(tmp,
0,
1,
xlabel="Time elapsed (hr)",
ylabel="Time (s)",
outfile="work_%s_time_total.png" % module,
ylogscale=False,
xunit=3600.0,
nmarkers=13,
xstep=4)
tmp = {}
for name in data:
tmp[name + "_All"] = averageData(data[name],
key="Time_Elapsed",
value="Total_Time_All",
bin_size=600)
plot(tmp,
0,
1,
xlabel="Time elapsed (hr)",
ylabel="Time (s)",
outfile="work_%s_time_total_all.png" % module,
ylogscale=False,
xunit=3600.0,
nmarkers=13,
xstep=4)
# Execute Time
tmp = {}
for name in data:
for job in ["Generate", "Mutate", "Triage"]:
tmp[name + "_" + job] = averageData(data[name],
key="Time_Elapsed",
value="Execute_Time_" +
job,
bin_size=600)
plot(tmp,
0,
1,
xlabel="Time elapsed (hr)",
ylabel="Time (s)",
outfile="work_%s_time_execute.png" % module,
ylogscale=False,
xunit=3600.0,
nmarkers=13,
xstep=4)
tmp = {}
for name in data:
tmp[name + "_All"] = averageData(data[name],
key="Time_Elapsed",
value="Execute_Time_All",
bin_size=600)
plot(tmp,
0,
1,
xlabel="Time elapsed (hr)",
ylabel="Time (s)",
outfile="work_%s_time_execute_all.png" % module,
ylogscale=False,
xunit=3600.0,
nmarkers=13,
xstep=4)
# Overall Choices
__plotWorkDist(data,
module=module,
key="Works_Done",
ylabel="Choice",
ylogscale=True)
# Syscalls made
#tmp = {}
#for name in data:
# for job in ["Generate", "Mutate", "Triage"]:
# tmp[name + "_" + job] = averageData(data[name], key="Time_Elapsed", value="Syscalls_Made_" + job, bin_size=600)
#plot(tmp, 0, 1, xlabel="Time elapsed (hr)", ylabel="Syscalls", outfile="work_%s_syscalls.png" % module, ylogscale=False);
# Programs Executed
__plotWorkDist(data,
module=module,
key="Programs_Executed",
ylabel="Programs",
ylogscale=True,
yrange=(1000, 10000000))
def plotCoverage(tests=["RAMINDEX", "KCOV"]):
modules = {}
# Determine whether we should split by module
splitByModule = False
for test in tests:
print(test)
name, module, run = getTestParams(test)
if not module in modules:
modules[module] = []
modules[module].append(test)
cov_median = {}
cov_mean = {}
for module in modules:
data = {}
for test in modules[module]:
try:
__data = loadDataCached('coverage_%s.cache', test, __processTestAltAlt);
print(test, len(__data), __data[-1] if len(__data) > 0 else -1)
name, module, run = getTestParams(test)
print(name, module, run)
#plot({test: __data}, "Time_Elapsed", "Total_Coverage", xlabel="Time elapsed (min)", ylabel="Coverage", title="Coverage", outfile="coverage_%s_time.png" % test);
if not name in data:
data[name] = []
data[name].append(__data);
except:
traceback.print_exc();
pass;
# Cliff's Delta
tmp = {}
for name0 in data:
if "Default" in name0:
continue
for name1 in data:
if not "Default" in name1:
continue
tmp[name0] = cliffsDelta(data[name0], data[name1], key="Time_Elapsed", value="Total_Coverage", bin_size=600)
plot(tmp, 0, 1, xlabel="Time elapsed (hr)", ylabel="Cliff's Delta", outfile="coverage_cd_time.png", xunit=3600.0, nmarkers=13, xstep=4);
# Average / median result
print("Median")
tmp = {}
for name in data:
tmp[name] = averageData(data[name], key="Time_Elapsed", value="Total_Coverage", bin_size=600)
print(name, tmp[name][-1])
cov_median[module.replace('dev-', '').capitalize() + '_' + name] = tmp[name]
plot(tmp, 0, 1, xlabel="Time elapsed (hr)", ylabel="Coverage (1000 edges)", outfile="coverage_%s_time.png" % module, xunit=3600.0, yunit=1000.0, nmarkers=13, xstep=4, legendout=False);
print("25-75")
tmp = {}
for name in data:
tmp[name+"_25%"] = averageData(data[name], key="Time_Elapsed", value="Total_Coverage", bin_size=600, percentile=25)
tmp[name+"_75%"] = averageData(data[name], key="Time_Elapsed", value="Total_Coverage", bin_size=600, percentile=75)
plot(tmp, 0, 1, xlabel="Time elapsed (hr)", ylabel="Coverage (1000 edges)", outfile="coverage_%s_time_2575.png" % module, xunit=3600.0, yunit=1000.0, nmarkers=13, xstep=4, legendout=False);
print("Mean")
tmp = {}
for name in data:
tmp[name] = averageData(data[name], key="Time_Elapsed", value="Total_Coverage", bin_size=600, median=False)
print(name, tmp[name][-1])
cov_mean[module.replace('dev-', '').capitalize() + '_' + name] = tmp[name]
plot(tmp, 0, 1, xlabel="Time elapsed (hr)", ylabel="Coverage (1000 edges)", outfile="coverage_%s_time_mean.png" % module, xunit=3600.0, yunit=1000.0, nmarkers=13, xstep=4);
# Seed count
print("Seed count")
tmp = {}
for name in data:
tmp[name] = averageData(data[name], key="Time_Elapsed", value="Seed_Count", bin_size=600, median=False)
print(name, tmp[name][-1])
cov_mean[module.replace('dev-', '').capitalize() + '_' + name] = tmp[name]
plot(tmp, 0, 1, xlabel="Time elapsed (hr)", ylabel="Number of seeds (1000)", outfile="seed_%s_time.png" % module, xunit=3600.0, yunit=1000.0, nmarkers=13, xstep=4);
#tmp = {}
#for name in data:
# tmp[name] = averageData(data[name], key="Syscall_Count", value="Total_Coverage")
#plot(tmp, 0, 1, xlabel="Syscalls executed", ylabel="Coverage", title="Coverage", outfile="coverage_%s_call.png" % module);
#tmp = {}
#for name in data:
# tmp[name] = averageData(data[name], key="Program_Count", value="Total_Coverage")
#plot(tmp, 0, 1, xlabel="Programs executed", ylabel="Coverage", title="Coverage", outfile="coverage_%s_prog.png" % module);
tmp = {}
for name in data:
tmp[name] = averageData(data[name], key="Time_Elapsed", value="Corpus_Coverage", bin_size=600)
plot(tmp, 0, 1, xlabel="Time elapsed (hr)", ylabel="Corpus Signal", title="Coverage", outfile="corpusSig_%s_time.png" % module, xunit=3600.0, nmarkers=13, xstep=4);
plot(cov_median, 0, 1, xlabel="Time elapsed (hr)", ylabel="Coverage (1000 edges)", outfile="coverage_all_time.png", xunit=3600.0, yunit=1000.0, nmarkers=13, xstep=4);
plot(cov_median, 0, 1, xlabel="Time elapsed (hr)", ylabel="Coverage (1000 edges)", outfile="coverage_all_time_small.png", xunit=3600.0, yunit=1000.0, nmarkers=13, xstep=4, small=True);
plot(cov_mean, 0, 1, xlabel="Time elapsed (hr)", ylabel="Coverage (1000 edges)", outfile="coverage_all_time_mean.png", xunit=3600.0, yunit=1000.0, nmarkers=13, xstep=4);
def plotMutationTree(tests):
datas = {}
for test in tests:
name, module, run = getTestParams(test)
# name = name + '_' + module
datas[name] = {
"Num_Trees": [],
"Tree_Height": [],
"Node_Degree": [],
"Leaf_Nodes": [],
"Leaf_Nodes_Percentage": [],
"Leaf_Nodes_Per_Tree": [],
"Leaf_Nodes_Percentage_Per_Tree": [],
"Tree_Size": [],
"Seed_Subtree_Height": {"Generate": [], "Mutate": [], "Minimize": [], "All": []},
"Seed_Subtree_Size": {"Generate": [], "Mutate": [], "Minimize": [], "All": []}
}
for test in tests:
name, module, run = getTestParams(test)
# name = name + '_' + module
print("Plotting mutation tree for %s" % test)
try:
p_all, p_generated, p_corpus, p_triage, __data = loadDataCached('program_%s.cache', test, __processTest);
for i in range(len(p_all)):
if type(p_all[i]) == dict:
p_all[i] = Program.FromDict(p_all[i])
except:
traceback.print_exc()
continue;
trees, nodes = buildMutationTrees(p_all, p_generated, p_corpus, p_triage)
print(len(trees), len(nodes))
plotForest(trees, nodes, outfile="mt_sample_%s.png" % test)
datas[name]["Num_Trees"].append(len(trees))
num_lf = 0
for r in trees:
# For generation, just consider ones that're mutated
if r.height > 0 and r.size > 1:
datas[name]["Tree_Height"].append(r.height)
datas[name]["Tree_Size"].append(r.size)
degrees = []
visited = set()
l = r.collectDegrees(degrees, visited)
# print(l, len(degrees))
datas[name]["Node_Degree"] += degrees
num_lf += l
datas[name]["Leaf_Nodes_Per_Tree"].append(l)
datas[name]["Leaf_Nodes_Percentage_Per_Tree"].append(l / r.size)
datas[name]["Leaf_Nodes"].append(num_lf)
if len(nodes) > 0:
datas[name]["Leaf_Nodes_Percentage"].append(100.0 * num_lf / len(nodes))
for sig in nodes:
n = nodes[sig]
# datas[name]["Node_Degree"].append(len(n.children))
csig = n.program.sig
if csig in p_corpus:
src = p_all[p_corpus[csig]].corpusSource
if src is not None:
datas[name]["Seed_Subtree_Height"][src].append(n.height)
datas[name]["Seed_Subtree_Size"][src].append(n.size)
datas[name]["Seed_Subtree_Height"]["All"].append(n.height)
datas[name]["Seed_Subtree_Size"]["All"].append(n.size)
# Overall Tree size and height
# plotCDF(datas, key="Tree_Height", xlabel="Tree Height", ylabel="Cumulative # Trees", title="", outfile="mt_height_overall.png", xlogscale=True, raw=True, small=False);
# plotCDF(datas, key="Tree_Size", xlabel="Tree Size", ylabel="Cumulative # Trees", title="", outfile="mt_size_overall.png", xlogscale=True, raw=True, small=False);
plotCDF2([datas, datas], key=["Tree_Size", "Tree_Height"], xlabel=["Tree Size", "Tree Height"], ylabel=["Cumulative # Trees", "Cumulative # Trees"], outfile="mt_size_height_overall.png", xlogscale=[True, True], raw=[True, True]);
# plotCDF(datas, key="Node_Degree", xlabel="Node Degree", ylabel="Cumulative # Nodes", title="", outfile="mt_degree_overall.png", xlogscale=True, raw=True);
#plotCDF(datas, key="Tree_Height", xlabel="Tree Height", ylabel="CDF", title="", outfile="mt_height_overall_cdf.png", xlogscale=False, xrange=(-5,105));
#plotCDF(datas, key="Tree_Size", xlabel="Tree Size", ylabel="CDF", title="", outfile="mt_size_overall_cdf.png", xlogscale=True);
#plotCDF(datas, key="Node_Degree", xlabel="Tree Size", ylabel="CDF", title="", outfile="mt_degree_overall_cdf.png", xlogscale=True);
# Leaf nodes per tree
#plotCDF(datas, key="Leaf_Nodes_Per_Tree", xlabel="# of nodes", ylabel="CDF", title="", outfile="mt_leaf_per_tree_cdf.png", xlogscale=True);
#plotCDF(datas, key="Leaf_Nodes_Percentage_Per_Tree", xlabel="# of nodes", ylabel="CDF", title="", outfile="mt_leaf_per_tree_perc_cdf.png", xlogscale=False);
# Num Trees
tmp = {}
for name in datas:
#tmp["Num_Trees"][name] = datas[name]["Num_Trees"]
tmp[name] = {"Num_Trees": datas[name]["Num_Trees"]}
plotBar1(tmp, ylabel="# Nodes", outfile="mt_num_trees.png")
# Leaf nodes total
tmp = {}
for name in datas:
#tmp["Leaf_Nodes"][name] = datas[name]["Leaf_Nodes"]
tmp[name] = {"Leaf_Nodes": datas[name]["Leaf_Nodes"]}
plotBar1(tmp, ylabel="# Nodes", outfile="mt_leaf_per_forest.png")
tmp = {"Leaf_Nodes_Percentage": {}}
for name in datas:
#tmp["Leaf_Nodes_Percentage"][name] = datas[name]["Leaf_Nodes_Percentage"]
tmp[name] = {"Leaf_Nodes_Percentage": datas[name]["Leaf_Nodes_Percentage"]}
plotBar1(tmp, ylabel="Percentage (%)", outfile="mt_leaf_per_forest_perc.png")
# Sub-tree size, height
tmp = {"Generate": {}, "Mutate": {}, "Minimize": {}, "All": {}}
for src in ["Generate", "Mutate", "Minimize", "All"]:
for name in datas:
tmp[src][name] = datas[name]["Seed_Subtree_Height"][src]
plotCDF(tmp[src], xlabel="Tree height", ylabel="CDF", title="", outfile="mt_subtree_height_cdf_%s.png" % src, xlogscale=False);
tmp = {"Generate": {}, "Mutate": {}, "Minimize": {}, "All": {}}
for src in ["Generate", "Mutate", "Minimize", "All"]:
for name in datas:
tmp[src][name] = datas[name]["Seed_Subtree_Size"][src]
plotCDF(tmp[src], xlabel="Tree height", ylabel="CDF", title="", outfile="mt_subtree_size_cdf_%s.png" % src, xlogscale=True);
def plotCrashes(tests=["KCOV", "RAMINDEX"]):
datas = {}
for test in tests:
name, module, run = getTestParams(test)
name = name + '_' + module
if not name in datas:
datas[name] = []
for test in tests:
name, module, run = getTestParams(test)
name = name + '_' + module
print("Plotting crashes for %s" % test)
__data = None
try:
# p_all, p_generated, p_corpus, p_triage, __data = __processTest(test);
__data = loadDataCached('crashes_%s.cache', test, __processTest)
#__data = __processTest(test)
datas[name].append(__data)
except:
traceback.print_exc()
continue
buildCrashDb(datas)
# Crash count
crash_count = {}
crashes_avg = {}
for name in datas:
crash_count[name] = []
for d in datas[name]:
ts = []
for cid in d:
ts.append(d[cid]["ts"])
ts.sort()
tmp = [(0, 0)] + [(ts[i], i + 1) for i in range(len(ts))]
crash_count[name].append(tmp)
crashes_avg[name] = averageData(crash_count[name],
key=0,
value=1,
bin_size=600)
# print(crash_count[name])
plot(crashes_avg,
0,
1,
xlabel="Time elapsed (hr)",
ylabel="Crahses Found",
title="",
outfile="crashes_time.png",
xunit=3600.0,
nmarkers=12,
xstep=4)
# Cliff's delta
tmp = {}
for name0 in crash_count:
if "Default" in name0:
continue
for name1 in crash_count:
if not "Default" in name1:
continue
tmp[name0] = cliffsDelta(crash_count[name0],
crash_count[name1],
key=0,
value=1,
bin_size=600)
plot(tmp,
0,
1,
xlabel="Time elapsed (hr)",
ylabel="Cliff's Delta",
outfile="crashes_cd_time.png",
xunit=3600.0,
nmarkers=12,
xstep=4)
def plotPrograms(tests=["KCOV", "RAMINDEX"]):
datas = {}
datas_pgsize = {}
datas_cpsize = {}
tmax = 0
cmax = 0
bin_size = 3600
datas_jobpower_sum = {}
datas_seedpower = {}
datas_seednum = {}
datas_seedpower_avg = {}
datas_seedpower_sum = {}
datas_seedpower_sum_avg = {}
datas_mutlp = {}
datas_mutep = {}
datas_mutls = {}
datas_jobpower = {}
for test in tests:
name, module, run = getTestParams(test)
# name = name + '_' + module
if not name in datas_seedpower:
datas_seednum[name] = {
"Generate": [],
"Mutate": [],
"Triage": [],
"All": [],
}
datas_seedpower[name] = {
"Generate": [],
"Mutate": [],
"Triage": [],
"All": [],
}
datas_seedpower_avg[name] = {
"Generate": [],
"Mutate": [],
"Triage": [],
"All": [],
}
datas_seedpower_sum[name] = {
"Generate": [],
"Mutate": [],
"Triage": [],
}
datas_seedpower_sum_avg[name] = {
"Generate": [],
"Mutate": [],
"Triage": [],
"All": [],
}
datas_jobpower_sum[name] = {
"Generate": [],
"Mutate": [],
"Triage": [],
}
datas_jobpower[name] = {
"Generate": [],
"Mutate": [],
"Triage": [],
}
datas_mutls[name] = {
"Total_Mutations": [],
"Last_Eff_Mutation": [],
"Eff_Mutation": []
}
datas_mutlp[name] = []
datas_mutep[name] = []
for test in tests:
name, module, run = getTestParams(test)
# name = name + '_' + module
print("Plotting programs for %s" % test)
try:
# p_all, p_generated, p_corpus, p_triage, __data = __processTest(test);
p_all, p_generated, p_corpus, p_triage, __data = loadDataCached(
'program_%s.cache', test, __processTest)
for i in range(len(p_all)):
if type(p_all[i]) == dict:
p_all[i] = Program.FromDict(p_all[i])
except:
traceback.print_exc()
continue
#plotMutation(p_all, test)
print(len(p_all))
print(len(p_generated))
print(len(p_corpus))
print(len(p_triage))
print(__data[-1])
datas_jobpower_sum[name]["Generate"].append(
__data[-1]["Generate_Coverage"])
datas_jobpower_sum[name]["Mutate"].append(
__data[-1]["Mutate_Coverage"])
datas_jobpower_sum[name]["Triage"].append(
__data[-1]["Minimize_Coverage"])
# Accumulated
datas[test] = {
"Generation":
[(v["Time_Elapsed"], v["Generate_Coverage"]) for v in __data],
"Minimization":
[(v["Time_Elapsed"], v["Minimize_Coverage"]) for v in __data],
"Mutation": [(v["Time_Elapsed"], v["Mutate_Coverage"])
for v in __data],
}
datas_jobpower[name]["Generate"].append(datas[test]["Generation"])
datas_jobpower[name]["Triage"].append(datas[test]["Minimization"])
datas_jobpower[name]["Mutate"].append(datas[test]["Mutation"])
datas[test + "_average"] = {
"Generation":
[(v["Time_Elapsed"], v["Generate_Coverage"] /
v["Generate_Count"] if v["Generate_Count"] > 0 else 0)
for v in __data],
"Minimization":
[(v["Time_Elapsed"], v["Minimize_Coverage"] /
v["Minimize_Count"] if v["Minimize_Count"] > 0 else 0)
for v in __data],
"Mutation": [(v["Time_Elapsed"], v["Mutate_Coverage"] /
v["Mutate_Count"] if v["Mutate_Count"] > 0 else 0)
for v in __data],
}
#plot(datas[test], 0, 1, xlabel="Time elapsed (hr)", ylabel="Total coverage (# edges)", title="", outfile="programs_%s.png" % test, xunit=3600.0);
#plot(datas[test+"_average"], 0, 1, xlabel="Time elapsed (hr)", ylabel="Average coverage (# edges)", title="", outfile="programs_%s_avg.png" % test, ylogscale=True, xunit=3600);
plot2(
(datas[test], datas[test + "_average"]), (0, 0), (1, 1),
xlabel=("Time elapsed (hr)", "Time elapsed (hr)"),
ylabel=("Total coverage (# edges)", "Average coverage (# edges)"),
outfile="programs_coverage_%s.png" % test,
ylogscale=[True, True],
xunit=(3600.0, 3600.0))
# By bins
'''
data_bin = {
"Generate_Coverage": __binSplit(__data, x="Time_Elapsed", y="Generate_Coverage", c="Generate_Count", bin_size=bin_size)[0],
"Minimize_Coverage": __binSplit(__data, x="Time_Elapsed", y="Minimize_Coverage", c="Minimize_Count", bin_size=bin_size)[0],
"Mutate_Coverage": __binSplit(__data, x="Time_Elapsed", y="Mutate_Coverage", c="Mutate_Count", bin_size=bin_size)[0]
}
data_bin_avg = {
"Generate_Coverage": __binSplit(__data, x="Time_Elapsed", y="Generate_Coverage", c="Generate_Count", bin_size=bin_size)[1],
"Minimize_Coverage": __binSplit(__data, x="Time_Elapsed", y="Minimize_Coverage", c="Minimize_Count", bin_size=bin_size)[1],
"Mutate_Coverage": __binSplit(__data, x="Time_Elapsed", y="Mutate_Coverage", c="Mutate_Count", bin_size=bin_size)[1]
}
plotBar(data_bin, 0, 1, width=bin_size, xlabel="Time elapsed (hr)", ylabel="# of signals", title="", outfile="programs_bin_%s.png" % test, xunit=3600.0);
plotBar(data_bin_avg, 0, 1, width=bin_size, xlabel="Time elapsed (hr)", ylabel="# of signals", title="", outfile="programs_bin_avg_%s.png" % test, xunit=3600.0);
'''
# Program size
datas_pgsize[test] = [p.size for p in p_all]
datas_cpsize[test] = []
for psig in p_corpus:
p = p_all[p_corpus[psig]]
#if p_all[p].inCorpus:
datas_cpsize[test].append(p.size)
# Source of seed
seed_source = [0, 0, 0]
for psig in p_corpus:
p = p_all[p_corpus[psig]]
#if p_corpus[p].inCorpus:
if p.corpusSource == "Generate":
seed_source[0] += 1
elif p.corpusSource == "Mutate":
seed_source[1] += 1
elif p.corpusSource == "Minimize":
seed_source[2] += 1
print(seed_source)
# Mutation lifespan
data_ls = {
"Total_Mutations": [],
"Last_Eff_Mutation": [],
"Eff_Mutation": [],
}
data_lp = {
"Lifespan_Percentage": [],
}
data_ep = {
"Eff_Percentage": [],
}
for psig in p_corpus:
p = p_all[p_corpus[psig]]
#if p_corpus[p].inCorpus:
tm = len(p.children)
lm = 0
em = 0
for _c in range(len(p.children)):
c = p_all[p.children[_c]]
if len(c.coverage) > 0:
lm = _c
em += 1
data_ls["Total_Mutations"].append(tm)
data_ls["Last_Eff_Mutation"].append(lm)
data_ls["Eff_Mutation"].append(em)
if tm > 0:
data_lp["Lifespan_Percentage"].append(float(lm) / float(tm))
data_ep["Eff_Percentage"].append(float(em) / float(tm))
else:
data_lp["Lifespan_Percentage"].append(0.0)
data_ep["Eff_Percentage"].append(0.0)
for dn in data_ls:
datas_mutls[name][dn] += data_ls[dn]
datas_mutlp[name] += data_lp["Lifespan_Percentage"]
datas_mutep[name] += data_ep["Eff_Percentage"]
#plotCDF(data_ls, xlabel="# Mutations", ylabel="CDF", title="", outfile="mutations_lifespan_%s.png" % test);
#plotCDF(data_lp, xlabel="Percentage", ylabel="CDF", title="", outfile="mutations_lifespan_percentage_%s.png" % test);
# Seed power
data_seedpower = {
"Generate": [],
"Mutate": [],
"Triage": [],
"All": [],
}
data_seedpower_avg = {
"Generate": [],
"Mutate": [],
"Triage": [],
"All": [],
}
data_seedpower_sum = {"Generate": 0, "Mutate": 0, "Triage": 0}
data_seednum = {"Generate": 0, "Mutate": 0, "Triage": 0, "All": 0}
for psig in p_corpus:
p = p_all[p_corpus[psig]]
#if p.inCorpus:
cov = 0
origin = p.corpusSource
if origin == "Minimize":
origin = "Triage"
if origin is None:
print("WTF")
print(psig)
continue
data_seednum[origin] += 1
data_seednum["All"] += 1
for _c in p.children:
c = p_all[_c]
cov += len(c.coverage)
data_seedpower[origin].append(cov)
data_seedpower["All"].append(cov)
data_seedpower_sum[origin] += cov
if len(p.children) > 0:
data_seedpower_avg[origin].append(cov / len(p.children))
data_seedpower_avg["All"].append(cov / len(p.children))
# print(data_seedpower_avg)
for job in data_seednum:
datas_seednum[name][job].append(data_seednum[job])
for job in datas_seedpower[name]:
datas_seedpower[name][job] += data_seedpower[job]
datas_seedpower_avg[name][job] += data_seedpower_avg[job]
for job in data_seedpower_sum:
datas_seedpower_sum[name][job].append(data_seedpower_sum[job])
datas_seedpower_sum_avg[name][job].append(
data_seedpower_sum[job] / len(data_seedpower[job])
if len(data_seedpower[job]) > 0 else 0.0)
datas_seedpower_sum_avg[name]["All"].append(
(data_seedpower_sum["Generate"] + data_seedpower_sum["Mutate"] +
data_seedpower_sum["Triage"]) / len(data_seedpower["All"])
if len(data_seedpower["All"]) > 0 else 0.0)
tmp = {}
tmp_break = {}
for name in datas_seedpower:
plotCDF(datas_mutls[name],
xlabel="# Mutations",
ylabel="CDF",
title="",
outfile="mutations_lifespan_%s.png" % name,
xrange=(-10, 210),
small=True)
plotCDF(datas_seedpower[name],
xlabel="Coverage",
ylabel="CDF",
title="",
outfile="seed_power_%s.png" % name,
xrange=(-0.5, 1005),
xlogscale=True,
small=False)
plotCDF(datas_seedpower_avg[name],
xlabel="Coverage",
ylabel="CDF",
title="",
outfile="seed_power_avg_%s.png" % name,
xrange=(-0.5, 10),
xlogscale=False,
small=False)
tmp[name] = datas_seedpower[name]["All"]
if "SS" in name:
for job in ["Generate", "Mutate", "Triage"]:
tmp_break[name + "_" + job] = datas_seedpower[name][job]
plotCDF(tmp,
xlabel="Coverage",
ylabel="CDF",
title="",
outfile="seed_power_all.png",
xrange=(-0.5, 1005),
xlogscale=True)
plotCDF(tmp_break,
xlabel="Coverage",
ylabel="CDF",
title="",
outfile="seed_power_breakdown.png",
xrange=(-0.5, 1005),
xlogscale=True)
plotCDF(tmp_break,
xlabel="Coverage",
ylabel="# of seeds",
title="",
outfile="seed_power_breakdown_raw.png",
xrange=(-0.5, 1005),
xlogscale=True,
raw=True)
# Seed power sum
#for name in datas_seedpower_sum:
# for job in datas_seedpower_sum[name]:
# datas_seedpower_sum[name][job] = np.median(datas_seedpower_sum[name][job])
plotBar1(datas_seednum, ylabel="# seeds", outfile="seed_num.png")
print("Seed Numbers")
plotBar1(datas_seedpower_sum,
ylabel="Coverage",
outfile="seed_power_sum.png")
plotBar1(datas_seedpower_sum_avg,
ylabel="Coverage",
outfile="seed_power_sum_avg.png")
plotBar1(datas_jobpower_sum,
ylabel="Coverage (1000 edges)",
outfile="work_power_sum.png",
yunit=1000.0)
plotCDF(datas_mutlp,
xlabel="Percentage",
ylabel="CDF",
title="",
outfile="mutations_lifespan_percentage.png",
xrange=(-0.05, 1.05))
plotCDF(datas_mutep,
xlabel="Percentage",
ylabel="CDF",
title="",
outfile="mutations_eff_percentage.png",
xrange=(-0.05, 1.05))
plotCDF(datas_pgsize,
xlabel="Program Size",
ylabel="CDF",
title="",
outfile="programs_size.png")
plotCDF(datas_cpsize,
xlabel="Corpus Size",
ylabel="CDF",
title="",
outfile="corpus_size.png")
for name in datas_jobpower:
for task in ["Generate", "Mutate", "Triage"]:
datas_jobpower[name][task] = averageData(
datas_jobpower[name][task], key=0, value=1, bin_size=600)
plot(datas_jobpower[name],
0,
1,
xlabel="Time elapsed (hr)",
ylabel="Coverage (1000 edges)",
outfile="work_power_growth_%s.png" % name,
xunit=3600.0,
yunit=1000.0,
nmarkers=13,
xstep=4)