def update_averages(self):
#damage "in" latency: (the time it takes for damage requests to be processed only)
if len(self.damage_in_latency) > 0:
data = [(when, latency)
for when, _, _, latency in list(self.damage_in_latency)]
self.avg_damage_in_latency, self.recent_damage_in_latency = calculate_time_weighted_average(
data)
#damage "out" latency: (the time it takes for damage requests to be processed and sent out)
if len(self.damage_out_latency) > 0:
data = [(when, latency)
for when, _, _, latency in list(self.damage_out_latency)]
self.avg_damage_out_latency, self.recent_damage_out_latency = calculate_time_weighted_average(
data)
#client decode speed:
if len(self.client_decode_time) > 0:
#the elapsed time recorded is in microseconds, so multiply by 1000*1000 to get the real value:
self.avg_decode_speed, self.recent_decode_speed = calculate_timesize_weighted_average(
list(self.client_decode_time), sizeunit=1000 * 1000)
#network send speed:
if len(self.damage_send_speed) > 0:
self.avg_send_speed, self.recent_send_speed = calculate_timesize_weighted_average(
list(self.damage_send_speed))
all_l = [
0.1, self.avg_damage_in_latency, self.recent_damage_in_latency,
self.avg_damage_out_latency, self.recent_damage_out_latency
]
self.max_latency = max(all_l)
def update_averages(self):
#damage "in" latency: (the time it takes for damage requests to be processed only)
dil = tuple(self.damage_in_latency)
if dil:
data = tuple((when, latency) for when, _, _, latency in dil)
self.avg_damage_in_latency, self.recent_damage_in_latency = calculate_time_weighted_average(
data)
#damage "out" latency: (the time it takes for damage requests to be processed and sent out)
dol = tuple(self.damage_out_latency)
if dol:
data = tuple((when, latency) for when, _, _, latency in dol)
self.avg_damage_out_latency, self.recent_damage_out_latency = calculate_time_weighted_average(
data)
#client decode speed:
cdt = tuple(self.client_decode_time)
if cdt:
#the elapsed time recorded is in microseconds:
decode_speed = tuple(
(event_time, size, int(size * 1000 * 1000 / elapsed))
for event_time, size, elapsed in cdt)
r = calculate_size_weighted_average(decode_speed)
self.avg_decode_speed = int(r[0])
self.recent_decode_speed = int(r[1])
#network send speed:
all_l = [
0.1, self.avg_damage_in_latency, self.recent_damage_in_latency,
self.avg_damage_out_latency, self.recent_damage_out_latency
]
self.max_latency = max(all_l)
def update_averages(self):
if len(self.client_latency)>0:
data = [(when, latency) for _, when, _, latency in list(self.client_latency)]
self.min_client_latency = min([x for _,x in data])
self.avg_client_latency, self.recent_client_latency = calculate_time_weighted_average(data)
#client ping latency: from ping packets
if len(self.client_ping_latency)>0:
data = list(self.client_ping_latency)
self.min_client_ping_latency = min([x for _,x in data])
self.avg_client_ping_latency, self.recent_client_ping_latency = calculate_time_weighted_average(data)
#server ping latency: from ping packets
if len(self.server_ping_latency)>0:
data = list(self.server_ping_latency)
self.min_server_ping_latency = min([x for _,x in data])
self.avg_server_ping_latency, self.recent_server_ping_latency = calculate_time_weighted_average(data)
def update_averages(self):
if len(self.client_latency) > 0:
data = [(when, latency)
for _, when, _, latency in tuple(self.client_latency)]
self.min_client_latency = min([x for _, x in data])
self.avg_client_latency, self.recent_client_latency = calculate_time_weighted_average(
data)
#client ping latency: from ping packets
if len(self.client_ping_latency) > 0:
data = tuple(self.client_ping_latency)
self.min_client_ping_latency = min([x for _, x in data])
self.avg_client_ping_latency, self.recent_client_ping_latency = calculate_time_weighted_average(
data)
#server ping latency: from ping packets
if len(self.server_ping_latency) > 0:
data = tuple(self.server_ping_latency)
self.min_server_ping_latency = min([x for _, x in data])
self.avg_server_ping_latency, self.recent_server_ping_latency = calculate_time_weighted_average(
data)
#set to 0 if we have less than 2 events in the last 60 seconds:
now = monotonic_time()
min_time = now - 60
css = tuple(x for x in self.congestion_send_speed if x[0] > min_time)
acss = 0
if len(css) >= 2:
#weighted average of the send speed over the last minute:
acss = int(calculate_size_weighted_average(css)[0])
latest_ctime = self.congestion_send_speed[-1][0]
elapsed = now - latest_ctime
#require at least one recent event:
if elapsed < 30:
#as the last event recedes in the past, increase limit:
acss *= 1 + elapsed
self.avg_congestion_send_speed = int(acss)
#how often we get congestion events:
#first chunk it into second intervals
min_time = now - 10
cst = tuple(x[0] for x in css)
cps = []
for t in range(10):
etime = now - t
matches = tuple(
1 for x in cst if x > etime - 1 and x <= etime) or (0, )
cps.append((etime, sum(matches)))
#log("cps(%s)=%s (now=%s)", cst, cps, now)
self.congestion_value = time_weighted_average(cps)
def update_averages(self):
if len(self.client_latency) > 0:
data = [(when, latency)
for _, when, _, latency in list(self.client_latency)]
self.min_client_latency = min([x for _, x in data])
self.avg_client_latency, self.recent_client_latency = calculate_time_weighted_average(
data)
#client ping latency: from ping packets
if len(self.client_ping_latency) > 0:
data = list(self.client_ping_latency)
self.min_client_ping_latency = min([x for _, x in data])
self.avg_client_ping_latency, self.recent_client_ping_latency = calculate_time_weighted_average(
data)
#server ping latency: from ping packets
if len(self.server_ping_latency) > 0:
data = list(self.server_ping_latency)
self.min_server_ping_latency = min([x for _, x in data])
self.avg_server_ping_latency, self.recent_server_ping_latency = calculate_time_weighted_average(
data)
def test_calculate_time_weighted_average(self): now = time.time() sample_size = 100 data = [] t = now - sample_size for _ in range(sample_size): v = random.random() data.append((t, v)) t += 1 a, ra = cystats.calculate_time_weighted_average(data) assert 0<a<1 and 0<ra<1
def update_averages(self):
#damage "in" latency: (the time it takes for damage requests to be processed only)
if len(self.damage_in_latency)>0:
data = [(when, latency) for when, _, _, latency in list(self.damage_in_latency)]
self.avg_damage_in_latency, self.recent_damage_in_latency = calculate_time_weighted_average(data)
#damage "out" latency: (the time it takes for damage requests to be processed and sent out)
if len(self.damage_out_latency)>0:
data = [(when, latency) for when, _, _, latency in list(self.damage_out_latency)]
self.avg_damage_out_latency, self.recent_damage_out_latency = calculate_time_weighted_average(data)
#client decode speed:
if len(self.client_decode_time)>0:
#the elapsed time recorded is in microseconds, so multiply by 1000*1000 to get the real value:
self.avg_decode_speed, self.recent_decode_speed = calculate_timesize_weighted_average(list(self.client_decode_time), sizeunit=1000*1000)
#network send speed:
if len(self.damage_send_speed)>0:
self.avg_send_speed, self.recent_send_speed = calculate_timesize_weighted_average(list(self.damage_send_speed))
all_l = [0.1,
self.avg_damage_in_latency, self.recent_damage_in_latency,
self.avg_damage_out_latency, self.recent_damage_out_latency]
self.max_latency = max(all_l)
def update_averages(self):
if len(self.client_latency) > 0:
data = [(when, latency)
for _, when, _, latency in tuple(self.client_latency)]
self.min_client_latency = min([x for _, x in data])
self.avg_client_latency, self.recent_client_latency = calculate_time_weighted_average(
data)
#client ping latency: from ping packets
if len(self.client_ping_latency) > 0:
data = tuple(self.client_ping_latency)
self.min_client_ping_latency = min([x for _, x in data])
self.avg_client_ping_latency, self.recent_client_ping_latency = calculate_time_weighted_average(
data)
#server ping latency: from ping packets
if len(self.server_ping_latency) > 0:
data = tuple(self.server_ping_latency)
self.min_server_ping_latency = min([x for _, x in data])
self.avg_server_ping_latency, self.recent_server_ping_latency = calculate_time_weighted_average(
data)
#set to 0 if we have less than 2 events in the last 60 seconds:
min_time = monotonic_time() - 60
css = tuple(x for x in self.congestion_send_speed if x[0] > min_time)
if len(css) <= 2:
self.avg_congestion_send_speed = 0
else:
self.avg_congestion_send_speed = int(
calculate_size_weighted_average(
tuple(self.congestion_send_speed))[0])
#how often we get congestion events:
#first chunk it into second intervals
now = monotonic_time()
min_time = now - 10
cst = tuple(x[0] for x in css)
cps = []
for t in range(10):
etime = now - t
cps.append(
(etime, sum(1 for x in cst if x > etime - 1 and x <= etime)))
#log("cps(%s)=%s (now=%s)", cst, cps, now)
self.congestion_value = time_weighted_average(cps)
def latency_averages(values):
avg, recent = calculate_time_weighted_average(values)
return max(0.001, avg), max(0.001, recent)
