def get_run_data(self):
obs_end_time = self.net.get_cur_time()
#obs_dur = obs_end_time - self.obs_start_time
# print("Got %d acks in %f seconds" % (self.acked, obs_dur))
# print("Sent %d packets in %f seconds" % (self.sent, obs_dur))
# print("self.rate = %f" % self.rate)
# print(self.acked, self.sent)
# print(self.rtt_samples)
if self.got_data:
return sender_obs.SenderMonitorInterval(
self.id,
bytes_sent=self.sent * BYTES_PER_PACKET,
bytes_acked=self.acked * BYTES_PER_PACKET,
bytes_lost=self.lost * BYTES_PER_PACKET,
# send_start=self.first_pkt_send_time,
# send_end=self.last_pkt_send_time,
# recv_start=self.first_pkt_ack_time,
# recv_end=self.last_pkt_ack_time,
send_start=self.obs_start_time,
send_end=obs_end_time,
recv_start=self.obs_start_time,
recv_end=obs_end_time,
rtt_samples=self.rtt_samples,
packet_size=BYTES_PER_PACKET
)
else:
global start_int_id
start_int_id += 1
print([self.net.links[0].dl * 2 - 0.0001 * start_int_id])
return sender_obs.SenderMonitorInterval(
self.id,
bytes_sent=self.sent * BYTES_PER_PACKET,
bytes_acked=self.sent * BYTES_PER_PACKET,
bytes_lost=0 * BYTES_PER_PACKET,
send_start=self.obs_start_time,
send_end=obs_end_time,
recv_start=self.obs_start_time,
recv_end=obs_end_time,
rtt_samples=[self.net.links[0].dl * 2- 0.0003 * i for i in range(5)],
packet_size=BYTES_PER_PACKET
)
def give_sample(self, bytes_sent, bytes_acked, bytes_lost, send_start_time,
send_end_time, recv_start_time, recv_end_time, rtt_samples,
packet_size, utility):
self.record_observation(
sender_obs.SenderMonitorInterval(self.id,
bytes_sent=bytes_sent,
bytes_acked=bytes_acked,
bytes_lost=bytes_lost,
send_start=send_start_time,
send_end=send_end_time,
recv_start=recv_start_time,
recv_end=recv_end_time,
rtt_samples=rtt_samples,
packet_size=packet_size))
def get_run_data(self):
assert self.net
obs_end_time = self.net.get_cur_time()
#obs_dur = obs_end_time - self.obs_start_time
#print("Got %d acks in %f seconds" % (self.acked, obs_dur))
#print("Sent %d packets in %f seconds" % (self.sent, obs_dur))
#print("self.rate = %f" % self.rate)
# print(self.acked, self.sent)
if not self.rtt_samples and self.prev_rtt_samples:
rtt_samples = [np.mean(np.array(self.prev_rtt_samples))]
else:
rtt_samples = self.rtt_samples
# if not self.rtt_samples:
# print(self.obs_start_time, obs_end_time, self.rate)
# rtt_samples is empty when there is no packet acked in MI
# Solution: inherit from previous rtt_samples.
# recv_start = self.rtt_samples_ts[0] if len(
# self.rtt_samples) >= 2 else self.obs_start_time
recv_start = self.history.back().recv_end if len(
self.rtt_samples) >= 1 else self.obs_start_time
recv_end = self.rtt_samples_ts[-1] if len(
self.rtt_samples) >= 1 else obs_end_time
bytes_acked = self.acked * BYTES_PER_PACKET
if recv_start == 0:
recv_start = self.rtt_samples_ts[0]
bytes_acked = (self.acked - 1) * BYTES_PER_PACKET
# bytes_acked = max(0, (self.acked-1)) * BYTES_PER_PACKET if len(
# self.rtt_samples) >= 2 else self.acked * BYTES_PER_PACKET
return sender_obs.SenderMonitorInterval(
self.id,
bytes_sent=self.sent * BYTES_PER_PACKET,
# max(0, (self.acked-1)) * BYTES_PER_PACKET,
# bytes_acked=self.acked * BYTES_PER_PACKET,
bytes_acked=bytes_acked,
bytes_lost=self.lost * BYTES_PER_PACKET,
send_start=self.obs_start_time,
send_end=obs_end_time,
# recv_start=self.obs_start_time,
# recv_end=obs_end_time,
recv_start=recv_start,
recv_end=recv_end,
rtt_samples=rtt_samples,
queue_delay_samples=self.queue_delay_samples,
packet_size=BYTES_PER_PACKET
)
def give_sample(self, bytes_sent, bytes_acked, bytes_lost, send_start_time,
send_end_time, recv_start_time, recv_end_time, rtt_samples,
packet_size, utility):
self.record_observation(
sender_obs.SenderMonitorInterval(
self.id,
bytes_sent=bytes_sent,
bytes_acked=bytes_acked,
bytes_lost=bytes_lost,
send_start=send_start_time,
send_end=send_end_time,
recv_start=recv_start_time,
recv_end=recv_end_time,
rtt_samples=rtt_samples,
packet_size=packet_size, #sender_obs.MAXIMUM_SEGMENT_SIZE,
))
self.mi_pushed = True
def get_run_data(self):
obs_end_time = self.net.get_cur_time()
# obs_dur = obs_end_time - self.obs_start_time
# print("Got %d acks in %f seconds" % (self.acked, obs_dur))
# print("Sent %d packets in %f seconds" % (self.sent, obs_dur))
# print("self.rate = %f" % self.rate)
return sender_obs.SenderMonitorInterval(
self.id,
bytes_sent=self.sent * BYTES_PER_PACKET,
bytes_acked=self.acked * BYTES_PER_PACKET,
bytes_lost=self.lost * BYTES_PER_PACKET,
send_start=self.obs_start_time,
send_end=obs_end_time,
recv_start=self.obs_start_time,
recv_end=obs_end_time,
rtt_samples=self.rtt_samples,
packet_size=BYTES_PER_PACKET)
def get_run_data(self):
obs_end_time = self.get_cur_time()
if not self.rtt_samples and self.prev_rtt_samples:
rtt_samples = [np.mean(self.prev_rtt_samples)]
else:
rtt_samples = self.rtt_samples
# rtt_samples is empty when there is no packet acked in MI
# Solution: inherit from previous rtt_samples.
# recv_start = self.rtt_samples_ts[0] if len(
# self.rtt_samples) >= 2 else self.obs_start_time
recv_start = self.history.back().recv_end if len(
self.rtt_samples) >= 1 else self.obs_start_time
recv_end = self.rtt_samples_ts[-1] if len(
self.rtt_samples) >= 1 else obs_end_time
bytes_acked = self.acked * BYTES_PER_PACKET
if recv_start == 0:
recv_start = self.rtt_samples_ts[0]
bytes_acked = (self.acked - 1) * BYTES_PER_PACKET
# bytes_acked = max(0, (self.acked-1)) * BYTES_PER_PACKET if len(
# self.rtt_samples) >= 2 else self.acked * BYTES_PER_PACKET
return sender_obs.SenderMonitorInterval(
self.sender_id,
bytes_sent=self.sent * BYTES_PER_PACKET,
# max(0, (self.acked-1)) * BYTES_PER_PACKET,
# bytes_acked=self.acked * BYTES_PER_PACKET,
bytes_acked=bytes_acked,
bytes_lost=self.lost * BYTES_PER_PACKET,
send_start=self.obs_start_time,
send_end=obs_end_time,
# recv_start=self.obs_start_time,
# recv_end=obs_end_time,
recv_start=recv_start,
recv_end=recv_end,
rtt_samples=rtt_samples,
queue_delay_samples=self.queue_delay_samples,
packet_size=BYTES_PER_PACKET
)
def step(self, action):
if self.conn is None:
print("Listening for connection from network sender")
self.sock.listen()
self.conn, self.addr = self.sock.accept()
self.apply_action(action[0])
self.conn.send(str(self.rate).encode())
data = self.conn.recv(1024).decode()
data = data.split("\n")[-2]
vals = data.split(";")
flow_id = int(vals[0])
bytes_sent = int(vals[1])
bytes_acked = int(vals[2])
bytes_lost = int(vals[3])
send_start_time = float(vals[4])
send_end_time = float(vals[5])
recv_start_time = float(vals[6])
recv_end_time = float(vals[7])
rtt_samples = [float(rtt) for rtt in ast.literal_eval(vals[8])]
packet_size = int(vals[9])
rew = float(vals[10])
self.history.step(
sender_obs.SenderMonitorInterval(flow_id,
bytes_sent=bytes_sent,
bytes_acked=bytes_acked,
bytes_lost=bytes_lost,
send_start=send_start_time,
send_end=send_end_time,
recv_start=recv_start_time,
recv_end=recv_end_time,
rtt_samples=rtt_samples,
packet_size=packet_size))
self.reward_sum += rew
self.steps_taken += 1
done = (self.steps_taken > RESET_INTERVAL)
return self.history.as_array(), rew, done, {}
