def recv(self):
serialized_ack, addr = self.sock.recvfrom(1600)
if addr != self.peer_addr:
return
ack = datagram_pb2.Ack()
ack.ParseFromString(serialized_ack)
action = self.action
self.update_state(ack)
if self.step_start_ms is None:
self.step_start_ms = curr_ts_ms()
done = False
reward = 0
# At each step end, feed the state:
if curr_ts_ms() - self.step_start_ms > self.step_len_ms: # step's end
self.state = [
self.delay_ewma, self.delivery_rate_ewma, self.send_rate_ewma,
self.cwnd
]
#print(state)
# time how long it takes to get an action from the NN
if self.debug:
start_sample = time.time()
norm_state = normalize(self.state)
one_hot_action = one_hot(self.action, self.action_cnt)
state = norm_state + one_hot_action
self.action = self.sample_action(state)
if self.debug:
self.sampling_file.write('%.2f ms\n' %
((time.time() - start_sample) * 1000))
self.take_action(self.action)
'''
self.delay_ewma = None
self.delivery_rate_ewma = None
self.send_rate_ewma = None
'''
self.step_start_ms = curr_ts_ms()
done = False
if self.train:
self.step_cnt += 1
reward = self.compute_performance()
if self.step_cnt >= Sender.max_steps:
self.step_cnt = 0
self.running = False
done = True
#print self.state,self.action, reward, done
return self.state, action, reward, done
def run_one_train_step(self, batch_states, batch_actions):
""" Runs one step of the training operator on the given data.
At times will update Tensorboard and save a checkpointed model.
Returns the total loss calculated.
"""
summary = True if self.train_step % 10 == 0 else False
ops_to_run = [self.train_op, self.total_loss]
if summary:
ops_to_run.append(self.summary_op)
pi = self.global_network
start_ts = curr_ts_ms()
ret = self.sess.run(ops_to_run,
feed_dict={
pi.input: batch_states,
self.actions: batch_actions,
pi.state_in: self.init_state
})
elapsed = (curr_ts_ms() - start_ts) / 1000.0
sys.stderr.write('train step %d: time %.2f\n' %
(self.train_step, elapsed))
if summary:
self.summary_writer.add_summary(ret[2], self.train_step)
print "Dagger leader: ret"
print ret
return ret[1]
def recv(self):
serialized_ack, addr = self.sock.recvfrom(1600)
if addr != self.peer_addr:
return
ack = datagram_pb2.Ack()
ack.ParseFromString(serialized_ack)
self.update_state(ack)
if self.step_start_ms is None:
self.step_start_ms = curr_ts_ms()
# At each step end, feed the state:
if curr_ts_ms() - self.step_start_ms > self.step_len_ms: # step's end
state = [
self.delay_ewma, self.delivery_rate_ewma, self.send_rate_ewma,
self.cwnd
]
# time how long it takes to get an action from the NN
if self.debug:
start_sample = time.time()
action = self.sample_action(state)
#os.system()
##scriptx = "echo "+"{:04d}".format(self.thid)+ '\t' +str(time.time()) + '\t'+str(self.delay_ewma)+'\t'+str(self.delivery_rate_ewma)+'\t'+str(self.send_rate_ewma)+'\t'+str(self.cwnd) +">> logx/"+line_algo+"-state.txt"
##proc = subprocess.Popen(scriptx,stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
#(out, err) = proc.communicate()
if self.debug:
self.sampling_file.write('%.2f ms\n' %
((time.time() - start_sample) * 1000))
self.take_action(action)
self.delay_ewma = None
self.delivery_rate_ewma = None
self.send_rate_ewma = None
self.step_start_ms = curr_ts_ms()
if self.train:
self.step_cnt += 1
if self.step_cnt >= Sender.max_steps:
self.step_cnt = 0
self.running = False
self.compute_performance()
def recv(self):
serialized_ack, addr = self.sock.recvfrom(1600)
k = -1
if addr != self.peer_addr:
return
ack = datagram_pb2.Ack()
ack.ParseFromString(serialized_ack)
self.update_state(ack)
if self.step_start_ms is None:
self.step_start_ms = curr_ts_ms()
# At each step end, feed the state:
if curr_ts_ms() - self.step_start_ms > self.step_len_ms: # step's end
state = [
self.delay_ewma, self.delivery_rate_ewma, self.send_rate_ewma,
self.cwnd
]
# time how long it takes to get an action from the NN
if self.debug:
start_sample = time.time()
action = self.sample_action(state)
if self.debug:
self.sampling_file.write('%.2f ms\n' %
((time.time() - start_sample) * 1000))
self.take_action(action)
self.delay_ewma = None
self.delivery_rate_ewma = None
self.send_rate_ewma = None
self.step_start_ms = curr_ts_ms()
if self.train:
self.step_cnt += 1
if self.step_cnt >= Sender.max_steps:
self.step_cnt = 0
self.running = False
k = self.compute_performance()
return k
def compute_performance(self):
duration = curr_ts_ms() - self.ts_first
tput = 0.008 * self.delivered / duration
perc_delay = np.percentile(self.rtt_buf, 95)
with open(path.join(project_root.DIR, 'env', 'perf'), 'a', 0) as perf:
perf.write('%.2f %d\n' % (tput, perc_delay))
def compute_performance(self):
print("****************IN COMPUTE_PERFORMANCE*********************")
duration = curr_ts_ms() - self.ts_first
tput = 0.008 * self.delivered / duration
perc_delay = np.percentile(self.rtt_buf, 95)
print(tput)
print(perc_delay)
return 10 * tput - perc_delay
with open(path.join(project_root.DIR, 'env', 'perf'), 'a', 0) as perf:
perf.write('%.2f %d\n' % (tput, perc_delay))
def update_state(self, ack):
""" Update the state variables listed in __init__() """
self.next_ack = max(self.next_ack, ack.seq_num + 1)
curr_time_ms = curr_ts_ms()
# Update RTT
rtt = float(curr_time_ms - ack.send_ts)
self.min_rtt = min(self.min_rtt, rtt)
if self.train:
if self.ts_first is None:
self.ts_first = curr_time_ms
self.rtt_buf.append(rtt)
delay = rtt - self.min_rtt
if self.delay_ewma is None:
self.delay_ewma = delay
else:
self.delay_ewma = 0.875 * self.delay_ewma + 0.125 * delay
# Update BBR's delivery rate
self.delivered += ack.ack_bytes
self.delivered_time = curr_time_ms
delivery_rate = (0.008 * (self.delivered - ack.delivered) /
max(1, self.delivered_time - ack.delivered_time))
if self.delivery_rate_ewma is None:
self.delivery_rate_ewma = delivery_rate
else:
self.delivery_rate_ewma = (0.875 * self.delivery_rate_ewma +
0.125 * delivery_rate)
# Update Vegas sending rate
send_rate = 0.008 * (self.sent_bytes - ack.sent_bytes) / max(1, rtt)
if self.send_rate_ewma is None:
self.send_rate_ewma = send_rate
else:
self.send_rate_ewma = (0.875 * self.send_rate_ewma +
0.125 * send_rate)
# todo: test : Real time or EWMA version
if self.q_delivery_rate.full():
self.q_delivery_rate.get()
self.q_delivery_rate.put(self.cwnd)
if self.q_delay.full():
self.q_delay.get()
self.q_delay.put(delay)
if self.q_send_rate.full():
self.q_send_rate.get()
self.q_send_rate.put(send_rate)
def send(self):
data = datagram_pb2.Data()
data.seq_num = self.seq_num
data.send_ts = curr_ts_ms()
data.sent_bytes = self.sent_bytes
data.delivered_time = self.delivered_time
data.delivered = self.delivered
data.payload = self.dummy_payload
serialized_data = data.SerializeToString()
self.sock.sendto(serialized_data, self.peer_addr)
self.seq_num += 1
self.sent_bytes += len(serialized_data)
def compute_performance(self):
sys.stderr.write(
'\n****************IN COMPUTE_PERFORMANCE*********************\n')
# print("****************IN COMPUTE_PERFORMANCE*********************")
duration = curr_ts_ms() - self.ts_first
tput = 0.008 * self.delivered / duration
perc_delay = np.percentile(self.rtt_buf, 95)
sys.stderr.write('tput and tput/gt are: (%f,%f)\n' % (tput, tput / gt))
sys.stderr.write('perc_delay: %f\n' % perc_delay)
return 10 * tput - perc_delay
# return 100*(tput/self.gt) - perc_delay
with open(path.join(project_root.DIR, 'env', 'perf'), 'a', 0) as perf:
perf.write('%.2f %d\n' % (tput, perc_delay))
def update_state(self, ack):
""" Update the state variables listed in __init__() """
self.new_rec_count += 1
self.next_ack = max(self.next_ack, ack.seq_num + 1)
curr_time_ms = curr_ts_ms()
# Update RTT
rtt = float(curr_time_ms - ack.send_ts)
self.min_rtt = min(self.min_rtt, rtt)
if self.train:
if self.ts_first is None:
self.ts_first = curr_time_ms
self.rtt_buf.append(rtt)
else:
self.new_rtt_buf.append(rtt)
delay = rtt - self.min_rtt
if self.delay_ewma is None:
self.delay_ewma = delay
else:
self.delay_ewma = 0.875 * self.delay_ewma + 0.125 * delay
# Update BBR's delivery rate
self.delivered += ack.ack_bytes
self.delivered_time = curr_time_ms
delivery_rate = (0.008 * (self.delivered - ack.delivered) /
max(1, self.delivered_time - ack.delivered_time))
if self.delivery_rate_ewma is None:
self.delivery_rate_ewma = delivery_rate
else:
self.delivery_rate_ewma = (0.875 * self.delivery_rate_ewma +
0.125 * delivery_rate)
# Update Vegas sending rate
send_rate = 0.008 * (self.sent_bytes - ack.sent_bytes) / max(1, rtt)
if self.send_rate_ewma is None:
self.send_rate_ewma = send_rate
else:
self.send_rate_ewma = (0.875 * self.send_rate_ewma +
0.125 * send_rate)
def compute_performance(self):
duration = curr_ts_ms() - self.ts_first
tput = 0.008 * self.delivered / duration
#Compute the qth percentile of the data along the specified axis.
perc_delay = np.percentile(self.rtt_buf, 95)
util = self.utility
self.utility = tput - 0.1 * perc_delay
with open(path.join(project_root.DIR, 'env', 'perf'), 'a', 0) as perf:
perf.write('%.2f %d\n' % (tput, perc_delay))
if self.utility - util > 0.01:
reward = 1
elif self.utility - util < -0.01:
reward = -1
else:
reward = 0
#print(tput, perc_delay, self.utility, reward)
return reward
def update_state(self, ack):
self.next_ack = max(self.next_ack, ack.seq_num + 1)
curr_time_ms = curr_ts_ms()
rtt = float(curr_time_ms - ack.send_ts)
self.min_rtt = min(self.min_rtt, rtt)
queue_delay = rtt - self.min_rtt
if self.delay_ewma is None:
self.delay_ewma = queue_delay
else:
self.delay_ewma = 0.875 * self.delay_ewma + 0.125 * queue_delay
# Update BBR's delivery rate
self.delivered += ack.ack_bytes
self.delivered_time = curr_time_ms
delivery_rate = (0.008 * (self.delivered - ack.delivered) /
max(1, self.delivered_time - ack.delivered_time))
if self.delivery_rate_ewma is None:
self.delivery_rate_ewma = delivery_rate
else:
self.delivery_rate_ewma = (
0.875 * self.delivery_rate_ewma + 0.125 * delivery_rate)
# Update Vegas sending rate
send_rate = 0.008 * (self.sent_bytes - ack.sent_bytes) / max(1, rtt)
if self.send_rate_ewma is None:
self.send_rate_ewma = send_rate
else:
self.send_rate_ewma = (
0.875 * self.send_rate_ewma + 0.125 * send_rate)
def recv(self):
serialized_ack, addr = self.sock.recvfrom(1600)
if addr != self.peer_addr:
return
ack = datagram_pb2.Ack()
ack.ParseFromString(serialized_ack)
self.update_state(ack)
if self.step_start_ms is None:
self.step_start_ms = curr_ts_ms()
# At each step end, feed the state:
if curr_ts_ms() - self.step_start_ms > self.step_len_ms: # step's end
self.new_send_count = self.seq_num - self.last_seq_num
self.last_seq_num = self.seq_num
new_not_ack_count = self.new_send_count - self.new_rec_count
new_loss = float(
new_not_ack_count
) / self.new_send_count if self.new_send_count else 0
new_latency = self.new_compute_latency() / 1000 # s
# new_throughput = float(self.new_rec_count) / self.step_len_ms
delivered = self.delivered - self.last_delivered
new_throughput = 0.008 * delivered / self.step_len_ms # Mbit/s
self.last_delivered = self.delivered
new_ele_list = [new_throughput, new_latency, new_loss]
# sys.stderr.write(str(new_ele_list)+'\n')
new_reward = new_throughput - 10 * new_latency
state = [
self.delay_ewma, self.delivery_rate_ewma, self.send_rate_ewma,
self.cwnd
]
# time how long it takes to get an action from the NN
if self.debug:
start_sample = time.time()
action, new_aug_state = self.sample_action(state)
new_is_done = 0
self.fout.write('|'.join([
str(self.new_pre_state),
str(action),
str(new_aug_state),
str(new_reward),
str(new_is_done),
str(new_ele_list)
]))
self.fout.write('\n')
self.new_pre_state = new_aug_state
self.new_rec_count = 0
if self.debug:
self.sampling_file.write('%.2f ms\n' %
((time.time() - start_sample) * 1000))
self.take_action(action)
self.delay_ewma = None
self.delivery_rate_ewma = None
self.send_rate_ewma = None
self.step_start_ms = curr_ts_ms()
if self.train:
self.step_cnt += 1
if self.step_cnt >= Sender.max_steps:
self.step_cnt = 0
self.running = False
self.compute_performance()
