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)