def runThread(numEpisodes, results, finished, histories): exp = simulation(hardwareAccelerated=True) sim.simulations.current = exp try: for e in range(numEpisodes): exp.simulateEpisode() results.put(["Duration", e, exp.time.current]) results.put([ "Episode reward", e, offloading.offloadingDecision.sharedAgent.episodeReward ]) results.put([ "Overall reward", e, offloading.offloadingDecision.sharedAgent.totalReward ]) except: traceback.print_exc(file=sys.stdout) print("Error in experiment:", exp.time) sys.exit(0) finished.put(True) histories.put(sim.simulations.simulationResults.learningHistory) # print("\nsaving history", sim.results.learningHistory, '\nr') print("forward", sim.counters.NUM_FORWARD, "backward", sim.counters.NUM_BACKWARD)
def POST(self): web.header('Content-Type', 'application/json') sim = simulation() msg = {} payload = json.loads(web.data()) data = payload['data'] pw_policy_model.update( { 'userid': context.user_id(), 'date': payload['date'] }, data) calendar = calendar_model.get_calendar(data, payload['newCosts'], payload['date']) for k, value in data.iteritems(): sim.set_policy(k, value) msg['msg1'] = [{'name': 'risk', 'value': sim.calc_risk_prob()}, {'name': 'cost', 'value': sim.calc_prod_cost()}] msgs = [] tmp_msg = {} tmp_msg['id'] = payload['id'] tmp_msg['data'] = data msgs.append(tmp_msg) my_list = ['plen', 'psets', 'pdict', 'phist', 'prenew', 'pattempts', 'precovery'] for key in my_list: tmp_policy = pw_policy_model.get_range(data, key) for k in tmp_policy: msgs.append(k) scores = score_model().multiple_score(msgs) msg['msg2'] = scores msg['calendar'] = calendar return json.dumps(msg)
def runThread(offloading, jobLikelihood, numTicks, results, finished): sim.simulations.constants.JOB_LIKELIHOOD = jobLikelihood # sim.constants.SAMPLE_SIZE = sim.variable.Constant(samples) exp = simulation(0, numDevices, 0, hardwareAccelerated=True) for i in range(numTicks): exp.simulateTick() results.put([ "Offloading Policy {}".format(offloading), jobLikelihood, np.average(exp.delays) ]) finished.put(True)
def runThread(jobLikelihood, totalTime, results, finished): sim.simulations.constants.JOB_LIKELIHOOD = jobLikelihood # sim.constants.SAMPLE_SIZE = sim.variable.Constant(samples) exp = simulation(0, numDevices, 0, hardwareAccelerated=True) for i in range(int(totalTime / jump)): exp.simulateTime(jump) results.put([ "Job Likelihood: {:.4f}".format(jobLikelihood), i * jump, np.max(exp.taskQueueLength) ]) finished.put(True)
def runThread(jobLikelihood, offloadingPolicy, results, finished): sim.simulations.constants.OFFLOADING_POLICY = offloadingPolicy sim.simulations.constants.JOB_LIKELIHOOD = jobLikelihood exp = simulation(0, numDevices, 0, hardwareAccelerated=True) exp.simulateTime(sim.simulations.constants.TOTAL_TIME) # if not exp.allDone(): # warnings.warn("not all devices done: {}".format(numDevices)) results.put([ "Offloading {}".format(offloadingPolicy), jobLikelihood, np.sum(exp.totalDevicesEnergy()) / numDevices ]) finished.put(True)
def runThread(numJobs, results, finished, histories): exp = simulation(hardwareAccelerated=True) sim.simulations.current = exp try: for e in range(numJobs): exp.simulateUntilJobDone() results.put(["Job Duration", e, sim.tasks.job.job.jobResultsQueue.get()]) except: traceback.print_exc(file=sys.stdout) sys.exit(0) print("Error in experiment:", exp.time) finished.put(True) histories.put(sim.results.learningHistory) print("forward", sim.counters.NUM_FORWARD, "backward", sim.counters.NUM_BACKWARD)
def runThread(jobLikelihood, offloadingPolicy, task, hw, results, finished): sim.simulations.constants.OFFLOADING_POLICY = offloadingPolicy sim.simulations.constants.JOB_LIKELIHOOD = jobLikelihood sim.simulations.constants.DEFAULT_TASK_GRAPH = [task] exp = simulation(0, numDevices, 0, hardwareAccelerated=hw) exp.simulateTime(totalTime) # if not exp.allDone(): # warnings.warn("not all devices done: {}".format(numDevices)) results.put([ "{} - {} - HW {}".format(offloadingPolicy, task, hw), jobLikelihood, np.sum(exp.totalDevicesEnergy()) / numDevices ]) finished.put(True)
def runThread(jobLikelihood, roundRobin, results, finished): sim.simulations.constants.ROUND_ROBIN_TIMEOUT = roundRobin sim.simulations.constants.JOB_LIKELIHOOD = jobLikelihood # sim.constants.SAMPLE_SIZE = sim.variable.Constant(samples) exp = simulation(0, numDevices, 0, hardwareAccelerated=True) try: exp.simulateTime(sim.simulations.constants.TOTAL_TIME) except: traceback.print_exc(file=sys.stdout) print("Error in experiment:", jobLikelihood, roundRobin, exp.time) results.put([ "Round Robin {}".format(roundRobin), jobLikelihood, np.sum(exp.totalDevicesEnergy()) / numDevices ]) finished.put(True)
def multiple_score(self, policies): post_data = policies policy_costs_risks = [] sim = simulation() for policy_entry in post_data: result_entry = {} for key in policy_entry: if key == "data": tmp_value = policy_entry[key] sim.set_multi_policy(tmp_value) result_entry["risk"] = sim.calc_risk_prob() result_entry["cost"] = sim.calc_prod_cost() else: result_entry["id"] = policy_entry[key] policy_costs_risks.append(result_entry) # print('return cost '+ policy_costs_risks) return policy_costs_risks
def get_calendar(cls, user_id, data, cost, date): sim = simulation() risk = sim.calc_risk_prob() cost = sim.calc_prod_cost() calendar = records.record_prophecy(user_id, risk) # dtt = datetime.strptime(date, "%Y/%m/%d") # string_time = dtt.strftime("%Y/%m/%d") db.insert('scores', userid=user_id, score_type=1, score_value=risk, date=date, rank=0) db.insert('scores', userid=user_id, score_type=2, score_value=cost, date=date, rank=0) db.insert('pw_policy', userid=user_id, date=date, plen=data["plen"], psets=data["psets"], pdict=data["pdict"], phist=data["phist"], prenew=data["prenew"], pattempts=data["pattempts"], precovery=data["precovery"]) #return json.dumps([{"value": new_date.strftime("%Y/%m/%d %H:%M:%S")}]) return calendar
def POST(self): web.header('Content-Type', 'application/json') sim = simulation() post_data = json.loads(web.data()) policy_costs_risks = [] for policy_entry in post_data: result_entry = {} for key, value in policy_entry.iteritems(): if key == "data": tmp_value = eval(value) sim.set_multi_policy(tmp_value) result_entry["risk"] = sim.calc_risk_prob() result_entry["cost"] = sim.calc_prod_cost() else: result_entry[key] = value policy_costs_risks.append(result_entry) # print('return cost '+ policy_costs_risks) return json.dumps(policy_costs_risks)
def runThread(likelihood, alpha, results, finished): # sim.constants.SAMPLE_SIZE = sim.variable.Constant(samples) sim.simulations.constants.EXPECTED_LIFETIME_ALPHA = alpha sim.simulations.constants.JOB_LIKELIHOOD = likelihood exp = simulation(hardwareAccelerated=True) sim.simulations.current = exp # exp.simulateTime(30) counter = 0 for i in range(int(totalTime/jump)): exp.simulateTime(jump) counter += 1 # print("counter", counter) results.put(["Lifetime Alpha = {:.4f} Likelihood = {:.4f}".format(alpha, likelihood), i * jump, exp.devicesLifetimes()]) results.put(["Power Alpha = {:.4f} Likelihood = {:.4f}".format(alpha, likelihood), i * jump, [dev.averagePower for dev in exp.devices]]) # print("\ntime", exp.time, "lifetime", exp.systemLifetime()) # print("life ", [dev.expectedLifetime() for dev in exp.devices]) # print("power", [dev.averagePower for dev in exp.devices]) finished.put(True)
if __name__ == '__main__': sim.debug.enabled = True sim.debug.learnEnabled = True sim.simulations.constants.JOB_LIKELIHOOD = 0 sim.simulations.constants.OFFLOADING_POLICY = sim.offloading.offloadingPolicy.REINFORCEMENT_LEARNING sim.simulations.constants.FPGA_POWER_PLAN = sim.devices.components.powerPolicy.IDLE_TIMEOUT sim.simulations.constants.FPGA_IDLE_SLEEP = 0.1 sim.simulations.constants.NUM_DEVICES = 1 sim.simulations.constants.DRAW_DEVICES = False sim.simulations.constants.MINIMUM_BATCH = 1e10 sim.simulations.constants.PLOT_TD = sim.simulations.constants.TD * 10 sim.simulations.constants.DEFAULT_ELASTIC_NODE.RECONFIGURATION_TIME = sim.simulation.variable.Constant( sim.simulations.constants.TD * 2) exp = simulation(True) sim.simulations.current = exp exp.simulateTime(sim.simulations.constants.PLOT_TD * 1) dev = exp.devices[0] # time.sleep(1) # fix decision to local # adding some batched jobs for _ in range(5): sim.experiments.experiment.doWaitJob(exp, dev) exp.simulateTime(0.1) # exp.simulateUntilJobDone() # exp.simulateUntilJobDone() # exp.simulateUntilJobDone()