def __init__(self, task_queue, result_queue, CurrentNotDomConstraints_queuelist, index, outputFileParentName, INPUT): multiprocessing.Process.__init__(self) self.task_queue = task_queue self.result_queue = result_queue self.CurrentNotDomConstraints_queuelist = CurrentNotDomConstraints_queuelist self.index = index self.outputFileParentName = outputFileParentName self.GIAOptions = GuidedImprovementAlgorithmOptions(verbosity=0, \ incrementallyWriteLog=False, \ writeTotalTimeFilename="timefile.csv", \ writeRandomSeedsFilename="randomseed.csv", useCallLogs=False) self.GIAAlgorithm = GuidedImprovementAlgorithm(INPUT.s, INPUT.metrics_variables, \ INPUT.metrics_objective_direction, INPUT.FeatureVariable, options=self.GIAOptions) self.count_sat_calls = 0 self.count_unsat_calls = 0 self.count_paretoPoints = 0 self.startTime = time.time()
def __init__(self, task_queue, result_queue, totalTime,CurrentNotDomConstraints_queuelist, index, outputFileParentName, num_consumers, s, extraConstraint): multiprocessing.Process.__init__(self) s.add(extraConstraint) self.task_queue = task_queue self.result_queue = result_queue self.CurrentNotDomConstraints_queuelist = CurrentNotDomConstraints_queuelist self.totalTime = totalTime self.index = index self.outputFileParentName = outputFileParentName self.num_consumers = num_consumers # each group has an individual model and has two member consumers running on the model self.groupid = self.index / 2 self.memberid= self.index % 2 # split the objective space in terms of num_groups = num_consumers / 2 # maximum 30 cores -> minimum 3 degrees, so we use range [degree, degree) num_groups = self.num_consumers / 2 degree = 90.0 / num_groups # radian = degree * math.pi / 180.0 self.GIAOptions = GuidedImprovementAlgorithmOptions(verbosity=0, \ incrementallyWriteLog=False, \ writeTotalTimeFilename="timefile.csv", \ writeRandomSeedsFilename="randomseed.csv", useCallLogs=False) self.GIAAlgorithm = GuidedImprovementAlgorithm(s, metrics_variables, \ metrics_objective_direction, FeatureVariable, options=self.GIAOptions) self.count_sat_calls = 0 self.count_unsat_calls = 0 self.count_paretoPoints = 0 self.startTime = time.time()
def __init__(self, task_queue, result_queue, totalTime, index, outputFileParentName, num_consumers, s, extraConstraint): multiprocessing.Process.__init__(self) self.task_queue = task_queue self.result_queue = result_queue # self.CurrentNotDomConstraints_queuelist = CurrentNotDomConstraints_queuelist self.totalTime = totalTime self.index = index self.outputFileParentName = outputFileParentName self.num_consumers = num_consumers self.GIAOptions = GuidedImprovementAlgorithmOptions(verbosity=0, \ incrementallyWriteLog=False, \ writeTotalTimeFilename="timefile.csv", \ writeRandomSeedsFilename="randomseed.csv", useCallLogs=False) ''' add extra constraint''' #print extraConstraint s.add(extraConstraint) self.GIAAlgorithm = GuidedImprovementAlgorithm(s, metrics_variables, \ metrics_objective_direction, FeatureVariable, options=self.GIAOptions) self.count_sat_calls = 0 self.count_unsat_calls = 0 self.count_paretoPoints = 0 self.startTime = time.time()
class Consumer(multiprocessing.Process): def __init__(self, task_queue, result_queue, CurrentNotDomConstraints_queuelist, index, outputFileParentName, INPUT): multiprocessing.Process.__init__(self) self.task_queue = task_queue self.result_queue = result_queue self.CurrentNotDomConstraints_queuelist = CurrentNotDomConstraints_queuelist self.index = index self.outputFileParentName = outputFileParentName self.GIAOptions = GuidedImprovementAlgorithmOptions(verbosity=0, \ incrementallyWriteLog=False, \ writeTotalTimeFilename="timefile.csv", \ writeRandomSeedsFilename="randomseed.csv", useCallLogs=False) self.GIAAlgorithm = GuidedImprovementAlgorithm(INPUT.s, INPUT.metrics_variables, \ INPUT.metrics_objective_direction, INPUT.FeatureVariable, options=self.GIAOptions) self.count_sat_calls = 0 self.count_unsat_calls = 0 self.count_paretoPoints = 0 self.startTime = time.time() def run(self): while True: if self.task_queue.empty() == True: #print self.result_queue.qsize() #print '%s : Exiting' % multiprocessing.current_process().pid #self.task_queue.task_done() #print multiprocessing.current_process().is_alive() #os.exit(0) #print multiprocessing.current_process().is_alive() break else: next_task = self.task_queue.get(False) if next_task is None: # Poison pill means shutdown #print self.result_queue.qsize() #print '%s : Exiting' % multiprocessing.current_process().pid # while self.result_queue.empty() != True: # print self.result_queue.get() #multiprocessing.current_process().terminate() self.task_queue.task_done() #print count_paretoPoints, count_sat_calls, count_sat_calls outputFileChild = open(str(str(self.outputFileParentName)+'C'+str(self.index)+'.csv'), 'a') try: outputFileChild.writelines(str(self.index)+','+ str(self.count_paretoPoints) + ',' + str(self.count_sat_calls) + ',' + str(self.count_unsat_calls) + ',' + str(time.time()-self.startTime) +',' + '\n') finally: outputFileChild.close() #print multiprocessing.current_process().is_alive() #os.exit(0) #print multiprocessing.current_process().is_alive() # multiprocessing.current_process().terminate() # print multiprocessing.current_process().is_alive() break # execute a task, i.e., find a Pareto point # 1) update CurrentNotDomConstraints while self.CurrentNotDomConstraints_queuelist[self.index].empty() != True: strconstraintlist = self.CurrentNotDomConstraints_queuelist[self.index].get() ConvertedZ3ConstraintList = list() for constraint in strconstraintlist: #print constraint # eval() may lose precision, for example, eval(9962778141/19531250000) = 0 # that's why we need repr(), but not work for z3 # split constraint via > or < constraintSplitList = [] if constraint.find('>') != -1: constraintSplitList = constraint.split('>') #print constraintSplitList if constraintSplitList[1].find('/') != -1: ConvertedZ3ConstraintList.append( Real(constraintSplitList[0].strip()) > RealVal(constraintSplitList[1].strip())) else: ConvertedZ3ConstraintList.append( Int(constraintSplitList[0].strip()) > IntVal(constraintSplitList[1].strip())) #print ConvertedZ3ConstraintList else: constraintSplitList = constraint.split('<') #print constraintSplitList if constraintSplitList[1].find('/') != -1: ConvertedZ3ConstraintList.append( Real(constraintSplitList[0].strip()) < RealVal(constraintSplitList[1].strip())) else: ConvertedZ3ConstraintList.append( Int(constraintSplitList[0].strip()) < IntVal(constraintSplitList[1].strip())) #print ConvertedZ3ConstraintList #print Or(ConvertedZ3ConstraintList) tmpNotDominatedByNextParetoPoint = Or(ConvertedZ3ConstraintList) #print tmpNotDominatedByNextParetoPoint self.GIAAlgorithm.s.add(tmpNotDominatedByNextParetoPoint) # 2) if find all Pareto points, add a poison pill; otherwise find a Pareto point if self.GIAAlgorithm.s.check() != sat: self.count_unsat_calls += 1 self.task_queue.put(None) else: self.count_sat_calls += 1 self.task_queue.put("Task") prev_solution = self.GIAAlgorithm.s.model() self.GIAAlgorithm.s.push() NextParetoPoint, local_count_sat_calls, local_count_unsat_calls = self.GIAAlgorithm.ranToParetoFront(prev_solution) self.count_sat_calls += local_count_sat_calls self.count_unsat_calls += local_count_unsat_calls self.count_paretoPoints += 1 # #for EShop # outputFile = open(outfilename, 'a') # try: # outputFile.writelines('Found Pareto Points ' + str(count_paretoPoints) + ',' + # '\n') # finally: # outputFile.close() self.GIAAlgorithm.s.pop() tmpNotDominatedByNextParetoPoint = self.GIAAlgorithm.ConstraintNotDominatedByX(NextParetoPoint) self.GIAAlgorithm.s.add(tmpNotDominatedByNextParetoPoint) # picklize and store Pareto point and constraints strNextParetoPoint = list((d.name(), str(NextParetoPoint[d])) for d in NextParetoPoint.decls()) self.result_queue.put(strNextParetoPoint) constraintlist = self.GIAAlgorithm.EtractConstraintListNotDominatedByX(NextParetoPoint) strconstraintlist = list(str(item) for item in constraintlist) for j in xrange(len(self.CurrentNotDomConstraints_queuelist)): if j != self.index: self.CurrentNotDomConstraints_queuelist[j].put(strconstraintlist) self.task_queue.task_done() return 0
class Consumer(multiprocessing.Process): def __init__(self, task_queue, result_queue, totalTime,CurrentNotDomConstraints_queuelist, index, outputFileParentName, num_consumers, s, extraConstraint): multiprocessing.Process.__init__(self) s.add(extraConstraint) self.task_queue = task_queue self.result_queue = result_queue self.CurrentNotDomConstraints_queuelist = CurrentNotDomConstraints_queuelist self.totalTime = totalTime self.index = index self.outputFileParentName = outputFileParentName self.num_consumers = num_consumers # each group has an individual model and has two member consumers running on the model self.groupid = self.index / 2 self.memberid= self.index % 2 # split the objective space in terms of num_groups = num_consumers / 2 # maximum 30 cores -> minimum 3 degrees, so we use range [degree, degree) num_groups = self.num_consumers / 2 degree = 90.0 / num_groups # radian = degree * math.pi / 180.0 self.GIAOptions = GuidedImprovementAlgorithmOptions(verbosity=0, \ incrementallyWriteLog=False, \ writeTotalTimeFilename="timefile.csv", \ writeRandomSeedsFilename="randomseed.csv", useCallLogs=False) self.GIAAlgorithm = GuidedImprovementAlgorithm(s, metrics_variables, \ metrics_objective_direction, FeatureVariable, options=self.GIAOptions) self.count_sat_calls = 0 self.count_unsat_calls = 0 self.count_paretoPoints = 0 self.startTime = time.time() def run(self): while True: if self.task_queue[self.groupid].empty() == True: break else: next_task = self.task_queue[self.groupid].get(False) if next_task is None: self.task_queue[self.groupid].task_done() self.totalTime.put(str(time.time()-self.startTime)) outputFileChild = open(str(str(self.outputFileParentName)+'C'+str(self.index)+'.csv'), 'a') try: outputFileChild.writelines(str(self.index)+','+ str(self.count_paretoPoints) + ',' + str(self.count_sat_calls) + ',' + str(self.count_unsat_calls) + ',' + str(time.time()-self.startTime) +',' + '\n') finally: outputFileChild.close() break # execute a task, i.e., find a Pareto point # 1) update CurrentNotDomConstraints while self.CurrentNotDomConstraints_queuelist[self.index].empty() != True: strconstraintlist = self.CurrentNotDomConstraints_queuelist[self.index].get() ConvertedZ3ConstraintList = list() for constraint in strconstraintlist: constraintSplitList = [] if constraint.find('>') != -1: constraintSplitList = constraint.split('>') #print constraintSplitList if constraintSplitList[1].find('/') != -1: ConvertedZ3ConstraintList.append( Real(constraintSplitList[0].strip()) > RealVal(constraintSplitList[1].strip())) else: ConvertedZ3ConstraintList.append( Int(constraintSplitList[0].strip()) > IntVal(constraintSplitList[1].strip())) #print ConvertedZ3ConstraintList else: constraintSplitList = constraint.split('<') #print constraintSplitList if constraintSplitList[1].find('/') != -1: ConvertedZ3ConstraintList.append( Real(constraintSplitList[0].strip()) < RealVal(constraintSplitList[1].strip())) else: ConvertedZ3ConstraintList.append( Int(constraintSplitList[0].strip()) < IntVal(constraintSplitList[1].strip())) #print ConvertedZ3ConstraintList #print Or(ConvertedZ3ConstraintList) tmpNotDominatedByNextParetoPoint = Or(ConvertedZ3ConstraintList) #print tmpNotDominatedByNextParetoPoint self.GIAAlgorithm.s.add(tmpNotDominatedByNextParetoPoint) # 2) if find all Pareto points, add a poison pill; otherwise find a Pareto point start_time = time.time() if self.GIAAlgorithm.s.check() != sat: self.count_unsat_calls += 1 self.task_queue[self.groupid].put(None) else: self.count_sat_calls += 1 self.task_queue[self.groupid].put("Task") prev_solution = self.GIAAlgorithm.s.model() self.GIAAlgorithm.s.push() NextParetoPoint, local_count_sat_calls, local_count_unsat_calls = self.GIAAlgorithm.ranToParetoFront(prev_solution) end_time = time.time() self.count_sat_calls += local_count_sat_calls self.count_unsat_calls += local_count_unsat_calls self.count_paretoPoints += 1 # RecordPoint strNextParetoPoint = list((d.name(), str(NextParetoPoint[d])) for d in NextParetoPoint.decls()) if RECORDPOINT: strNextParetoPoint = list((d.name(), str(NextParetoPoint[d])) for d in NextParetoPoint.decls()) outputFileChild = open(str(str(self.outputFileParentName)+'C'+str(self.index)+'.csv'), 'a') try: outputFileChild.writelines(str(self.index)+','+ str(self.count_paretoPoints) + ',' + str(self.count_sat_calls) + ',' + str(end_time-start_time) +',' + str(strNextParetoPoint) +',' + '\n') finally: outputFileChild.close() self.GIAAlgorithm.s.pop() tmpNotDominatedByNextParetoPoint = self.GIAAlgorithm.ConstraintNotDominatedByX(NextParetoPoint) self.GIAAlgorithm.s.add(tmpNotDominatedByNextParetoPoint) # picklize and store Pareto point and constraints self.result_queue.put(strNextParetoPoint) constraintlist = self.GIAAlgorithm.EtractConstraintListNotDominatedByX(NextParetoPoint) strconstraintlist = list(str(item) for item in constraintlist) # broadcast the constraints to the other queue in the same group brother_index = self.groupid * 2 + (1-self.memberid) self.CurrentNotDomConstraints_queuelist[brother_index].put(strconstraintlist) self.task_queue[self.groupid].task_done() return 0
class Consumer(multiprocessing.Process): def __init__(self, task_queue, result_queue, totalTime, index, outputFileParentName, num_consumers, s, extraConstraint): multiprocessing.Process.__init__(self) self.task_queue = task_queue self.result_queue = result_queue # self.CurrentNotDomConstraints_queuelist = CurrentNotDomConstraints_queuelist self.totalTime = totalTime self.index = index self.outputFileParentName = outputFileParentName self.num_consumers = num_consumers self.GIAOptions = GuidedImprovementAlgorithmOptions(verbosity=0, \ incrementallyWriteLog=False, \ writeTotalTimeFilename="timefile.csv", \ writeRandomSeedsFilename="randomseed.csv", useCallLogs=False) ''' add extra constraint''' #print extraConstraint s.add(extraConstraint) self.GIAAlgorithm = GuidedImprovementAlgorithm(s, metrics_variables, \ metrics_objective_direction, FeatureVariable, options=self.GIAOptions) self.count_sat_calls = 0 self.count_unsat_calls = 0 self.count_paretoPoints = 0 self.startTime = time.time() def run(self): while True: if self.task_queue[self.index].empty() == True: break else: next_task = self.task_queue[self.index].get(False) if next_task is None: self.task_queue[self.index].task_done() self.totalTime.put(str(time.time()-self.startTime)) outputFileChild = open(str(str(self.outputFileParentName)+'C'+str(self.index)+'.csv'), 'a') try: outputFileChild.writelines(str(self.index)+','+ str(self.count_paretoPoints) + ',' + str(self.count_sat_calls) + ',' + str(self.count_unsat_calls) + ',' + str(time.time()-self.startTime) +',' + '\n') finally: outputFileChild.close() break start_time = time.time() if self.GIAAlgorithm.s.check() != sat: self.count_unsat_calls += 1 self.task_queue[self.index].put(None) else: self.count_sat_calls += 1 self.task_queue[self.index].put("Task") prev_solution = self.GIAAlgorithm.s.model() self.GIAAlgorithm.s.push() NextParetoPoint, local_count_sat_calls, local_count_unsat_calls = self.GIAAlgorithm.ranToParetoFront(prev_solution) end_time = time.time() self.count_sat_calls += local_count_sat_calls self.count_unsat_calls += local_count_unsat_calls self.count_paretoPoints += 1 self.GIAAlgorithm.s.pop() tmpNotDominatedByNextParetoPoint = self.GIAAlgorithm.ConstraintNotDominatedByX(NextParetoPoint) self.GIAAlgorithm.s.add(tmpNotDominatedByNextParetoPoint) # picklize and store Pareto point and constraints strNextParetoPoint = list((d.name(), str(NextParetoPoint[d])) for d in NextParetoPoint.decls()) self.result_queue.put(strNextParetoPoint) # RecordPoint if RECORDPOINT: strNextParetoPoint = list((d.name(), str(NextParetoPoint[d])) for d in NextParetoPoint.decls()) outputFileChild = open(str(str(self.outputFileParentName)+'C'+str(self.index)+'.points'), 'a') try: outputFileChild.writelines(str(self.index)+','+ str(self.count_paretoPoints) + ',' + str(self.count_sat_calls) + ',' + str(end_time-start_time) +',' + str(strNextParetoPoint) +',' + '\n') finally: outputFileChild.close() self.task_queue[self.index].task_done() return 0
def __init__(self, task_queue, result_queue, totalTime, CurrentNotDomConstraints_queuelist, index, outputFileParentName, num_consumers, solver, INPUT): multiprocessing.Process.__init__(self) self.task_queue = task_queue self.result_queue = result_queue self.CurrentNotDomConstraints_queuelist = CurrentNotDomConstraints_queuelist self.totalTime = totalTime self.index = index self.outputFileParentName = outputFileParentName self.num_consumers = num_consumers s = solver # each group has an individual model and has two member consumers running on the model self.groupid = self.index / 2 self.memberid= self.index % 2 # split the objective space in terms of num_groups = num_consumers / 2 # maximum 30 cores -> minimum 3 degrees, so we use range [degree, degree) num_groups = self.num_consumers / 2 degree = 90.0 / num_groups # radian = degree * math.pi / 180.0 splitRuleList = [] if sys.argv[1] == "ERS": if (self.groupid == 0): # from the reference point with a larger angle -> a bigger range # radian_higher = (degree + 1) * math.pi / 180.0 radian_higher = (degree) * math.pi / 180.0 gradient_higher = int(1000*round(math.tan(radian_higher), 3)) # print str(self.groupid) + ">=" + str(gradient_higher) # squarization # choosing "the two best" dimensions of the projective plane could be an interesting problem # try to use Shannon Diversity Index, but seems not working; i think it only works when we normalize all values into [0, 1] # so, still use the two dimensions with the maximum value range # the challenge is how to know the scattering of configurations in the objective space, given the quality attributes of each feature? # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 >= IntVal(gradient_higher) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_responsetime - 2070) * 629 >= IntVal(gradient_higher) * (INPUT.total_cost - 3145) * 414 ) tmpsplitRuleList = And(splitRuleList) # print tmpsplitRuleList s.add(tmpsplitRuleList) elif (self.groupid == num_groups - 1): # from the reference point with a smaller angle -> a bigger range # radian_lower = (degree * self.groupid - 1) * math.pi / 180.0 radian_lower = (degree * self.groupid) * math.pi / 180.0 gradient_lower = int(1000*round(math.tan(radian_lower), 3)) # print str(self.groupid) + "<" + str(gradient_lower) # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 < IntVal(gradient_lower) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_responsetime - 2070) * 629 < IntVal(gradient_lower) * (INPUT.total_cost - 3145) * 414 ) tmpsplitRuleList = And(splitRuleList) # print tmpsplitRuleList s.add(tmpsplitRuleList) else: # radian_lower = (degree * self.groupid - 1) * math.pi / 180.0 radian_lower = (degree * self.groupid) * math.pi / 180.0 gradient_lower = int(1000*round(math.tan(radian_lower), 3)) # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 < IntVal(gradient_lower) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_responsetime - 2070) * 629 < IntVal(gradient_lower) * (INPUT.total_cost - 3145) * 414 ) # radian_higher = (degree * (self.groupid+1) + 1) * math.pi / 180.0 radian_higher = (degree * (self.groupid + 1)) * math.pi / 180.0 gradient_higher = int(1000*round(math.tan(radian_higher), 3)) # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 >= IntVal(gradient_higher) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_responsetime - 2070) * 629 >= IntVal(gradient_higher) * (INPUT.total_cost - 3145) * 414 ) # print str(self.groupid) + ">=" + str(gradient_higher) + "<" + str(gradient_lower) tmpsplitRuleList = And(splitRuleList) # print tmpsplitRuleList s.add(tmpsplitRuleList) elif sys.argv[1] == "ESH": if (self.groupid == 0): # from the reference point with a larger angle -> a bigger range # radian_higher = (degree + 1) * math.pi / 180.0 radian_higher = (degree) * math.pi / 180.0 gradient_higher = int(1000*round(math.tan(radian_higher), 3)) # print str(self.groupid) + ">=" + str(gradient_higher) # squarization # choosing "the two best" dimensions of the projective plane could be an interesting problem # try to use Shannon Diversity Index, but seems not working; i think it only works when we normalize all values into [0, 1] # so, still use the two dimensions with the maximum value range # the challenge is how to know the scattering of configurations in the objective space, given the quality attributes of each feature? # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 >= IntVal(gradient_higher) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 2887) * 708 >= IntVal(gradient_higher) * (INPUT.total_Defects - 708) * 2887 ) tmpsplitRuleList = And(splitRuleList) # print tmpsplitRuleList s.add(tmpsplitRuleList) elif (self.groupid == num_groups - 1): # from the reference point with a smaller angle -> a bigger range # radian_lower = (degree * self.groupid - 1) * math.pi / 180.0 radian_lower = (degree * self.groupid) * math.pi / 180.0 gradient_lower = int(1000*round(math.tan(radian_lower), 3)) # print str(self.groupid) + "<" + str(gradient_lower) # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 < IntVal(gradient_lower) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 2887) * 708 < IntVal(gradient_lower) * (INPUT.total_Defects - 708) * 2887 ) tmpsplitRuleList = And(splitRuleList) # print tmpsplitRuleList s.add(tmpsplitRuleList) else: # radian_lower = (degree * self.groupid - 1) * math.pi / 180.0 radian_lower = (degree * self.groupid) * math.pi / 180.0 gradient_lower = int(1000*round(math.tan(radian_lower), 3)) # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 < IntVal(gradient_lower) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 2887) * 708 < IntVal(gradient_lower) * (INPUT.total_Defects - 708) * 2887 ) # radian_higher = (degree * (self.groupid+1) + 1) * math.pi / 180.0 radian_higher = (degree * (self.groupid + 1)) * math.pi / 180.0 gradient_higher = int(1000*round(math.tan(radian_higher), 3)) # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 >= IntVal(gradient_higher) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 2887) * 708 >= IntVal(gradient_higher) * (INPUT.total_Defects - 708) * 2887 ) # print str(self.groupid) + ">=" + str(gradient_higher) + "<" + str(gradient_lower) tmpsplitRuleList = And(splitRuleList) # print tmpsplitRuleList s.add(tmpsplitRuleList) elif sys.argv[1] == "WPT": if (self.groupid == 0): # from the reference point with a larger angle -> a bigger range # radian_higher = (degree + 1) * math.pi / 180.0 radian_higher = (degree) * math.pi / 180.0 gradient_higher = int(1000*round(math.tan(radian_higher), 3)) # print str(self.groupid) + ">=" + str(gradient_higher) # squarization # choosing "the two best" dimensions of the projective plane could be an interesting problem # try to use Shannon Diversity Index, but seems not working; i think it only works when we normalize all values into [0, 1] # so, still use the two dimensions with the maximum value range # the challenge is how to know the scattering of configurations in the objective space, given the quality attributes of each feature? # splitRuleList.append( 1000 * (total_rampuptime - 13) * 10 >= IntVal(gradient_higher) * (total_batteryusage - 10) * 13 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 422) * 145 >= IntVal(gradient_higher) * (INPUT.total_Defects - 145) * 422 ) tmpsplitRuleList = And(splitRuleList) s.add(tmpsplitRuleList) elif (self.groupid == num_groups - 1): # from the reference point with a smaller angle -> a bigger range # radian_lower = (degree * self.index - 1) * math.pi / 180.0 radian_lower = (degree * self.groupid) * math.pi / 180.0 gradient_lower = int(1000*round(math.tan(radian_lower), 3)) # print str(self.groupid) + "<" + str(gradient_lower) # splitRuleList.append( 1000 * (total_rampuptime - 13) * 10 < IntVal(gradient_lower) * (total_batteryusage - 10) * 13 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 422) * 145 < IntVal(gradient_lower) * (INPUT.total_Defects - 145) * 422 ) tmpsplitRuleList = And(splitRuleList) s.add(tmpsplitRuleList) else: # radian_lower = (degree * self.index - 1) * math.pi / 180.0 radian_lower = (degree * self.groupid) * math.pi / 180.0 gradient_lower = int(1000*round(math.tan(radian_lower), 3)) # splitRuleList.append( 1000 * (total_rampuptime - 13) * 10 < IntVal(gradient_lower) * (total_batteryusage - 10) * 13 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 422) * 145 < IntVal(gradient_lower) * (INPUT.total_Defects - 145) * 422 ) # radian_higher = (degree * (self.index+1) + 1) * math.pi / 180.0 radian_higher = (degree * (self.groupid+1)) * math.pi / 180.0 gradient_higher = int(1000*round(math.tan(radian_higher), 3)) # splitRuleList.append( 1000 * (total_rampuptime - 13) * 10 >= IntVal(gradient_higher) * (total_batteryusage - 10) * 13 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 422) * 145 >= IntVal(gradient_higher) * (INPUT.total_Defects - 145) * 422 ) # print str(self.groupid) + ">=" + str(gradient_higher) + "<" + str(gradient_lower) tmpsplitRuleList = And(splitRuleList) s.add(tmpsplitRuleList) elif sys.argv[1] == "BDB": pass else: print "messed up" sys.exit() self.GIAOptions = GuidedImprovementAlgorithmOptions(verbosity=0, \ incrementallyWriteLog=False, \ writeTotalTimeFilename="timefile.csv", \ writeRandomSeedsFilename="randomseed.csv", useCallLogs=False) self.GIAAlgorithm = GuidedImprovementAlgorithm(s, INPUT.metrics_variables, \ INPUT.metrics_objective_direction, INPUT.FeatureVariable, options=self.GIAOptions) self.count_sat_calls = 0 self.count_unsat_calls = 0 self.count_paretoPoints = 0 self.startTime = time.time()
class Consumer(multiprocessing.Process): def __init__(self, task_queue, result_queue, totalTime, CurrentNotDomConstraints_queuelist, index, outputFileParentName, num_consumers, solver, INPUT): multiprocessing.Process.__init__(self) self.task_queue = task_queue self.result_queue = result_queue self.CurrentNotDomConstraints_queuelist = CurrentNotDomConstraints_queuelist self.totalTime = totalTime self.index = index self.outputFileParentName = outputFileParentName self.num_consumers = num_consumers s = solver # each group has an individual model and has two member consumers running on the model self.groupid = self.index / 2 self.memberid= self.index % 2 # split the objective space in terms of num_groups = num_consumers / 2 # maximum 30 cores -> minimum 3 degrees, so we use range [degree, degree) num_groups = self.num_consumers / 2 degree = 90.0 / num_groups # radian = degree * math.pi / 180.0 splitRuleList = [] if sys.argv[1] == "ERS": if (self.groupid == 0): # from the reference point with a larger angle -> a bigger range # radian_higher = (degree + 1) * math.pi / 180.0 radian_higher = (degree) * math.pi / 180.0 gradient_higher = int(1000*round(math.tan(radian_higher), 3)) # print str(self.groupid) + ">=" + str(gradient_higher) # squarization # choosing "the two best" dimensions of the projective plane could be an interesting problem # try to use Shannon Diversity Index, but seems not working; i think it only works when we normalize all values into [0, 1] # so, still use the two dimensions with the maximum value range # the challenge is how to know the scattering of configurations in the objective space, given the quality attributes of each feature? # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 >= IntVal(gradient_higher) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_responsetime - 2070) * 629 >= IntVal(gradient_higher) * (INPUT.total_cost - 3145) * 414 ) tmpsplitRuleList = And(splitRuleList) # print tmpsplitRuleList s.add(tmpsplitRuleList) elif (self.groupid == num_groups - 1): # from the reference point with a smaller angle -> a bigger range # radian_lower = (degree * self.groupid - 1) * math.pi / 180.0 radian_lower = (degree * self.groupid) * math.pi / 180.0 gradient_lower = int(1000*round(math.tan(radian_lower), 3)) # print str(self.groupid) + "<" + str(gradient_lower) # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 < IntVal(gradient_lower) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_responsetime - 2070) * 629 < IntVal(gradient_lower) * (INPUT.total_cost - 3145) * 414 ) tmpsplitRuleList = And(splitRuleList) # print tmpsplitRuleList s.add(tmpsplitRuleList) else: # radian_lower = (degree * self.groupid - 1) * math.pi / 180.0 radian_lower = (degree * self.groupid) * math.pi / 180.0 gradient_lower = int(1000*round(math.tan(radian_lower), 3)) # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 < IntVal(gradient_lower) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_responsetime - 2070) * 629 < IntVal(gradient_lower) * (INPUT.total_cost - 3145) * 414 ) # radian_higher = (degree * (self.groupid+1) + 1) * math.pi / 180.0 radian_higher = (degree * (self.groupid + 1)) * math.pi / 180.0 gradient_higher = int(1000*round(math.tan(radian_higher), 3)) # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 >= IntVal(gradient_higher) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_responsetime - 2070) * 629 >= IntVal(gradient_higher) * (INPUT.total_cost - 3145) * 414 ) # print str(self.groupid) + ">=" + str(gradient_higher) + "<" + str(gradient_lower) tmpsplitRuleList = And(splitRuleList) # print tmpsplitRuleList s.add(tmpsplitRuleList) elif sys.argv[1] == "ESH": if (self.groupid == 0): # from the reference point with a larger angle -> a bigger range # radian_higher = (degree + 1) * math.pi / 180.0 radian_higher = (degree) * math.pi / 180.0 gradient_higher = int(1000*round(math.tan(radian_higher), 3)) # print str(self.groupid) + ">=" + str(gradient_higher) # squarization # choosing "the two best" dimensions of the projective plane could be an interesting problem # try to use Shannon Diversity Index, but seems not working; i think it only works when we normalize all values into [0, 1] # so, still use the two dimensions with the maximum value range # the challenge is how to know the scattering of configurations in the objective space, given the quality attributes of each feature? # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 >= IntVal(gradient_higher) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 2887) * 708 >= IntVal(gradient_higher) * (INPUT.total_Defects - 708) * 2887 ) tmpsplitRuleList = And(splitRuleList) # print tmpsplitRuleList s.add(tmpsplitRuleList) elif (self.groupid == num_groups - 1): # from the reference point with a smaller angle -> a bigger range # radian_lower = (degree * self.groupid - 1) * math.pi / 180.0 radian_lower = (degree * self.groupid) * math.pi / 180.0 gradient_lower = int(1000*round(math.tan(radian_lower), 3)) # print str(self.groupid) + "<" + str(gradient_lower) # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 < IntVal(gradient_lower) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 2887) * 708 < IntVal(gradient_lower) * (INPUT.total_Defects - 708) * 2887 ) tmpsplitRuleList = And(splitRuleList) # print tmpsplitRuleList s.add(tmpsplitRuleList) else: # radian_lower = (degree * self.groupid - 1) * math.pi / 180.0 radian_lower = (degree * self.groupid) * math.pi / 180.0 gradient_lower = int(1000*round(math.tan(radian_lower), 3)) # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 < IntVal(gradient_lower) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 2887) * 708 < IntVal(gradient_lower) * (INPUT.total_Defects - 708) * 2887 ) # radian_higher = (degree * (self.groupid+1) + 1) * math.pi / 180.0 radian_higher = (degree * (self.groupid + 1)) * math.pi / 180.0 gradient_higher = int(1000*round(math.tan(radian_higher), 3)) # splitRuleList.append( 1000 * (total_rampuptime - 130) * 121 >= IntVal(gradient_higher) * (total_batteryusage - 121) * 130 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 2887) * 708 >= IntVal(gradient_higher) * (INPUT.total_Defects - 708) * 2887 ) # print str(self.groupid) + ">=" + str(gradient_higher) + "<" + str(gradient_lower) tmpsplitRuleList = And(splitRuleList) # print tmpsplitRuleList s.add(tmpsplitRuleList) elif sys.argv[1] == "WPT": if (self.groupid == 0): # from the reference point with a larger angle -> a bigger range # radian_higher = (degree + 1) * math.pi / 180.0 radian_higher = (degree) * math.pi / 180.0 gradient_higher = int(1000*round(math.tan(radian_higher), 3)) # print str(self.groupid) + ">=" + str(gradient_higher) # squarization # choosing "the two best" dimensions of the projective plane could be an interesting problem # try to use Shannon Diversity Index, but seems not working; i think it only works when we normalize all values into [0, 1] # so, still use the two dimensions with the maximum value range # the challenge is how to know the scattering of configurations in the objective space, given the quality attributes of each feature? # splitRuleList.append( 1000 * (total_rampuptime - 13) * 10 >= IntVal(gradient_higher) * (total_batteryusage - 10) * 13 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 422) * 145 >= IntVal(gradient_higher) * (INPUT.total_Defects - 145) * 422 ) tmpsplitRuleList = And(splitRuleList) s.add(tmpsplitRuleList) elif (self.groupid == num_groups - 1): # from the reference point with a smaller angle -> a bigger range # radian_lower = (degree * self.index - 1) * math.pi / 180.0 radian_lower = (degree * self.groupid) * math.pi / 180.0 gradient_lower = int(1000*round(math.tan(radian_lower), 3)) # print str(self.groupid) + "<" + str(gradient_lower) # splitRuleList.append( 1000 * (total_rampuptime - 13) * 10 < IntVal(gradient_lower) * (total_batteryusage - 10) * 13 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 422) * 145 < IntVal(gradient_lower) * (INPUT.total_Defects - 145) * 422 ) tmpsplitRuleList = And(splitRuleList) s.add(tmpsplitRuleList) else: # radian_lower = (degree * self.index - 1) * math.pi / 180.0 radian_lower = (degree * self.groupid) * math.pi / 180.0 gradient_lower = int(1000*round(math.tan(radian_lower), 3)) # splitRuleList.append( 1000 * (total_rampuptime - 13) * 10 < IntVal(gradient_lower) * (total_batteryusage - 10) * 13 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 422) * 145 < IntVal(gradient_lower) * (INPUT.total_Defects - 145) * 422 ) # radian_higher = (degree * (self.index+1) + 1) * math.pi / 180.0 radian_higher = (degree * (self.groupid+1)) * math.pi / 180.0 gradient_higher = int(1000*round(math.tan(radian_higher), 3)) # splitRuleList.append( 1000 * (total_rampuptime - 13) * 10 >= IntVal(gradient_higher) * (total_batteryusage - 10) * 13 ) splitRuleList.append( 1000 * (INPUT.total_Cost - 422) * 145 >= IntVal(gradient_higher) * (INPUT.total_Defects - 145) * 422 ) # print str(self.groupid) + ">=" + str(gradient_higher) + "<" + str(gradient_lower) tmpsplitRuleList = And(splitRuleList) s.add(tmpsplitRuleList) elif sys.argv[1] == "BDB": pass else: print "messed up" sys.exit() self.GIAOptions = GuidedImprovementAlgorithmOptions(verbosity=0, \ incrementallyWriteLog=False, \ writeTotalTimeFilename="timefile.csv", \ writeRandomSeedsFilename="randomseed.csv", useCallLogs=False) self.GIAAlgorithm = GuidedImprovementAlgorithm(s, INPUT.metrics_variables, \ INPUT.metrics_objective_direction, INPUT.FeatureVariable, options=self.GIAOptions) self.count_sat_calls = 0 self.count_unsat_calls = 0 self.count_paretoPoints = 0 self.startTime = time.time() def run(self): while True: if self.task_queue[self.groupid].empty() == True: break else: next_task = self.task_queue[self.groupid].get(False) if next_task is None: self.task_queue[self.groupid].task_done() self.totalTime.put(str(time.time()-self.startTime)) outputFileChild = open(str(str(self.outputFileParentName)+'C'+str(self.index)+'.csv'), 'a') try: outputFileChild.writelines(str(self.index)+','+ str(self.count_paretoPoints) + ',' + str(self.count_sat_calls) + ',' + str(self.count_unsat_calls) + ',' + str(time.time()-self.startTime) +',' + '\n') finally: outputFileChild.close() break # execute a task, i.e., find a Pareto point # 1) update CurrentNotDomConstraints while self.CurrentNotDomConstraints_queuelist[self.index].empty() != True: strconstraintlist = self.CurrentNotDomConstraints_queuelist[self.index].get() ConvertedZ3ConstraintList = list() for constraint in strconstraintlist: constraintSplitList = [] if constraint.find('>') != -1: constraintSplitList = constraint.split('>') #print constraintSplitList if constraintSplitList[1].find('/') != -1: ConvertedZ3ConstraintList.append( Real(constraintSplitList[0].strip()) > RealVal(constraintSplitList[1].strip())) else: ConvertedZ3ConstraintList.append( Int(constraintSplitList[0].strip()) > IntVal(constraintSplitList[1].strip())) #print ConvertedZ3ConstraintList else: constraintSplitList = constraint.split('<') #print constraintSplitList if constraintSplitList[1].find('/') != -1: ConvertedZ3ConstraintList.append( Real(constraintSplitList[0].strip()) < RealVal(constraintSplitList[1].strip())) else: ConvertedZ3ConstraintList.append( Int(constraintSplitList[0].strip()) < IntVal(constraintSplitList[1].strip())) #print ConvertedZ3ConstraintList #print Or(ConvertedZ3ConstraintList) tmpNotDominatedByNextParetoPoint = Or(ConvertedZ3ConstraintList) #print tmpNotDominatedByNextParetoPoint self.GIAAlgorithm.s.add(tmpNotDominatedByNextParetoPoint) # 2) if find all Pareto points, add a poison pill; otherwise find a Pareto point if self.GIAAlgorithm.s.check() != sat: self.count_unsat_calls += 1 self.task_queue[self.groupid].put(None) else: self.count_sat_calls += 1 self.task_queue[self.groupid].put("Task") prev_solution = self.GIAAlgorithm.s.model() self.GIAAlgorithm.s.push() NextParetoPoint, local_count_sat_calls, local_count_unsat_calls = self.GIAAlgorithm.ranToParetoFront(prev_solution) self.count_sat_calls += local_count_sat_calls self.count_unsat_calls += local_count_unsat_calls self.count_paretoPoints += 1 # #for EShop # outputFile = open(outfilename, 'a') # try: # outputFile.writelines('Found Pareto Points ' + str(count_paretoPoints) + ',' + # '\n') # finally: # outputFile.close() self.GIAAlgorithm.s.pop() tmpNotDominatedByNextParetoPoint = self.GIAAlgorithm.ConstraintNotDominatedByX(NextParetoPoint) self.GIAAlgorithm.s.add(tmpNotDominatedByNextParetoPoint) # picklize and store Pareto point and constraints strNextParetoPoint = list((d.name(), str(NextParetoPoint[d])) for d in NextParetoPoint.decls()) self.result_queue.put(strNextParetoPoint) constraintlist = self.GIAAlgorithm.EtractConstraintListNotDominatedByX(NextParetoPoint) strconstraintlist = list(str(item) for item in constraintlist) # broadcast the constraints to the other queue in the same group brother_index = self.groupid * 2 + (1-self.memberid) self.CurrentNotDomConstraints_queuelist[brother_index].put(strconstraintlist) self.task_queue[self.groupid].task_done() return 0