def main():
bitcodeFile = sys.argv[1]
searchConfigFile = sys.argv[2]
originalConfigFile = sys.argv[3]
# delete log file if exists
try:
os.remove("log.dd")
except OSError:
pass
searchConfig = json.loads(open(searchConfigFile, 'r').read())
originalConfig = json.loads(open(originalConfigFile, 'r').read())
changes = searchConfig["config"]
changeSet = []
typeSet = []
for change in changes:
typeList = change.values()[0]["type"]
if isinstance(typeList, list):
typeSet.append(typeList)
changeSet.append(change.values()[0])
print "Searching for valid config using delta-debugging algorithm..."
to_highest_precision(changeSet, typeSet)
while not is_empty(typeSet):
search_config(changeSet, typeSet, searchConfig, bitcodeFile,
searchConfig, originalConfig)
print "Check valid_" + bitcodeFile + ".json for the valid config file"
utilities.print_config(searchConfig, "valid_" + bitcodeFile + ".json")
utilities.print_diff(searchConfig, originalConfig,
"diff_" + bitcodeFile + ".json")
def random_local_search_config(change_set, type_set, switch_set, search_config,
original_config, bitcode, div, original_score,
count):
initial_change_set = []
for i in range(len(change_set)):
initial_change_set.append(change_set[i]["type"])
#print initial_change_set
while (count > 0):
lower = False
while (not lower):
if is_bottom(initial_change_set):
return
lower = randomly_to_2nd_highest_precision(change_set, type_set,
switch_set,
initial_change_set)
count = count - 1
if run_config(
search_config, original_config, bitcode, original_score
) == 1 and utilities.get_dynamic_score() <= original_score:
initial_change_set = []
for i in range(len(change_set)):
initial_change_set.append(change_set[i]["type"])
utilities.print_config(search_config,
"final_config_from_random_search.json")
fp = open('log.dd', 'a')
fp.write(".......................................\n")
fp.close()
def main():
bitcodeFile = sys.argv[1]
searchConfigFile = sys.argv[2]
originalConfigFile = sys.argv[3]
# delete log file if exists
try:
os.remove("log.dd")
except OSError:
pass
searchConfig = json.loads(open(searchConfigFile, 'r').read())
originalConfig = json.loads(open(originalConfigFile, 'r').read())
changes = searchConfig["config"]
changeSet = []
typeSet = []
for change in changes:
typeList = change.values()[0]["type"]
if isinstance(typeList, list):
typeSet.append(typeList)
changeSet.append(change.values()[0])
print "Searching for valid config using delta-debugging algorithm..."
to_highest_precision(changeSet, typeSet)
while not is_empty(typeSet):
search_config(changeSet, typeSet, searchConfig, bitcodeFile, searchConfig, originalConfig)
print "Check valid_" + bitcodeFile + ".json for the valid config file"
utilities.print_config(searchConfig, "valid_" + bitcodeFile + ".json")
utilities.print_diff(searchConfig, originalConfig, "diff_" + bitcodeFile + ".json")
def main():
global search_counter
bitcode = sys.argv[1]
search_conf_file = sys.argv[2]
original_conf_file = sys.argv[3]
#
# delete log file if exists
#
try:
os.remove("log.dd")
except OSError:
pass
#
# parsing config files
#
search_conf = json.loads(open(search_conf_file, 'r').read())
original_conf = json.loads(open(original_conf_file, 'r').read())
search_changes = search_conf["config"]
change_set = []
type_set = []
#
# record the change set
#
for search_change in search_changes:
type_vector = search_change.values()[0]["type"]
if isinstance(type_vector, list):
type_set.append(type_vector)
change_set.append(search_change.values()[0])
#
# search for valid configuration
#
print "Searching for valid configuration using delta-debugging algorithm ..."
# get original score
utilities.to_highest_precision(change_set, type_set)
utilities.run_config(search_conf, original_conf, bitcode, search_counter)
original_score = utilities.get_dynamic_score(search_counter) * 1.05
search_counter = search_counter + 1
# keep searching while the type set is not searched throughout
while not utilities.is_empty(type_set):
search_config(change_set, type_set, search_conf, original_conf, bitcode, original_score)
# get the score of modified program
utilities.run_config(search_conf, original_conf, bitcode, search_counter)
modified_score = utilities.get_dynamic_score(search_counter)
search_counter = search_counter + 1
if modified_score <= original_score:
print "Check valid_" + bitcode + ".json for the valid configuration file"
# print valid configuration file and diff file
utilities.print_config(search_conf, "dd2_valid_" + bitcode + ".json")
utilities.print_diff(search_conf, original_conf, "dd2_diff_" + bitcode + ".json")
else:
print "No configuration is found!"
def main():
"""
main function receives
- argv[1] : bitcode file location
- argv[2] : search file location
- argv[3] : original config file location
"""
global BITCODE, SEARCH_CONF, ORIGINAL_CONF, ORIGINAL_SCORE
BITCODE = sys.argv[1]
SEARCH_CONF = json.loads(open(sys.argv[2], 'r').read())
ORIGINAL_CONF = json.loads(open(sys.argv[3], 'r').read())
# delete log file if exists
try:
os.remove("log.dd")
except OSError:
pass
# use index to find corresponding type
change_set = []
type_set = []
switch_set = []
# parse search configuration file
for idx, item in enumerate(SEARCH_CONF["config"]):
type_list = item.values()[0]["type"]
if isinstance(type_list, list):
type_set.append(type_list)
change_set.append(item.values()[0])
# put function calls into switch_set
if item.keys()[0] == "call":
switch_set.append(item.values()[0]["switch"])
else:
switch_set.append([])
# parse search grouping
group_set = init_groups()
print "groups: "
print group_set
print "\n"
# get original score
to_highest_precision(change_set, type_set, switch_set)
run_config()
ORIGINAL_SCORE = utilities.get_dynamic_score()
# search for valid configuration using delta-debugging algorithm
search_config(change_set, type_set, switch_set, group_set)
# get the score of modified program
if is_valid_config():
print "Check valid_" + BITCODE + ".json for the valid configuration file"
# print valid configuration file and diff file
utilities.print_config(SEARCH_CONF, "dd2_valid_" + BITCODE + ".json")
utilities.print_diff(SEARCH_CONF, ORIGINAL_CONF,
"dd2_diff_" + BITCODE + ".txt")
else:
print "No configuration is found!"
def random_search_config(change_set, type_set, switch_set, search_config,
original_config, bitcode, original_score, count):
utilities.print_config(search_config,
"final_config_from_random_search.json")
# search starts with the original config
random_local_search_config(change_set, type_set, switch_set, search_config,
original_config, bitcode, 2, original_score,
count)
def print_config(config, configFile):
'''
f = open(configFile, 'w+')
f.write("{\n")
changeList = config["config"]
for change in changeList:
f.write("\t\"" + change.keys()[0] + "\": {\n")
changeValue = change.values()[0]
for valueInfo in changeValue.keys():
f.write("\t\t\"" + valueInfo + "\": \"" + changeValue[valueInfo] + "\",\n")
f.write("\t},\n")
f.write("}\n")
'''
utilities.print_config(config, configFile)
def main():
bitcode = sys.argv[1]
search_conf_file = sys.argv[2]
original_conf_file = sys.argv[3]
#
# delete log file if exists
#
try:
os.remove("log.dd")
except OSError:
pass
#
# parsing config files
#
search_conf = json.loads(open(search_conf_file, 'r').read())
original_conf = json.loads(open(original_conf_file, 'r').read())
search_changes = search_conf["config"]
change_set = []
type_set = []
#
# record the change set
#
for search_change in search_changes:
type_vector = search_change.values()[0]["type"]
if isinstance(type_vector, list):
type_set.append(type_vector)
change_set.append(search_change.values()[0])
#
# search for valid configuration
#
print "Searching for valid configuration using delta-debugging algorithm ..."
# get original score
original_score = -1
# keep searching while the type set is not searched throughout
while not is_empty(type_set):
search_config(change_set, type_set, search_conf, original_conf,
bitcode, original_score)
#if modified_score <= original_score:
print "Check valid_" + bitcode + ".json for the valid configuration file"
# print valid configuration file and diff file
utilities.print_config(search_conf, "dd2_valid_" + bitcode + ".json")
utilities.print_diff(search_conf, original_conf,
"dd2_diff_" + bitcode + ".json")
def random_search_config(change_set, type_set, switch_set, search_config, original_config, bitcode, original_score, total_count):
utilities.print_config(search_config, "final_config_from_random_search.json")
count=total_count
opt_score=original_score
while(count>0):
# search starts with a random initial config
to_random_precision(change_set, type_set, switch_set)
count=count-1
if run_config(search_config, original_config, bitcode, opt_score) == 1 and utilities.get_dynamic_score() <= opt_score:
initial_score = utilities.get_dynamic_score()
utilities.print_config(search_config, "final_config_from_random_search.json")
fp = open('log.dd', 'a')
fp.write("START local search <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n")
fp.close()
random_count=random.randint(0, count)
if random_count>0:
opt_score=random_local_search_config(change_set, type_set, switch_set, search_config, original_config, bitcode, 2, initial_score, random_count)
count=count-random_count
fp = open('log.dd', 'a')
fp.write("END local search >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n")
fp.close()
def run_config(config, bitcodeFile, searchConfig, originalConfig):
global search
utilities.print_config(config, "config_temp.json")
result = transform.transform(bitcodeFile, "config_temp.json")
if result == 1:
utilities.print_config(config, "VALID_config_" + bitcodeFile + "_" + str(search) + ".json")
utilities.log_config(config, "VALID", "log.dd", search)
utilities.print_diff(searchConfig, originalConfig, "diff_" + bitcodeFile + "_" + str(search) + ".json")
elif result == 0:
utilities.print_config(config, "INVALID_config_" + bitcodeFile + "_" + str(search) + ".json")
utilities.log_config(config, "INVALID", "log.dd", search)
elif result == -1:
utilities.print_config(config, "FAIL1_config_" + bitcodeFile + "_" + str(search) + ".json")
utilities.log_config(config, "FAIL1", "log.dd", search)
elif result == -2:
utilities.print_config(config, "FAIL2_config_" + bitcodeFile + "_" + str(search) + ".json")
utilities.log_config(config, "FAIL2", "log.dd", search)
elif result == -3:
utilities.print_config(config, "FAIL3_config_" + bitcodeFile + "_" + str(search) + ".json")
utilities.log_config(config, "FAIL3", "log.dd", search)
search += 1
return result
def run_config(search_config, original_config, bitcode):
global search_counter
utilities.print_config(search_config, "config_temp.json")
result = transform_notime.transform(bitcode, "config_temp.json")
if result == 1:
utilities.print_config(
search_config,
"VALID_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "VALID", "log.dd", search_counter)
utilities.print_diff(
search_config, original_config,
"dd2_diff_" + bitcode + "_" + str(search_counter) + ".json")
elif result == 0:
utilities.print_config(
search_config,
"INVALID_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "INVALID", "log.dd",
search_counter)
elif result == -1:
utilities.print_config(
search_config,
"FAIL1_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "FAIL1", "log.dd", search_counter)
elif result == -2:
utilities.print_config(
search_config,
"FAIL2_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "FAIL2", "log.dd", search_counter)
elif result == -3:
utilities.print_config(
search_config,
"FAIL3_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "FAIL3", "log.dd", search_counter)
else:
utilities.print_config(
search_config,
"FAIL4_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "FAIL4", "log.dd", search_counter)
search_counter += 1
return result
def main():
bitcode = sys.argv[1]
search_conf_file = sys.argv[2]
original_conf_file = sys.argv[3]
partition_conf_file = sys.argv[4]
#partition_conf_file = "partition.json"
#
# delete log file if exists
#
try:
os.remove("log.dd")
except OSError:
pass
if __debug__:
try:
os.remove("ivy.log")
except OSError:
pass
#
# get original config and score
#
original_conf = json.loads(open(original_conf_file, 'r').read())
run_config(original_conf, original_conf, bitcode, 0)
original_score = utilities.get_dynamic_score()
if __debug__:
fp = open('ivy.log', 'a')
print >> fp, "---------"
print >> fp, "original score"
print >> fp, original_score
fp.close()
#
# hierarchically type tuning
#
partition_tree = json.loads(open(partition_conf_file, 'r').read())
curr_conf = None
curr_score = -1
level = len(partition_tree) - 1
while level >= 0:
if __debug__:
fp = open('ivy.log', 'a')
print >> fp, "partition level and config"
print >> fp, level, partition_tree[level]
fp.close()
search_conf = json.loads(open(search_conf_file, 'r').read())
change_items = search_conf['config']
# delete from the search space the configs that have been pruned
if curr_conf != None:
reach_bottom_label = 1
for i in range(len(curr_conf['config'])):
curr_type = curr_conf['config'][i].values()[0]["type"]
type_vector = change_items[i].values()[0]["type"]
index = type_vector.index(curr_type)
if index != 0:
reach_bottom_label = 0
del type_vector[index + 1:]
if change_items[i].keys()[0] == "call":
del change_items[i].values()[0]["switch"][index + 1:]
if reach_bottom_label == 1:
break
# create communities based on the current level of the partition tree
global community_obj
community_obj = com.community(partition_tree, change_items, level)
if __debug__:
fp = open('ivy.log', 'a')
print >> fp, "community configs:"
print >> fp, community_obj.confs
fp.close()
#
# record the change set
#
search_changes = community_obj.confs
change_set = []
type_set = []
switch_set = []
for i in range(len(search_changes)):
type_vector = search_changes[i]["type"]
if isinstance(type_vector, list):
if len(type_vector) == 1:
tmp_set = []
tmp_type_set = []
tmp_switch_set = []
tmp_set.append(search_changes[i])
tmp_type_set.append(type_vector)
if "switch" in community_obj.get_vars(
search_changes[i]["name"])[0].keys():
tmp_switch_set.append(
community_obj.get_vars(
search_changes[i]["name"])[0]["switch"])
else:
tmp_switch_set.append([])
to_highest_precision(tmp_set, tmp_type_set, tmp_switch_set)
else:
type_set.append(type_vector)
change_set.append(search_changes[i])
if (len(community_obj.get_vars(search_changes[i]["name"]))
== 1) & ("switch" in community_obj.get_vars(
search_changes[i]["name"])[0].keys()):
switch_set.append(
community_obj.get_vars(
search_changes[i]["name"])[0]["switch"])
else:
switch_set.append([])
#
# search for valid configuration
#
print "Searching for valid configuration using delta-debugging algorithm ..."
# get current score
if curr_score == -1:
curr_score = original_score ## 0.95
curr_conf = original_conf
# keep searching while the type set is not searched throughout
while not is_empty(type_set):
search_config(change_set, type_set, switch_set, search_conf,
original_conf, bitcode, original_score)
# get the score of modified program
run_config(search_conf, original_conf, bitcode, 0)
modified_score = utilities.get_dynamic_score()
if modified_score <= curr_score:
curr_conf = search_conf
curr_score = modified_score
if __debug__:
fp = open('ivy.log', 'a')
print >> fp, "---------"
print >> fp, "updating new score"
print >> fp, curr_score
fp.close()
# print the intermediate level configuration
utilities.print_config(
curr_conf,
"dd2_valid_level" + str(level) + "_" + bitcode + ".json")
fleveline = open("log.dd", "a")
fleveline.write(
"----------------------------------------------------------------------\n"
)
fleveline.close()
# check the modified configuration
'''
if is_bottom_type(change_set):
if __debug__ :
fp = open('ivy.log', 'a')
print>>fp, "stop searching : reach bottom types"
print>>fp, search_conf
print>>fp, "change set:"
print>>fp, change_set
fp.close()
break
'''
level -= 1
# print tuning result
if (curr_score <= original_score) & (curr_conf != None):
#print valid configuration file and diff file
diff = utilities.print_diff(curr_conf, original_conf,
"dd2_diff_" + bitcode + ".json")
if diff:
utilities.print_config(curr_conf, "dd2_valid_" + bitcode + ".json")
print "original_score: ", original_score
print "modified_score: ", curr_score
fp = open('time.txt', 'a')
print >> fp, curr_score, "/", original_score
fp.close()
print "Check valid_" + bitcode + ".json for the valid configuration file"
return
print "No configuration is found!"
def run_config(search_config, original_config, bitcode, timeout):
if False:
fp = open('ivy.log', 'a')
print >> fp, "run config:"
print >> fp, "search_config:"
print >> fp, search_config
fp.close()
global search_counter
print "** Exploring configuration #" + str(search_counter)
utilities.print_config(search_config, "config_temp.json")
result = transform2.transform(bitcode, "config_temp.json", timeout)
if result == 1:
utilities.print_config(
search_config,
"VALID_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "VALID", "log.dd", search_counter)
utilities.print_diff(
search_config, original_config,
"dd2_diff_" + bitcode + "_" + str(search_counter) + ".json")
elif result == 0:
utilities.print_config(
search_config,
"INVALID_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "INVALID", "log.dd",
search_counter)
elif result == -1:
utilities.print_config(
search_config,
"FAIL1_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "FAIL1", "log.dd", search_counter)
elif result == -2:
utilities.print_config(
search_config,
"FAIL2_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "FAIL2", "log.dd", search_counter)
elif result == -3:
utilities.print_config(
search_config,
"FAIL3_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "FAIL3", "log.dd", search_counter)
else:
utilities.print_config(
search_config,
"FAIL4_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "FAIL4", "log.dd", search_counter)
search_counter += 1
return result
def main():
bitcode = sys.argv[1]
search_conf_file = sys.argv[2]
original_conf_file = sys.argv[3]
if len(sys.argv)>4:
total_count = int(sys.argv[4])
else:
total_count = 1000
#
# delete log file if exists
#
try:
os.remove("log.dd")
except OSError:
pass
#
# get configs and the topological order
#
search_conf = json.loads(open(search_conf_file, 'r').read())
original_conf = json.loads(open(original_conf_file, 'r').read())
#
# parsing config files
#
search_changes = search_conf["config"]
change_set = []
type_set = []
switch_set = []
#
# record the change set
#
for search_change in search_changes:
type_vector = search_change.values()[0]["type"]
if isinstance(type_vector, list):
type_set.append(type_vector)
change_set.append(search_change.values()[0])
if search_change.keys()[0] == "call":
switch_set.append(search_change.values()[0]["switch"])
else:
switch_set.append([])
#
# search for valid configuration
#
print "Searching for valid configuration using delta-debugging algorithm ..."
# get original score
to_highest_precision(change_set, type_set, switch_set)
run_config(search_conf, original_conf, bitcode, 0)
original_score = utilities.get_dynamic_score() ## 0.95
# keep searching while the type set is not searched throughout
if not is_empty(type_set):
random_search_config(change_set, type_set, switch_set, search_conf, original_conf, bitcode, original_score, total_count)
# get the score of modified program
cmd="sed -i -e '1s/{/{\"config\": [/' -e 's/\"localVar/{\"localVar/' -e 's/\"call/{\"call/' -e 's/},/}},/' -e 's/\"name\(.*\),/\"name\\1/' final_config_from_random_search.json"
os.system(cmd)
os.system("tac <final_config_from_random_search.json | sed -e '2s/},/}/' -e '1s/}/]}/' | tac >tmp_final_config_from_random_search.json")
os.system("mv tmp_final_config_from_random_search.json final_config_from_random_search.json")
search_conf = json.loads(open("final_config_from_random_search.json", 'r').read())
run_config(search_conf, original_conf, bitcode, 0)
modified_score = utilities.get_dynamic_score()
if modified_score <= original_score:
# print valid configuration file and diff file
utilities.print_config(search_conf, "dd2_valid_" + bitcode + ".json")
diff = utilities.print_diff(search_conf, original_conf, "dd2_diff_" + bitcode + ".json")
if diff:
print "original_score: ", original_score
print "modified_score: ", modified_score
fp = open('time.txt', 'a')
print>>fp, modified_score, "/", original_score
fp.close()
print "Check valid_" + bitcode + ".json for the valid configuration file"
return
print "No configuration is found!"
def main():
bitcode = sys.argv[1]
search_conf_file = sys.argv[2]
original_conf_file = sys.argv[3]
#
# delete log file if exists
#
try:
os.remove("log.dd")
except OSError:
pass
#
# parsing config files
#
search_conf = json.loads(open(search_conf_file, 'r').read())
original_conf = json.loads(open(original_conf_file, 'r').read())
search_changes = search_conf["config"]
change_set = []
type_set = []
switch_set = []
#
# record the change set
#
for search_change in search_changes:
type_vector = search_change.values()[0]["type"]
if isinstance(type_vector, list):
type_set.append(type_vector)
change_set.append(search_change.values()[0])
if search_change.keys()[0] == "call":
switch_set.append(search_change.values()[0]["switch"])
else:
switch_set.append([])
print switch_set
#
# search for valid configuration
#
print "Searching for valid configuration using delta-debugging algorithm ..."
# get original score
to_highest_precision(change_set, type_set, switch_set)
run_config(search_conf, original_conf, bitcode)
original_score = utilities.get_dynamic_score() ## 0.95
# keep searching while the type set is not searched throughout
while not is_empty(type_set):
search_config(change_set, type_set, switch_set, search_conf,
original_conf, bitcode, original_score)
# get the score of modified program
run_config(search_conf, original_conf, bitcode)
modified_score = utilities.get_dynamic_score()
if modified_score <= original_score:
print "Check valid_" + bitcode + ".json for the valid configuration file"
# print valid configuration file and diff file
utilities.print_config(search_conf, "dd2_valid_" + bitcode + ".json")
utilities.print_diff(search_conf, original_conf,
"dd2_diff_" + bitcode + ".json")
else:
print "No configuration is found!"
def run_config(search_config, original_config, bitcode):
global search_counter
utilities.print_config(search_config, "config_temp.json")
result = transform_notime.transform(bitcode, "config_temp.json")
if result == 1:
utilities.print_config(search_config, "VALID_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "VALID", "log.dd", search_counter)
utilities.print_diff(search_config, original_config, "dd2_diff_" + bitcode + "_" + str(search_counter) + ".json")
elif result == 0:
utilities.print_config(search_config, "INVALID_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "INVALID", "log.dd", search_counter)
elif result == -1:
utilities.print_config(search_config, "FAIL1_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "FAIL1", "log.dd", search_counter)
elif result == -2:
utilities.print_config(search_config, "FAIL2_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "FAIL2", "log.dd", search_counter)
elif result == -3:
utilities.print_config(search_config, "FAIL3_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "FAIL3", "log.dd", search_counter)
else:
utilities.print_config(search_config, "FAIL4_config_" + bitcode + "_" + str(search_counter) + ".json")
utilities.log_config(search_config, "FAIL4", "log.dd", search_counter)
search_counter += 1
return result
def main():
global search_counter
bitcode = sys.argv[1]
search_conf_file = sys.argv[2]
original_conf_file = sys.argv[3]
#
# delete log file if exists
#
try:
os.remove("log.dd")
except OSError:
pass
#
# parsing config files
#
search_conf = json.loads(open(search_conf_file, 'r').read())
original_conf = json.loads(open(original_conf_file, 'r').read())
search_changes = search_conf["config"]
change_set = []
type_set = []
#
# record the change set
#
for search_change in search_changes:
type_vector = search_change.values()[0]["type"]
if isinstance(type_vector, list):
type_set.append(type_vector)
change_set.append(search_change.values()[0])
# get original score
utilities.to_highest_precision(change_set, type_set)
utilities.run_config(search_conf, original_conf, bitcode, search_counter)
original_score = utilities.get_dynamic_score(search_counter) * 1.05
search_counter = search_counter + 1
cpu_no = CPU_NO
# multiprocessing.cpu_count()
#
# search for valid configuration
#
print "Searching for valid configuration using delta-debugging algorithm ..."
# keep searching while the type set is not searched throughout
while not utilities.is_empty(type_set):
#
# distribute change set
#
dis_no = ((len(change_set)-1)/cpu_no)+1
queue = Queue()
workers = []
for i in xrange(cpu_no):
workers.append(Process(target=search_config_dis, args=(
change_set[i*dis_no:min((i+1)*dis_no, len(change_set))],
type_set[i*dis_no:min((i+1)*dis_no, len(type_set))],
search_conf, original_conf, bitcode, search_counter + i*dis_no*dis_no, i*dis_no, queue)))
utilities.to_highest_precision(change_set, type_set)
for w in workers:
w.start()
for w in workers:
w.join()
print len(type_set)
while not queue.empty():
inx = queue.get()
print inx
del(type_set[inx][:])
j = 0
while j < len(type_set):
if len(type_set[j]) == 0:
type_set.pop(j)
change_set.pop(j)
else:
j += 1
search_counter += cpu_no*dis_no*dis_no
search_config(change_set, type_set, search_conf, original_conf, bitcode, original_score)
# get the score of modified program
utilities.run_config(search_conf, original_conf, bitcode, search_counter)
modified_score = utilities.get_dynamic_score(search_counter)
search_counter = search_counter + 1
if modified_score <= original_score:
print "Check valid_" + bitcode + ".json for the valid configuration file"
# print valid configuration file and diff file
utilities.print_config(search_conf, "dd2_valid_" + bitcode + ".json")
utilities.print_diff(search_conf, original_conf, "dd2_diff_" + bitcode + ".json")
else:
print "No configuration is found!"
def run_config(config, bitcodeFile, searchConfig, originalConfig):
global search
utilities.print_config(config, "config_temp.json")
result = transform.transform(bitcodeFile, "config_temp.json")
if result == 1:
utilities.print_config(
config,
"VALID_config_" + bitcodeFile + "_" + str(search) + ".json")
utilities.log_config(config, "VALID", "log.dd", search)
utilities.print_diff(
searchConfig, originalConfig,
"diff_" + bitcodeFile + "_" + str(search) + ".json")
elif result == 0:
utilities.print_config(
config,
"INVALID_config_" + bitcodeFile + "_" + str(search) + ".json")
utilities.log_config(config, "INVALID", "log.dd", search)
elif result == -1:
utilities.print_config(
config,
"FAIL1_config_" + bitcodeFile + "_" + str(search) + ".json")
utilities.log_config(config, "FAIL1", "log.dd", search)
elif result == -2:
utilities.print_config(
config,
"FAIL2_config_" + bitcodeFile + "_" + str(search) + ".json")
utilities.log_config(config, "FAIL2", "log.dd", search)
elif result == -3:
utilities.print_config(
config,
"FAIL3_config_" + bitcodeFile + "_" + str(search) + ".json")
utilities.log_config(config, "FAIL3", "log.dd", search)
search += 1
return result