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