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()
