def run_single(self, trial_number):
""" Using -1 as the trial number indicates that this is for a
single run, so the trial number won't be included in the filename. """
avg_num_tasks = 200.
task_length = 100
for probes_ratio in self.probes_ratio_values:
network_delay = 2
if probes_ratio == -1:
network_delay = 0
first = True
# Number of different utilization values.
utilization_granularity = 10
file_prefix = self.get_prefix(trial_number, probes_ratio)
for i in range(1, utilization_granularity + 1):
arrival_delay = (task_length * avg_num_tasks *
utilization_granularity /
(self.num_servers * self.cores_per_server *
i))
simulation.main(["job_arrival_delay=%f" % arrival_delay,
"num_users=1",
"network_delay=%d" % network_delay,
"probes_ratio=%f" % probes_ratio,
"task_length_distribution=constant",
"num_tasks=%d" % avg_num_tasks,
"task_length=%d" % task_length,
"task_distribution=constant",
"load_metric=total",
"cores_per_server=%d" % self.cores_per_server,
"file_prefix=%s" % file_prefix,
"num_servers=%d" % self.num_servers,
"total_time=%d" % self.total_time,
"first_time=%s" % first])
first = False
def run_single(self, trial_number):
""" Using -1 as the trial number indicates that this is for a
single run, so the trial number won't be included in the filename. """
avg_num_tasks = 200.
task_length = 100
for probes_ratio in self.probes_ratio_values:
network_delay = 2
if probes_ratio == -1:
network_delay = 0
first = True
# Number of different utilization values.
utilization_granularity = 10
file_prefix = self.get_prefix(trial_number, probes_ratio)
for i in range(1, utilization_granularity + 1):
arrival_delay = (
task_length * avg_num_tasks * utilization_granularity /
(self.num_servers * self.cores_per_server * i))
simulation.main([
"job_arrival_delay=%f" % arrival_delay, "num_users=1",
"network_delay=%d" % network_delay,
"probes_ratio=%f" % probes_ratio,
"task_length_distribution=constant",
"num_tasks=%d" % avg_num_tasks,
"task_length=%d" % task_length,
"task_distribution=constant", "load_metric=total",
"cores_per_server=%d" % self.cores_per_server,
"file_prefix=%s" % file_prefix,
"num_servers=%d" % self.num_servers,
"total_time=%d" % self.total_time,
"first_time=%s" % first
])
first = False
def run_single(self, trial_number):
""" Using -1 as the trial number indicates that this is for a
single run, so the trial number won't be included in the filename. """
avg_num_tasks = 200. / 6 + 5 * 10. / 6
for network_delay, probes_ratio in zip(self.delay_values,
self.probes_ratio_values):
first = True
utilization_granularity = 20 # Number of different utilization values.
file_prefix = self.get_prefix(trial_number, network_delay,
probes_ratio)
for i in range(1, utilization_granularity + 1):
arrival_delay = (100. * avg_num_tasks *
utilization_granularity /
(self.num_servers * i))
simulation.main([
"job_arrival_delay=%f" % arrival_delay,
"network_delay=%d" % network_delay,
"probes_ratio=%f" % probes_ratio,
"task_length_distribution=facebook",
"task_distribution=bimodal",
"file_prefix=%s" % file_prefix,
"num_servers=%d" % self.num_servers,
"total_time=%d" % self.total_time,
"first_time=%s" % first
])
first = False
def wait_time_vs_load(file_prefix, utilization, num_servers, tasks_per_job, probes_ratio):
""" This debugs anomalous performance by plotting wait time.
The output files plot a CDF of wait time for each load (as returned by
the probe to the server).
"""
task_length = 100
arrival_delay = task_length * tasks_per_job / (num_servers * utilization)
network_delay = 1
total_time = 1e4
simulation.main(
[
"job_arrival_delay=%f" % arrival_delay,
"num_users=1",
"network_delay=%d" % network_delay,
"probes_ratio=%f" % probes_ratio,
"task_length_distribution=constant",
"num_tasks=%d" % tasks_per_job,
"task_length=%d" % task_length,
"task_distribution=constant",
"load_metric=total",
"file_prefix=%s" % file_prefix,
"num_servers=%d" % num_servers,
"total_time=%d" % total_time,
"first_time=True",
"record_task_info=True",
]
)
for job_or_task in ["job", "task"]:
output_prefix = "%s_%s" % (file_prefix, job_or_task)
data_filename = "raw_results/%s_wait_cdf" % output_prefix
# Figure out how many load lines to plot.
data_file = open(data_filename, "r")
items = data_file.readline().split("\t")
num_load_values = len(items) - 2
data_file.close()
filename = "plot_%s.gp" % output_prefix
gnuplot_file = open(filename, "w")
gnuplot_file.write("set terminal postscript color 'Helvetica' 14\n")
gnuplot_file.write("set size 0.5,0.5\n")
gnuplot_file.write("set output 'graphs/%s.ps'\n" % output_prefix)
gnuplot_file.write("set xlabel 'Task Wait Time (ms)'\n")
gnuplot_file.write("set ylabel 'Cumulative Probability'\n")
gnuplot_file.write("set grid ytics\n")
gnuplot_file.write("plot ")
for load in range(num_load_values):
if load != 0:
gnuplot_file.write(", \\\n")
gnuplot_file.write("'%s' using %d:1 with l lw 4 title 'Load=%d'" % (data_filename, load + 2, load))
gnuplot_file.close()
subprocess.call(["gnuplot", filename])
def fairness_time(load_metric, cores_per_server):
""" Plots the number of running tasks for each user, over time. """
num_tasks = 10
network_delay = 5
probes_ratio = 2
num_servers = 1000
total_time = 5000
file_prefix = "fairness"
first = True
utilization = 2.0
num_users = 4
arrival_delay = (100.0 * num_tasks / (num_servers * cores_per_server *
utilization))
simulation.main(["job_arrival_delay=%f" % arrival_delay,
"network_delay=%d" % network_delay,
"probes_ratio=%f" % probes_ratio,
"task_length_distribution=constant",
"task_distribution=constant",
"job_arrival_distribution=poisson",
"deterministic=True",
"file_prefix=%s" % file_prefix,
"num_users=%d" % num_users,
"cores_per_server=%d" % cores_per_server,
"num_servers=%d" % num_servers,
"num_tasks=%d" % num_tasks,
"total_time=%d" % total_time,
"load_metric=%s" % load_metric,
"relative_weights=1,1,1,2",
"relative_demands=1,1,1,1",
"first_time=%s" % first])
gnuplot_filename = "plot_fairness.gp"
gnuplot_file = open(gnuplot_filename, "w")
gnuplot_file.write("set terminal postscript color\n")
gnuplot_file.write("set output 'graphs/fairness.ps'\n")
gnuplot_file.write("set size 0.5,0.5\n")
#gnuplot_file.write("set xlabel 'Time (ms)'\n")
#gnuplot_file.write("set ylabel 'Number of Running Tasks'\n")
gnuplot_file.write("set grid ytics\n")
gnuplot_file.write("set xrange[0:%d]\n" % total_time)
gnuplot_file.write("plot ")
# Write total number of running tasks.
gnuplot_file.write(("'raw_results/%s_running_tasks' using 1:2 lt 0 lw 4 "
"with l notitle") % file_prefix)
for user_id in range(num_users):
gnuplot_file.write(",\\\n")
gnuplot_file.write(("'raw_results/%s_running_tasks_%s' using "
"1:2 lt %d lw 4 with l notitle") %
(file_prefix, user_id, user_id + 1))
gnuplot_file.close()
return gnuplot_filename
def simulate_serial():
print('Iniciando Modo Serial:')
process_init = pt() # Contador de processo
script_init = timeit.default_timer() # Contador Benchmark
simulation.main()
process_end = pt() - process_init
script_end = timeit.default_timer() - script_init
print('Tempo de Finalização do Processo (Serial): ', process_end)
print('Tempo de Finalização do Script (Serial): ', script_end)
print('--------------------------')
def wait_time_vs_load(file_prefix, utilization, num_servers, tasks_per_job,
probes_ratio):
""" This debugs anomalous performance by plotting wait time.
The output files plot a CDF of wait time for each load (as returned by
the probe to the server).
"""
task_length = 100
arrival_delay = (task_length * tasks_per_job /
(num_servers * utilization))
network_delay = 1
total_time = 1e4
simulation.main(["job_arrival_delay=%f" % arrival_delay,
"num_users=1",
"network_delay=%d" % network_delay,
"probes_ratio=%f" % probes_ratio,
"task_length_distribution=constant",
"num_tasks=%d" % tasks_per_job,
"task_length=%d" % task_length,
"task_distribution=constant",
"load_metric=total",
"file_prefix=%s" % file_prefix,
"num_servers=%d" % num_servers,
"total_time=%d" % total_time,
"first_time=True",
"record_task_info=True"])
for job_or_task in ["job", "task"]:
output_prefix = "%s_%s" % (file_prefix, job_or_task)
data_filename = "raw_results/%s_wait_cdf" % output_prefix
# Figure out how many load lines to plot.
data_file = open(data_filename, "r")
items = data_file.readline().split("\t")
num_load_values = len(items) - 2
data_file.close()
filename = "plot_%s.gp" % output_prefix
gnuplot_file = open(filename, 'w')
gnuplot_file.write("set terminal postscript color 'Helvetica' 14\n")
gnuplot_file.write("set size 0.5,0.5\n")
gnuplot_file.write("set output 'graphs/%s.ps'\n" % output_prefix)
gnuplot_file.write("set xlabel 'Task Wait Time (ms)'\n")
gnuplot_file.write("set ylabel 'Cumulative Probability'\n")
gnuplot_file.write("set grid ytics\n")
gnuplot_file.write("plot ")
for load in range(num_load_values):
if load != 0:
gnuplot_file.write(", \\\n")
gnuplot_file.write("'%s' using %d:1 with l lw 4 title 'Load=%d'"
% (data_filename, load+2, load))
gnuplot_file.close()
subprocess.call(["gnuplot", filename])
def simulate_single_simulation(single_simulation_dict,
suspension_simulation=True):
title = single_simulation_dict['model_inverse_title']
n_neurons, n_steps, n_iterations = simulation.extract_rnn_structure_from_title(
title)
title_model_inverse_data = {
'title': title,
'n_neurons': n_neurons,
'n_steps': n_steps,
'n_iterations': n_iterations
}
title = single_simulation_dict['model_title']
n_neurons, n_steps, n_iterations = simulation.extract_rnn_structure_from_title(
title)
title_model_data = {
'title': title,
'n_neurons': n_neurons,
'n_steps': n_steps,
'n_iterations': n_iterations
}
if suspension_simulation:
simulation.simulation_TCP([title_model_inverse_data],
[title_model_data],
mse_calc=False,
plotting=True)
else:
simulation_time = 40
dt = 0.5
amplitude = 2
period = 10
simulation.main(
[title_model_inverse_data], [title_model_data],
simulation_time=simulation_time,
dt=dt,
SP=model_and_inv_model_identification.generate_rectangle(
simulation_time, amplitude, period, dt=dt),
mse_calc=False,
plotting=True)
simulation_time = 100
period = 70
simulation.main(
[title_model_inverse_data], [title_model_data],
simulation_time=simulation_time,
dt=dt,
SP=model_and_inv_model_identification.generate_rectangle(
simulation_time, amplitude, period, dt=dt),
mse_calc=False,
plotting=True)
def fairness_time(load_metric, cores_per_server):
""" Plots the number of running tasks for each user, over time. """
num_tasks = 10
network_delay = 5
probes_ratio = 2
num_servers = 1000
total_time = 5000
file_prefix = "fairness"
first = True
utilization = 2.0
num_users = 4
arrival_delay = (100.0 * num_tasks /
(num_servers * cores_per_server * utilization))
simulation.main([
"job_arrival_delay=%f" % arrival_delay,
"network_delay=%d" % network_delay,
"probes_ratio=%f" % probes_ratio, "task_length_distribution=constant",
"task_distribution=constant", "job_arrival_distribution=poisson",
"deterministic=True",
"file_prefix=%s" % file_prefix,
"num_users=%d" % num_users,
"cores_per_server=%d" % cores_per_server,
"num_servers=%d" % num_servers,
"num_tasks=%d" % num_tasks,
"total_time=%d" % total_time,
"load_metric=%s" % load_metric, "relative_weights=1,1,1,2",
"relative_demands=1,1,1,1",
"first_time=%s" % first
])
gnuplot_filename = "plot_fairness.gp"
gnuplot_file = open(gnuplot_filename, "w")
gnuplot_file.write("set terminal postscript color\n")
gnuplot_file.write("set output 'graphs/fairness.ps'\n")
gnuplot_file.write("set size 0.5,0.5\n")
#gnuplot_file.write("set xlabel 'Time (ms)'\n")
#gnuplot_file.write("set ylabel 'Number of Running Tasks'\n")
gnuplot_file.write("set grid ytics\n")
gnuplot_file.write("set xrange[0:%d]\n" % total_time)
gnuplot_file.write("plot ")
# Write total number of running tasks.
gnuplot_file.write(("'raw_results/%s_running_tasks' using 1:2 lt 0 lw 4 "
"with l notitle") % file_prefix)
for user_id in range(num_users):
gnuplot_file.write(",\\\n")
gnuplot_file.write(("'raw_results/%s_running_tasks_%s' using "
"1:2 lt %d lw 4 with l notitle") %
(file_prefix, user_id, user_id + 1))
gnuplot_file.close()
return gnuplot_filename
def main():
page = st.sidebar.selectbox(
"Menu", ["COVID19 no seu Município", "Metodologia", "Quem somos?"])
if page == "Metodologia":
if __name__ == "__main__":
md.main()
elif page == "COVID19 no seu Município":
if __name__ == "__main__":
sm.main()
elif page == "Quem somos?":
if __name__ == "__main__":
tm.main()
def simulator(self):
robot_num = self.ui.Robot_num.value()
filename = self.ui.Map_filename_read.text()
algorithm = self.choose_model(self.ui.Algorithm.currentText())
alpha = self.ui.Alpha.value()
length = self.ui.Len.value()
total_time = self.ui.Total_time.value()
is_window = self.is_windowed(self.ui.Window.currentText())
cover_ratio = self.ui.Cover_ratio.value()
self.ui.progressBar.setRange(0, total_time)
if algorithm == 4 or algorithm == 5:
parameter = [alpha, length]
else:
parameter = [alpha, 0]
result = []
for i in range(total_time):
tmp = simulation.main(robot_num, algorithm, parameter, (100, 100),
filename, cover_ratio, is_window)
result.append(tmp)
np_result = np.array(result)
self.ui.Num_now.clear()
self.ui.Num_now.insertPlainText(str(i + 1))
self.ui.Time_now.clear()
self.ui.Time_now.insertPlainText(str(tmp))
self.ui.progressBar.setValue(i + 1)
print((i + 1) / total_time)
self.ui.Mean.clear()
self.ui.Mean.insertPlainText(str(np.mean(np_result)))
self.ui.Stander.clear()
self.ui.Stander.insertPlainText(str(np.std(np_result)))
self.ui.Coverage_time.setYRange(min=0, max=1000)
self.curve.setData([j for j in range(1, i + 2)], result)
def main(n=100000, generate=False):
# Read saved data
c = simulation.main(n, generate)
# Table1
print('Table I -- Number of wins by strategy')
c2 = c.groupby('strategy').agg('count').iloc[:, 0]
print(c2)
# Table2
print('______________________________________________________')
print('Table II -- Number of wins by ties and strategy')
c3 = c.groupby(['tie', 'strategy']).agg('count').iloc[:, 0]
print(c3)
print(c3.groupby(level=[0]).sum())
# Table3
print('______________________________________________________')
print('Table III -- Number of wins by goals')
c4 = c.groupby('goal').agg('count').iloc[:, 0]
print(c4)
# Table4 -- Luck
print('______________________________________________________')
print('Table IV -- Luck')
print(c[['w_avg_dice', '2nd_avg_dice', 'o_avg_dice']].median())
print(
c.groupby(by='tie').agg('median')[[
'w_avg_dice', '2nd_avg_dice', 'o_avg_dice'
]])
print(
c.groupby(by='strategy').agg('median')[[
'w_avg_dice', '2nd_avg_dice', 'o_avg_dice'
]])
# Table5 -- Luck by strategy and tie
print('______________________________________________________')
print('Table V')
print(
c.groupby(by=['tie', 'strategy']).agg('median')[[
'w_avg_dice', '2nd_avg_dice', 'o_avg_dice'
]])
# Table6 Resilience and Opportunity
print('______________________________________________________')
print('Table VI')
print(
c.groupby(by=['strategy', 'tie']).agg(['count', 'median'])[[
'w_num_rolls', 'o_avg_num_rolls', 'w_avg_dice', 'o_avg_dice'
]])
return c
def belief_tester():
global error
output = main(sys.argv)
agents = output[0]
true_prob = output[1]
for agent in agents:
try:
assert (abs(agent.cur_belief() - true_prob) <= 0.05)
logging.debug('agent {} true prob {} belief {}'.format(
agent, true_prob, agent.cur_belief()))
except AssertionError:
logging.error('agent belief issue with {}. Exiting'.format(agent))
error = True
break
def analyze_model(modelpath):
global runtimes
try:
plt.clf()
logger.info('analyze: \t' + modelpath)
start = time.clock()
dbmf.main(modelpath, True, True)
runtimes[(modelpath, 'dbmf')] = time.clock() - start
start = time.clock()
pa.main(modelpath, True, True)
runtimes[(modelpath, 'pa')] = time.clock() - start
start = time.clock()
mc.main(read_model(modelpath), 5, 1000, 95, None)
runtimes[(modelpath, 'mcsimple')] = time.clock() - start
start = time.clock()
stopping_heuristic(modelpath)
runtimes[(modelpath, 'stoppingheuristic')] = time.clock() - start
write_runtime()
#evaluate_methods(modelpath, ['cluster_subspaceXX', 'cluster_subspaceXY','cluster_subspaceXZ'])
#return
evaluate_model(modelpath, 'cluster_subspaceXY')
#evaluate_model(modelpath,'cluster_subspaceXY')
write_runtime()
#evaluate_model(modelpath,'cluster_subspaceXZ')
simu_model = read_model(modelpath)
start = time.clock()
mc.main(simu_model, 10, 10000, 95, None)
runtimes[(modelpath, 'mcfull')] = time.clock() - start
logger.info('RUNTIME:\t' + repr(runtimes))
write_runtime()
except:
write_runtime()
logger.error('ERROR AT MODEL: \t' + modelpath)
logger.error(traceback.format_exc())
def run_single(self, trial_number):
""" Using -1 as the trial number indicates that this is for a
single run, so the trial number won't be included in the filename. """
avg_num_tasks = 200. / 6 + 5 * 10. / 6
for network_delay, probes_ratio in zip(self.delay_values,
self.probes_ratio_values):
first = True
utilization_granularity = 20 # Number of different utilization values.
file_prefix = self.get_prefix(trial_number, network_delay,
probes_ratio)
for i in range(1, utilization_granularity + 1):
arrival_delay = (100. * avg_num_tasks *
utilization_granularity /
(self.num_servers * i))
simulation.main(["job_arrival_delay=%f" % arrival_delay,
"network_delay=%d" % network_delay,
"probes_ratio=%f" % probes_ratio,
"task_length_distribution=facebook",
"task_distribution=bimodal",
"file_prefix=%s" % file_prefix,
"num_servers=%d" % self.num_servers,
"total_time=%d" % self.total_time,
"first_time=%s" % first])
first = False
def simulate_threading():
# Contadores
print('Iniciando Multithreading:\n')
process_init = pt() # Contador de processo
script_init = timeit.default_timer() # Contador Benchmark
with ThreadPoolExecutor(max_workers=None) as executor:
executor.map(simulation.main())
# task2 = executor.map(cpu_data.main())
process_end = pt() - process_init
script_end = timeit.default_timer() - script_init
print('Tempo de Finalização do Processo (Threading): ', process_end)
print('Tempo de Finalização do Script (Threading): ', script_end)
print('--------------------------')
labelbottom=True,
left=False,
right=False,
labelleft=True)
plt.savefig('results/png/{}_{}_{}.png'.format(col1, col2, tie),
bbox_inches='tight')
plt.savefig('results/pdf/{}_{}.pdf'.format(col1, col2),
bbox_inches='tight')
plt.show()
if __name__ == '__main__':
m = 100000
gen = False
c = simulation.main(m, gen)
# plotting(c)
# plotting(c[c.tie], col2='2nd_avg_dice')
# plotting(c[c.tie == False], col2='2nd_avg_dice')
# p = 'strategy'
# cs = ['sensible', 'minimalist', 'blitz']
# t = 'n_countries'
# plot_kde(c, cs, p, t)
# t = 'o_avg_dice'
# plot_kde(c, cs, p, t)
# t = 'w_avg_dice'
# plot_kde(c, cs, p, t)
# p = 'goal'
# cs = ['territory18', 'territory24', 'continent', 'destroy']
# t = 'n_countries'
# plot_kde(c, cs, p, t, 'n_countries_goal')
final_cost = test3.get_cost(test3.state)
initial_cost = test3.get_cost(np.array([0., 0.]))
logging.error(
'failing bounded loss with mkt state {}, revenue {}, losing {} revenue should be {} bound {}'
.format(test3.state, test3.revenue, loss,
final_cost - initial_cost, bound))
error = True
break
bounded_loss_test(LMSRMarket)
bounded_loss_test(LMSRProfitMarket)
print 'testing all agents can be initialized'
sys.argv = ["simulation.py", "ZeroI,1", "Truthful,1", "BuyOne,1", '-q']
main(sys.argv)
sys.argv = [
"simulation.py", "ZeroI,1", "Truthful,1", "BuyOne,1",
"--mkt_type=LMSRMoney", '-q'
]
main(sys.argv)
print 'testing that posteriors update correctly'
def belief_tester():
global error
output = main(sys.argv)
agents = output[0]
true_prob = output[1]
def simulate_tourney(num_sims, ratings_type):
df = main(num_sims, ratings_type)
return df
"""Makes the robot move away from the line and into the field.
Args:
robot: A Robot object to be moved and which has detected the lines.
line: A pymunk.Vec2d object representing average direction of lines detected (from line()).
"""
# sets the robot to move in whichever direction the TOFs detect is further away from the wall
resultant = pymunk.Vec2d(
0 if line.x == 0 else abs(line.x) if
(robot.TOFReadings[1] > robot.TOFReadings[3]
and robot.TOFReadings[3] < 120) or robot.TOFReadings[1] > 120 else
-abs(line.x),
0 if line.y == 0 else abs(line.y)
if robot.TOFReadings[0] > robot.TOFReadings[2] else -abs(line.y),
)
if resultant != pymunk.Vec2d(0, 0):
robot.move(450, vec_to_world(resultant))
# the programs have been moved to separate files in the /examples for clarity
if __name__ == "__main__":
main(
CONFIG,
examples.own.attack,
examples.own.defend,
examples.opponent.o_attack,
examples.opponent.o_defend,
)
return
def o_defend(
robots: List[Robot],
detectLine: Callable,
ballPosition: pymunk.Vec2d,
robotPositions: List[pymunk.Vec2d],
dribble: Callable[[Robot], None],
kick: Callable[[Robot], None],
) -> None:
"""Program and logic for opponent defending robot.
Args:
robots: A list of both Robots for opponent side.
detectLine: Function returning a pymunk.Vec2d vector representing
average **direction** of lines detected by robot passed as argument.
ballPosition: pymunk.Vec2d object representing world coordinate position of ball.
robotPositions: List of pymunk.Vec2d objects each representing the world coordinate position of a robot,
in order [own attack robot, own defense robot, opponent attack robot, opponent defense robot].
dribble: Function to dribble the ball (and sets robot.dribbleState)
kick: Function to kick the ball in the front catchment area (if any).
"""
return
if __name__ == "__main__":
main(CONFIG, attack, defend, o_attack, o_defend)
def fairness_isolation(load_metric, network_delay, probes_ratio,
cores_per_server):
""" This function makes a graph to look at how well we achieve isolation.
We fix the usage of one user at 50% of their allocation, and increase
the usage of the other user.
"""
num_users = 2
num_tasks = 10
num_servers = 1000
task_length = 100
total_time = 2e4
file_prefix = "fairness_isolation"
capacity_tasks_per_milli = num_servers * cores_per_server / task_length
# Demand of user 0, which has constant demand that's 1/4 of cluster
# calacity (which is half of its share).
constant_demand_per_milli = capacity_tasks_per_milli / 4.0
changing_demand_per_milli = capacity_tasks_per_milli / 4.0
first = True
while changing_demand_per_milli < (1.5 * capacity_tasks_per_milli):
total_demand = constant_demand_per_milli + changing_demand_per_milli
arrival_delay = float(num_tasks) / total_demand
simulation.main([
"job_arrival_delay=%f" % arrival_delay,
"network_delay=%d" % network_delay,
"probes_ratio=%f" % probes_ratio,
"task_length_distribution=constant", "task_distribution=constant",
"job_arrival_distribution=poisson", "deterministic=True",
"file_prefix=%s" % file_prefix,
"num_users=%d" % num_users,
"num_servers=%d" % num_servers,
"cores_per_server=%d" % cores_per_server,
"num_tasks=%d" % num_tasks,
"task_length=%d" % task_length,
"total_time=%d" % total_time,
"load_metric=%s" % load_metric,
("relative_demands=%d,%d" %
(constant_demand_per_milli, changing_demand_per_milli)),
"first_time=%s" % first
])
first = False
changing_demand_per_milli += 0.1 * capacity_tasks_per_milli
first = False
gnuplot_filename = "plot_fairness_isolation.gp"
gnuplot_file = open(gnuplot_filename, "w")
gnuplot_file.write("set terminal postscript color\n")
gnuplot_file.write("set output 'graphs/fairness_isolation.ps'\n")
gnuplot_file.write("set size 0.5,0.5\n")
#gnuplot_file.write("set xlabel 'Utilization'\n")
#gnuplot_file.write("set ylabel 'Normalized Response Time (ms)'\n")
gnuplot_file.write("set yrange [0:600]\n")
gnuplot_file.write("set grid ytics\n")
gnuplot_file.write("plot ")
gnuplot_file.write(("'raw_results/%s_response_time' using "
"3:4 lt 0 lw 4 with l notitle,\\\n") % (file_prefix))
gnuplot_file.write(("'raw_results/%s_response_time' using "
"3:4:5 lt 0 lw 4 with errorbars "
"notitle") % (file_prefix))
for user_id in range(num_users):
gnuplot_file.write(",\\\n")
gnuplot_file.write(("'raw_results/%s_response_time_%s' using "
"3:4 lt %d lw 4 with l notitle,\\\n") %
(file_prefix, user_id, user_id + 1))
gnuplot_file.write(("'raw_results/%s_response_time_%s' using "
"3:4:5 lt %d lw 4 with errorbars "
"notitle") % (file_prefix, user_id, user_id + 1))
gnuplot_file.close()
return gnuplot_filename
def execute_run(data):
""" Calls each run for a given run schedule.
Separate function to allow multiprocessing.
"""
main(data)
import sys
from simulation import main
sys.argv = [
'simulation.py',
'--initial_state=0.1,0.1',
'--num_rounds=3',
'--num_trials=2',
'--budget=10.',
'--mkt_type=LMSR',
'-q',
'BuyOne,3',
'Truthful,3',
]
output = main(sys.argv)
agents = output[0]
true_prob = output[1]
mkt_revenues = output[2]
mkt_probs = output[3]
mkt_lower_bounds = output[4]
mkt_upper_bounds = output[5]
agent_beliefs = output[6]
mkt_payoffs = output[7]
print 'agents in the market are {}'.format(agents)
for agent in agents:
print(
'access agent IDs like this: {} (useful for indexing into agent_beliefs, below)'
.format(agent.id))
print 'true probability of occurrence is {}'.format(true_prob)
def main():
# Get cli args
kargs = get_args()
print(kargs)
instance = kargs["instance"]
# Final dataframe containing data for each experiment of the simulation
final_df = pd.DataFrame()
# Create folder with timestamp as name for storing
# simulation data
dir_path = create_timestamp_folder(
config_manager.SIMULATION_CONTROLLER_ARCHIVE_PATH)
if instance == "":
# 1) Generate instance configuration
print("> STEP 1 - Generating instance configuration...")
instance_generator.main()
# Move instance generator output to final folder
copy_dir(config_manager.OUTPUT_INSTANCE_PATH, dir_path)
else:
print("> STEP 1 - Skip -- instance passed as param: {}...".format(
instance))
copy_file(instance, dir_path)
# Before simulations starts, remove all agent logs file from base foulder
remove_dir_content(config_manager.SIMULATION_AGENT_LOGGING_BASE_PATH)
# Execute each instance for a predefined number of times (ex. 5)
for i in range(0, config_manager.NUMBER_OF_SIMULATION_EXECUTION):
# Generate a random seed for the experiment
# Note: this is a very important point for experiment reproduction
# Is very important set seed for both library (random and np)
seed = np.random.randint(0, 4096)
random.seed(seed)
np.random.seed(seed)
# 2) Single simulation based on configuration file generated before
print("> STEP 2 - Simulation of instance...")
simulation.main(instance)
#time.sleep(2)
# 3) Analyze simulation output
print("> STEP 3 - Analyze output...")
analyzer.main()
# Create a dir for each iteration of the simulation
# Move analyzer output files to final foulder (separated for each iteration)
path = dir_path.joinpath("iteration_{}".format(i))
os.makedirs(path)
copy_dir(config_manager.ANALYZER_OUTPUT_PATH, path)
# Copy to this foulder also simulation results (weights for each agent)
# Also clean src dir of all content (avoiding file overwriting)
copy_dir(config_manager.SIMULATION_AGENT_LOGGING_BASE_PATH, path)
remove_dir_content(config_manager.SIMULATION_AGENT_LOGGING_BASE_PATH)
#time.sleep(2)
# 4) Load analyzer output file that contains index for comparison
print("> STEP 4 - Load Index df...")
df = pd.read_csv(config_manager.INDEX_COMPARISON_FILE,
delimiter='\t',
header=0,
index_col=0)
df.index.name = "strategy"
df["seed"] = [seed] * len(list(df.index.values))
df.set_index(["seed", df.index], inplace=True)
print(df)
if final_df.empty:
final_df = df
else:
final_df = pd.concat([final_df, df])
# print(final_df)
# time.sleep(5)
# 5) Export final results comparison table
print("> STEP 5 - Export final results table...")
print(final_df)
final_df.to_csv(config_manager.SIMULATION_CONTROLLER_OUTPUT_FILE,
sep='\t',
encoding='utf-8')
# Move instance generator output to final folder
copy_dir(config_manager.SIMULATION_CONTROLLER_OUTPUT_PATH, dir_path)
with open(
dir_path.joinpath(
config_manager.
SIMULATION_CONTROLLER_ARCHIVE_COMPARISON_FILE_NAME), "w") as f:
# Print mean result of comparison index after 5 executions
for s in config_manager.STRATEGIES:
print("---------------------------------------------")
f.write("---------------------------------------------\n")
print("> Strategy {}".format(s))
f.write("> Strategy {}\n".format(s))
res = final_df.query("strategy == @s")
for index in config_manager.INDEX_TO_MEAN_FOR_COMPARISON_FOR_TXT_FILE:
#print(res[index])
val = res[index].mean()
print(" > {}: {:0.2f}".format(index, val))
f.write(" > {}: {:0.2f}\n".format(index, val))
# Zip archive foulder with all previous gathered data
zip_foulder(dir_path, dir_path)
# Remove dir previously zipped
remove_dir_with_content(dir_path)
import topologies import simulation simulation.main(topologies.topologies[0], 5) simulation.main(topologies.topologies[0], 6) simulation.main(topologies.topologies[1], 5) simulation.main(topologies.topologies[1], 6) simulation.main(topologies.topologies[2], 5) simulation.main(topologies.topologies[2], 6)
def fairness_isolation(load_metric, network_delay, probes_ratio,
cores_per_server):
""" This function makes a graph to look at how well we achieve isolation.
We fix the usage of one user at 50% of their allocation, and increase
the usage of the other user.
"""
num_users = 2
num_tasks = 10
num_servers = 1000
task_length = 100
total_time = 2e4
file_prefix = "fairness_isolation"
capacity_tasks_per_milli = num_servers * cores_per_server / task_length
# Demand of user 0, which has constant demand that's 1/4 of cluster
# calacity (which is half of its share).
constant_demand_per_milli = capacity_tasks_per_milli / 4.0
changing_demand_per_milli = capacity_tasks_per_milli / 4.0
first = True
while changing_demand_per_milli < (1.5 * capacity_tasks_per_milli):
total_demand = constant_demand_per_milli + changing_demand_per_milli
arrival_delay = float(num_tasks) / total_demand
simulation.main(["job_arrival_delay=%f" % arrival_delay,
"network_delay=%d" % network_delay,
"probes_ratio=%f" % probes_ratio,
"task_length_distribution=constant",
"task_distribution=constant",
"job_arrival_distribution=poisson",
"deterministic=True",
"file_prefix=%s" % file_prefix,
"num_users=%d" % num_users,
"num_servers=%d" % num_servers,
"cores_per_server=%d" % cores_per_server,
"num_tasks=%d" % num_tasks,
"task_length=%d" % task_length,
"total_time=%d" % total_time,
"load_metric=%s" % load_metric,
("relative_demands=%d,%d" %
(constant_demand_per_milli,
changing_demand_per_milli)),
"first_time=%s" % first])
first = False
changing_demand_per_milli += 0.1 * capacity_tasks_per_milli
first = False
gnuplot_filename = "plot_fairness_isolation.gp"
gnuplot_file = open(gnuplot_filename, "w")
gnuplot_file.write("set terminal postscript color\n")
gnuplot_file.write("set output 'graphs/fairness_isolation.ps'\n")
gnuplot_file.write("set size 0.5,0.5\n")
#gnuplot_file.write("set xlabel 'Utilization'\n")
#gnuplot_file.write("set ylabel 'Normalized Response Time (ms)'\n")
gnuplot_file.write("set yrange [0:600]\n")
gnuplot_file.write("set grid ytics\n")
gnuplot_file.write("plot ")
gnuplot_file.write(("'raw_results/%s_response_time' using "
"3:4 lt 0 lw 4 with l notitle,\\\n") %
(file_prefix))
gnuplot_file.write(("'raw_results/%s_response_time' using "
"3:4:5 lt 0 lw 4 with errorbars "
"notitle") % (file_prefix))
for user_id in range(num_users):
gnuplot_file.write(",\\\n")
gnuplot_file.write(("'raw_results/%s_response_time_%s' using "
"3:4 lt %d lw 4 with l notitle,\\\n") %
(file_prefix, user_id, user_id + 1))
gnuplot_file.write(("'raw_results/%s_response_time_%s' using "
"3:4:5 lt %d lw 4 with errorbars "
"notitle") %
(file_prefix, user_id, user_id + 1))
gnuplot_file.close()
return gnuplot_filename
