def get_reward(self, trace_file: str, trace=None) -> float: if trace_file and trace_file.endswith('.json'): trace = Trace.load_from_file(trace_file) elif trace_file and trace_file.endswith('.log'): trace = Trace.load_from_pantheon_file(trace_file, 0, 50, 500) loss = self.get_loss_rate() if trace is None: # original reward return pcc_aurora_reward( self.get_avg_throughput() * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET, self.get_avg_latency() / 1e3, loss) # normalized reward return pcc_aurora_reward( self.get_avg_throughput() * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET, self.get_avg_latency() / 1e3, loss, trace.avg_bw * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET, trace.min_delay * 2 / 1e3)
def reward(self, avg_bw=None): if avg_bw is None: avg_bw = np.mean([ val for ts, val in zip(self.datalink.link_capacity_timestamps, self.datalink.link_capacity) if ts >= min(self.datalink.throughput_timestamps[0], self.datalink.sending_rate_timestamps[0]) ]) reward = pcc_aurora_reward( self.datalink.avg_throughput / avg_bw, # * 1e6 / 8 / 1500, (np.mean(self.datalink.one_way_delay) + np.mean(self.acklink.one_way_delay)) / 1000, self.datalink.loss_rate) return reward
def on_mi_finish(self) -> Tuple[float, float]: self.record_run() sender_mi = self.history.back() # get_run_data() throughput = sender_mi.get("recv rate") # bits/sec latency = sender_mi.get("avg latency") # second loss = sender_mi.get("loss ratio") reward = pcc_aurora_reward( throughput / BITS_PER_BYTE / BYTES_PER_PACKET, latency, loss, self.trace.avg_bw * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET, self.trace.avg_delay * 2 / 1e3) if latency > 0.0: mi_duration = MI_RTT_PROPORTION * \ sender_mi.get("avg latency") + np.mean(self.net.extra_delays) else: mi_duration = 0 return reward, mi_duration
def on_mi_finish(self) -> Tuple[float, float]: self.record_run() sender_mi = self.history.back() # get_run_data() throughput = sender_mi.get("recv rate") # bits/sec latency = sender_mi.get("avg latency") # second loss = sender_mi.get("loss ratio") reward = pcc_aurora_reward( throughput / BITS_PER_BYTE / BYTES_PER_PACKET, latency, loss, self.trace.avg_bw * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET, self.trace.avg_delay * 2 / 1e3) if latency > 0.0: self.mi_duration = MI_RTT_PROPORTION * \ sender_mi.get("avg latency") # + np.mean(extra_delays) self.btlbw_filter.update(throughput, self.round_count) min_lat = sender_mi.get("conn min latency") btlbw = self.btlbw_filter.get_btlbw() self.cwnd = max(2 * round(btlbw * self.min_latency / BITS_PER_BYTE / BYTES_PER_PACKET), MIN_CWND * 2) return reward, self.mi_duration
def run_for_dur(self, dur, action=None): if self.senders[0].lat_diff != 0: self.senders[0].start_stage = False start_time = self.cur_time end_time = min(self.cur_time + dur, self.env.current_trace.timestamps[-1]) # debug_print('MI from {} to {}, dur {}'.format( # self.cur_time, end_time, dur)) for sender in self.senders: sender.reset_obs() # set_obs_start = False extra_delays = [] # time used to put packet onto the network while True: event_time, sender, event_type, next_hop, cur_latency, dropped, \ event_id, rto, event_queue_delay = self.q[0] # if not sender.got_data and event_time >= end_time and event_type == EVENT_TYPE_ACK and next_hop == len(sender.path): # end_time = event_time # self.cur_time = end_time # self.env.run_dur = end_time - start_time # break if sender.got_data and event_time >= end_time and event_type == EVENT_TYPE_SEND: end_time = event_time self.cur_time = end_time break event_time, sender, event_type, next_hop, cur_latency, dropped, \ event_id, rto, event_queue_delay = heapq.heappop(self.q) self.cur_time = event_time new_event_time = event_time new_event_type = event_type new_next_hop = next_hop new_latency = cur_latency new_dropped = dropped new_event_queue_delay = event_queue_delay push_new_event = False # debug_print("Got %d event %s, to link %d, latency %f at time %f, " # "next_hop %d, dropped %s, event_q length %f, " # "sender rate %f, duration: %f, queue_size: %f, " # "rto: %f, cwnd: %f, ssthresh: %f, sender rto %f, " # "pkt in flight %d, wait time %d" % ( # event_id, event_type, next_hop, cur_latency, # event_time, next_hop, dropped, len(self.q), # sender.rate, dur, self.links[0].queue_size, # rto, sender.cwnd, sender.ssthresh, sender.rto, # int(sender.bytes_in_flight/BYTES_PER_PACKET), # sender.pkt_loss_wait_time)) if event_type == EVENT_TYPE_ACK: if next_hop == len(sender.path): # if cur_latency > 1.0: # sender.timeout(cur_latency) # sender.on_packet_lost(cur_latency) if rto >= 0 and cur_latency > rto and sender.pkt_loss_wait_time <= 0: sender.timeout() dropped = True new_dropped = True elif dropped: sender.on_packet_lost(cur_latency) if self.env.record_pkt_log: self.pkt_log.append([ self.cur_time, event_id, 'lost', BYTES_PER_PACKET, cur_latency, event_queue_delay, self.links[0].pkt_in_queue, sender.rate * BYTES_PER_PACKET * BITS_PER_BYTE, self.links[0].get_bandwidth(self.cur_time) * BYTES_PER_PACKET * BITS_PER_BYTE ]) else: sender.on_packet_acked(cur_latency) # debug_print('Ack packet at {}'.format(self.cur_time)) # log packet acked if self.env.record_pkt_log: self.pkt_log.append([ self.cur_time, event_id, 'acked', BYTES_PER_PACKET, cur_latency, event_queue_delay, self.links[0].pkt_in_queue, sender.rate * BYTES_PER_PACKET * BITS_PER_BYTE, self.links[0].get_bandwidth(self.cur_time) * BYTES_PER_PACKET * BITS_PER_BYTE ]) else: # comment out to save disk usage # if self.env.record_pkt_log: # self.pkt_log.append( # [self.cur_time, event_id, 'arrived', # BYTES_PER_PACKET, cur_latency, event_queue_delay, # self.links[0].pkt_in_queue, # sender.rate * BYTES_PER_PACKET * BITS_PER_BYTE, # self.links[0].get_bandwidth(self.cur_time) * BYTES_PER_PACKET * BITS_PER_BYTE]) new_next_hop = next_hop + 1 # new_event_queue_delay += sender.path[next_hop].get_cur_queue_delay( # self.cur_time) link_latency = sender.path[ next_hop].get_cur_propagation_latency(self.cur_time) # link_latency *= self.env.current_trace.get_delay_noise_replay(self.cur_time) # if USE_LATENCY_NOISE: # link_latency *= random.uniform(1.0, MAX_LATENCY_NOISE) new_latency += link_latency new_event_time += link_latency push_new_event = True elif event_type == EVENT_TYPE_SEND: if next_hop == 0: if sender.can_send_packet(): sender.on_packet_sent() # print('Send packet at {}'.format(self.cur_time)) if not self.env.train_flag and self.env.record_pkt_log: self.pkt_log.append([ self.cur_time, event_id, 'sent', BYTES_PER_PACKET, cur_latency, event_queue_delay, self.links[0].pkt_in_queue, sender.rate * BYTES_PER_PACKET * BITS_PER_BYTE, self.links[0].get_bandwidth(self.cur_time) * BYTES_PER_PACKET * BITS_PER_BYTE ]) push_new_event = True heapq.heappush(self.q, (self.cur_time + (1.0 / sender.rate), sender, EVENT_TYPE_SEND, 0, 0.0, False, self.event_count, sender.rto, 0)) self.event_count += 1 else: push_new_event = True if next_hop == sender.dest: new_event_type = EVENT_TYPE_ACK new_next_hop = next_hop + 1 prop_delay, new_event_queue_delay = sender.path[ next_hop].get_cur_latency(self.cur_time) link_latency = prop_delay + new_event_queue_delay # if USE_LATENCY_NOISE: # link_latency *= random.uniform(1.0, MAX_LATENCY_NOISE) # link_latency += self.env.current_trace.get_delay_noise( # self.cur_time, self.links[0].get_bandwidth(self.cur_time)) / 1000 # link_latency += max(0, np.random.normal(0, 1) / 1000) # link_latency += max(0, np.random.uniform(0, 5) / 1000) rand = random.uniform(0, 1) if rand > 0.9: noise = random.uniform( 0, sender.path[next_hop].trace.delay_noise) / 1000 else: noise = 0 new_latency += noise new_event_time += noise # link_latency *= self.env.current_trace.get_delay_noise_replay(self.cur_time) new_latency += link_latency new_event_time += link_latency new_dropped = not sender.path[next_hop].packet_enters_link( self.cur_time) extra_delays.append(1 / self.links[0].get_bandwidth(self.cur_time)) # new_latency += 1 / self.links[0].get_bandwidth(self.cur_time) # new_event_time += 1 / self.links[0].get_bandwidth(self.cur_time) if not new_dropped: sender.queue_delay_samples.append(new_event_queue_delay) if push_new_event: heapq.heappush(self.q, (new_event_time, sender, new_event_type, new_next_hop, new_latency, new_dropped, event_id, rto, new_event_queue_delay)) for sender in self.senders: sender.record_run() sender_mi = self.senders[0].history.back() #get_run_data() throughput = sender_mi.get("recv rate") # bits/sec latency = sender_mi.get("avg latency") # second loss = sender_mi.get("loss ratio") # debug_print("thpt %f, delay %f, loss %f, bytes sent %f, bytes acked %f" % ( # throughput/1e6, latency, loss, sender_mi.bytes_sent, sender_mi.bytes_acked)) avg_bw_in_mi = self.env.current_trace.get_avail_bits2send( start_time, end_time) / ( end_time - start_time) / BITS_PER_BYTE / BYTES_PER_PACKET # avg_bw_in_mi = np.mean(self.env.current_trace.bandwidths) * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET reward = pcc_aurora_reward( throughput / BITS_PER_BYTE / BYTES_PER_PACKET, latency, loss, avg_bw_in_mi, np.mean(self.env.current_trace.delays) * 2 / 1e3) # self.env.run_dur = MI_RTT_PROPORTION * self.senders[0].estRTT # + np.mean(extra_delays) if latency > 0.0: self.env.run_dur = MI_RTT_PROPORTION * \ sender_mi.get("avg latency") + np.mean(np.array(extra_delays)) # elif self.env.run_dur != 0.01: # assert self.env.run_dur >= 0.03 # self.env.run_dur = max(MI_RTT_PROPORTION * sender_mi.get("avg latency"), 5 * (1 / self.senders[0].rate)) # self.senders[0].avg_latency = sender_mi.get("avg latency") # second # self.senders[0].recv_rate = round(sender_mi.get("recv rate"), 3) # bits/sec # self.senders[0].send_rate = round(sender_mi.get("send rate"), 3) # bits/sec # self.senders[0].lat_diff = sender_mi.rtt_samples[-1] - sender_mi.rtt_samples[0] # self.senders[0].latest_rtt = sender_mi.rtt_samples[-1] # self.recv_rate_cache.append(self.senders[0].recv_rate) # if len(self.recv_rate_cache) > 6: # self.recv_rate_cache = self.recv_rate_cache[1:] # self.senders[0].max_tput = max(self.recv_rate_cache) # # if self.senders[0].lat_diff == 0 and self.senders[0].start_stage: # no latency change # pass # # self.senders[0].max_tput = max(self.senders[0].recv_rate, self.senders[0].max_tput) # elif self.senders[0].lat_diff == 0 and not self.senders[0].start_stage: # no latency change # pass # # self.senders[0].max_tput = max(self.senders[0].recv_rate, self.senders[0].max_tput) # elif self.senders[0].lat_diff > 0: # latency increase # self.senders[0].start_stage = False # # self.senders[0].max_tput = self.senders[0].recv_rate # , self.max_tput) # else: # latency decrease # self.senders[0].start_stage = False # # self.senders[0].max_tput = max(self.senders[0].recv_rate, self.senders[0].max_tput) return reward # * REWARD_SCALE
def test(self, trace: Trace, save_dir: str, plot_flag: bool = False) -> Tuple[float, float]: """Test a network trace and return rewards. The 1st return value is the reward in Monitor Interval(MI) level and the length of MI is 1 srtt. The 2nd return value is the reward in packet level. It is computed by using throughput, average rtt, and loss rate in each 500ms bin of the packet log. The 2nd value will be 0 if record_pkt_log flag is False. Args: trace: network trace. save_dir: where a MI level log will be saved if save_dir is a valid path. A packet level log will be saved if record_pkt_log flag is True and save_dir is a valid path. """ links = [Link(trace), Link(trace)] senders = [BBRSender(0, 0, self.seed)] net = Network(senders, links, self.record_pkt_log) rewards = [] start_rtt = trace.get_delay(0) * 2 / 1000 run_dur = start_rtt if save_dir: os.makedirs(save_dir, exist_ok=True) f_sim_log = open( os.path.join(save_dir, '{}_simulation_log.csv'.format(self.cc_name)), 'w', 1) writer = csv.writer(f_sim_log, lineterminator='\n') writer.writerow([ 'timestamp', "send_rate", 'recv_rate', 'latency', 'loss', 'reward', "action", "bytes_sent", "bytes_acked", "bytes_lost", "send_start_time", "send_end_time", 'recv_start_time', 'recv_end_time', 'latency_increase', "packet_size", 'bandwidth', "queue_delay", 'packet_in_queue', 'queue_size', 'cwnd', 'ssthresh', "rto", "packets_in_flight" ]) else: f_sim_log = None writer = None while True: net.run(run_dur) mi = senders[0].get_run_data() throughput = mi.get("recv rate") # bits/sec send_rate = mi.get("send rate") # bits/sec latency = mi.get("avg latency") avg_queue_delay = mi.get("avg queue delay") loss = mi.get("loss ratio") reward = pcc_aurora_reward( throughput / BITS_PER_BYTE / BYTES_PER_PACKET, latency, loss, trace.avg_bw * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET) rewards.append(reward) try: ssthresh = senders[0].ssthresh except: ssthresh = 0 action = 0 if save_dir and writer: writer.writerow([ net.get_cur_time(), send_rate, throughput, latency, loss, reward, action, mi.bytes_sent, mi.bytes_acked, mi.bytes_lost, mi.send_start, mi.send_end, mi.recv_start, mi.recv_end, mi.get('latency increase'), mi.packet_size, links[0].get_bandwidth(net.get_cur_time()) * BYTES_PER_PACKET * BITS_PER_BYTE, avg_queue_delay, links[0].pkt_in_queue, links[0].queue_size, senders[0].cwnd, ssthresh, senders[0].rto, senders[0].bytes_in_flight / BYTES_PER_PACKET ]) if senders[0].srtt: run_dur = senders[0].srtt should_stop = trace.is_finished(net.get_cur_time()) if should_stop: break if f_sim_log: f_sim_log.close() avg_sending_rate = senders[0].avg_sending_rate tput = senders[0].avg_throughput avg_lat = senders[0].avg_latency loss = senders[0].pkt_loss_rate pkt_level_reward = pcc_aurora_reward(tput, avg_lat, loss, avg_bw=trace.avg_bw * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET) pkt_level_original_reward = pcc_aurora_reward(tput, avg_lat, loss) if save_dir: with open( os.path.join(save_dir, "{}_summary.csv".format(self.cc_name)), 'w') as f: summary_writer = csv.writer(f, lineterminator='\n') summary_writer.writerow([ 'trace_average_bandwidth', 'trace_average_latency', 'average_sending_rate', 'average_throughput', 'average_latency', 'loss_rate', 'mi_level_reward', 'pkt_level_reward' ]) summary_writer.writerow([ trace.avg_bw, trace.avg_delay, avg_sending_rate * BYTES_PER_PACKET * BITS_PER_BYTE / 1e6, tput * BYTES_PER_PACKET * BITS_PER_BYTE / 1e6, avg_lat, loss, np.mean(rewards), pkt_level_reward ]) if self.record_pkt_log and save_dir: with open( os.path.join(save_dir, "{}_packet_log.csv".format(self.cc_name)), 'w', 1) as f: pkt_logger = csv.writer(f, lineterminator='\n') pkt_logger.writerow([ 'timestamp', 'packet_event_id', 'event_type', 'bytes', 'cur_latency', 'queue_delay', 'packet_in_queue', 'sending_rate', 'bandwidth' ]) pkt_logger.writerows(net.pkt_log) # with open(os.path.join(save_dir, "{}_log.csv".format(self.cc_name)), 'w', 1) as f: # writer = csv.writer(f, lineterminator='\n') # writer.writerow( # ['timestamp', 'pacing_gain', "pacing_rate", 'cwnd_gain', # 'cwnd', 'target_cwnd', 'prior_cwnd', "btlbw", "rtprop", # "full_bw", 'state', "packets_in_flight", # "in_fast_recovery_mode", 'rs_delivery_rate', 'round_start', # 'round_count', 'rto', 'exit_fast_recovery_ts', # 'pkt_in_queue']) # writer.writerows(senders[0].bbr_log) if plot_flag and save_dir: plot_mi_level_time_series( trace, os.path.join(save_dir, '{}_simulation_log.csv'.format(self.cc_name)), save_dir, self.cc_name) plot(trace, *senders[0].bin_tput, *senders[0].bin_sending_rate, tput * BYTES_PER_PACKET * BITS_PER_BYTE / 1e6, avg_sending_rate * BYTES_PER_PACKET * BITS_PER_BYTE / 1e6, *senders[0].latencies, avg_lat * 1000, loss, pkt_level_original_reward, pkt_level_reward, save_dir, self.cc_name) return np.mean(rewards), pkt_level_reward
def _test(self, trace: Trace, save_dir: str, plot_flag: bool = False, saliency: bool = False): reward_list = [] loss_list = [] tput_list = [] delay_list = [] send_rate_list = [] ts_list = [] action_list = [] mi_list = [] obs_list = [] if save_dir: os.makedirs(save_dir, exist_ok=True) f_sim_log = open(os.path.join(save_dir, 'aurora_simulation_log.csv'), 'w', 1) writer = csv.writer(f_sim_log, lineterminator='\n') writer.writerow(['timestamp', "target_send_rate", "send_rate", 'recv_rate', 'latency', 'loss', 'reward', "action", "bytes_sent", "bytes_acked", "bytes_lost", "MI", "send_start_time", "send_end_time", 'recv_start_time', 'recv_end_time', 'latency_increase', "packet_size", 'min_lat', 'sent_latency_inflation', 'latency_ratio', 'send_ratio', 'bandwidth', "queue_delay", 'packet_in_queue', 'queue_size', "recv_ratio", "srtt"]) else: f_sim_log = None writer = None env = gym.make( 'PccNs-v0', traces=[trace], delta_scale=self.delta_scale, record_pkt_log=self.record_pkt_log) env.seed(self.seed) obs = env.reset() grads = [] # gradients for saliency map while True: if isinstance(self.model, LoadedModel): obs = obs.reshape(1, -1) action = self.model.act(obs) action = action['act'][0] else: if env.net.senders[0].got_data: if saliency: action, _states, grad = self.model.predict( obs, deterministic=True, saliency=saliency) grads.append(grad) else: action, _states = self.model.predict( obs, deterministic=True) else: action = np.array([0]) # get the new MI and stats collected in the MI # sender_mi = env.senders[0].get_run_data() sender_mi = env.senders[0].history.back() #get_run_data() max_recv_rate = env.senders[0].max_tput throughput = sender_mi.get("recv rate") # bits/sec send_rate = sender_mi.get("send rate") # bits/sec latency = sender_mi.get("avg latency") loss = sender_mi.get("loss ratio") avg_queue_delay = sender_mi.get('avg queue delay') sent_latency_inflation = sender_mi.get('sent latency inflation') latency_ratio = sender_mi.get('latency ratio') send_ratio = sender_mi.get('send ratio') recv_ratio = sender_mi.get('recv ratio') reward = pcc_aurora_reward( throughput / BITS_PER_BYTE / BYTES_PER_PACKET, latency, loss, trace.avg_bw * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET, trace.avg_delay * 2/ 1e3) if save_dir and writer: writer.writerow([ env.net.get_cur_time(), round(env.senders[0].rate * BYTES_PER_PACKET * BITS_PER_BYTE, 0), round(send_rate, 0), round(throughput, 0), latency, loss, reward, action.item(), sender_mi.bytes_sent, sender_mi.bytes_acked, sender_mi.bytes_lost, sender_mi.send_end - sender_mi.send_start, sender_mi.send_start, sender_mi.send_end, sender_mi.recv_start, sender_mi.recv_end, sender_mi.get('latency increase'), sender_mi.packet_size, sender_mi.get('conn min latency'), sent_latency_inflation, latency_ratio, send_ratio, env.links[0].get_bandwidth( env.net.get_cur_time()) * BYTES_PER_PACKET * BITS_PER_BYTE, avg_queue_delay, env.links[0].pkt_in_queue, env.links[0].queue_size, recv_ratio, env.senders[0].estRTT]) reward_list.append(reward) loss_list.append(loss) delay_list.append(latency * 1000) tput_list.append(throughput / 1e6) send_rate_list.append(send_rate / 1e6) ts_list.append(env.net.get_cur_time()) action_list.append(action.item()) mi_list.append(sender_mi.send_end - sender_mi.send_start) obs_list.append(obs.tolist()) obs, rewards, dones, info = env.step(action) if dones: break if f_sim_log: f_sim_log.close() if self.record_pkt_log and save_dir: with open(os.path.join(save_dir, "aurora_packet_log.csv"), 'w', 1) as f: pkt_logger = csv.writer(f, lineterminator='\n') pkt_logger.writerow(['timestamp', 'packet_event_id', 'event_type', 'bytes', 'cur_latency', 'queue_delay', 'packet_in_queue', 'sending_rate', 'bandwidth']) pkt_logger.writerows(env.net.pkt_log) assert env.senders[0].last_ack_ts is not None and env.senders[0].first_ack_ts is not None assert env.senders[0].last_sent_ts is not None and env.senders[0].first_sent_ts is not None avg_sending_rate = env.senders[0].tot_sent / (env.senders[0].last_sent_ts - env.senders[0].first_sent_ts) tput = env.senders[0].tot_acked / (env.senders[0].last_ack_ts - env.senders[0].first_ack_ts) avg_lat = env.senders[0].cur_avg_latency loss = 1 - env.senders[0].tot_acked / env.senders[0].tot_sent pkt_level_reward = pcc_aurora_reward(tput, avg_lat,loss, avg_bw=trace.avg_bw * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET) pkt_level_original_reward = pcc_aurora_reward(tput, avg_lat, loss) if self.record_pkt_log and plot_flag: pkt_log = PacketLog.from_log(env.net.pkt_log) plot_pkt_log(trace, pkt_log, save_dir, "aurora") if plot_flag and save_dir: plot_simulation_log(trace, os.path.join(save_dir, 'aurora_simulation_log.csv'), save_dir, self.cc_name) bin_tput_ts, bin_tput = env.senders[0].bin_tput bin_sending_rate_ts, bin_sending_rate = env.senders[0].bin_sending_rate lat_ts, lat = env.senders[0].latencies plot(trace, bin_tput_ts, bin_tput, bin_sending_rate_ts, bin_sending_rate, tput * BYTES_PER_PACKET * BITS_PER_BYTE / 1e6, avg_sending_rate * BYTES_PER_PACKET * BITS_PER_BYTE / 1e6, lat_ts, lat, avg_lat * 1000, loss, pkt_level_original_reward, pkt_level_reward, save_dir, self.cc_name) if save_dir: with open(os.path.join(save_dir, "{}_summary.csv".format(self.cc_name)), 'w', 1) as f: summary_writer = csv.writer(f, lineterminator='\n') summary_writer.writerow([ 'trace_average_bandwidth', 'trace_average_latency', 'average_sending_rate', 'average_throughput', 'average_latency', 'loss_rate', 'mi_level_reward', 'pkt_level_reward']) summary_writer.writerow( [trace.avg_bw, trace.avg_delay, avg_sending_rate * BYTES_PER_PACKET * BITS_PER_BYTE / 1e6, tput * BYTES_PER_PACKET * BITS_PER_BYTE / 1e6, avg_lat, loss, np.mean(reward_list), pkt_level_reward]) if saliency: with open(os.path.join(save_dir, "saliency.npy"), 'wb') as f: np.save(f, np.concatenate(grads)) return ts_list, reward_list, loss_list, tput_list, delay_list, send_rate_list, action_list, obs_list, mi_list, pkt_level_reward
def plot(trace: Union[Trace, None], log_file: str, save_dir: str, cc: str): df = pd.read_csv(log_file) assert isinstance(df, pd.DataFrame) fig, axes = plt.subplots(6, 1, figsize=(12, 10)) axes[0].set_title(cc) axes[0].plot(df['timestamp'], df['recv_rate'] / 1e6, 'o-', ms=2, label='throughput, avg {:.3f}mbps'.format( df['recv_rate'].mean() / 1e6)) axes[0].plot(df['timestamp'], df['send_rate'] / 1e6, 'o-', ms=2, label='send rate, avg {:.3f}mbps'.format( df['send_rate'].mean() / 1e6)) if trace: avg_bw = trace.avg_bw min_rtt = trace.min_delay * 2 / 1e3 axes[0].plot(trace.timestamps, trace.bandwidths, 'o-', ms=2, drawstyle='steps-post', label='bw, avg {:.3f}mbps'.format(avg_bw)) else: axes[0].plot(df['timestamp'], df['bandwidth'] / 1e6, label='bw, avg {:.3f}mbps'.format(df['bandwidth'].mean() / 1e6)) avg_bw = df['bandwidth'].mean() / 1e6 min_rtt = None axes[0].set_xlabel("Time(s)") axes[0].set_ylabel("mbps") axes[0].legend(loc='right') axes[0].set_ylim(0, ) axes[0].set_xlim(0, ) axes[1].plot(df['timestamp'], df['latency'] * 1000, label='RTT avg {:.3f}ms'.format(df['latency'].mean() * 1000)) axes[1].set_xlabel("Time(s)") axes[1].set_ylabel("Latency(ms)") axes[1].legend(loc='right') axes[1].set_xlim(0, ) axes[1].set_ylim(0, ) axes[2].plot(df['timestamp'], df['loss'], label='loss avg {:.3f}'.format(df['loss'].mean())) axes[2].set_xlabel("Time(s)") axes[2].set_ylabel("loss") axes[2].legend() axes[2].set_xlim(0, ) axes[2].set_ylim(0, 1) avg_reward_mi = pcc_aurora_reward( df['recv_rate'].mean() / BITS_PER_BYTE / BYTES_PER_PACKET, df['latency'].mean(), df['loss'].mean(), avg_bw * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET, min_rtt) axes[3].plot(df['timestamp'], df['reward'], label='rewards avg {:.3f}'.format(avg_reward_mi)) axes[3].set_xlabel("Time(s)") axes[3].set_ylabel("Reward") axes[3].legend() axes[3].set_xlim(0, ) # axes[3].set_ylim(, ) axes[4].plot(df['timestamp'], df['action'] * 1.0, label='delta avg {:.3f}'.format(df['action'].mean())) axes[4].set_xlabel("Time(s)") axes[4].set_ylabel("delta") axes[4].legend() axes[4].set_xlim(0, ) axes[5].plot(df['timestamp'], df['packet_in_queue'] / df['queue_size'], label='Queue Occupancy') axes[5].set_xlabel("Time(s)") axes[5].set_ylabel("Queue occupancy") axes[5].legend() axes[5].set_xlim(0, ) axes[5].set_ylim(0, 1) # axes[5].plot(df['timestamp'], df['cwnd'], label='cwnd') # axes[5].plot(df['timestamp'], df['ssthresh'], label='ssthresh') # axes[5].set_xlabel("Time(s)") # axes[5].set_ylabel("# packets") # axes[5].set_ylim(0, df['cwnd'].max()) # axes[5].legend() # axes[5].set_xlim(0, ) plt.tight_layout() if save_dir is not None: fig.savefig(os.path.join(save_dir, "{}_time_series.jpg".format(cc))) plt.close()
def optimal_reward(self): return pcc_aurora_reward( self.avg_bw * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET, self.avg_delay * 2 / 1000, self.loss_rate, self.avg_bw * 1e6 / BITS_PER_BYTE / BYTES_PER_PACKET)