def update_averages(self):
def latency_averages(values):
avg, recent = calculate_time_weighted_average(values)
return max(0.001, avg), max(0.001, recent)
client_latency = tuple(self.client_latency)
if client_latency:
data = tuple((when, latency) for _, when, _, latency in client_latency)
self.min_client_latency = min(x for _,x in data)
self.avg_client_latency, self.recent_client_latency = latency_averages(data)
#client ping latency: from ping packets
client_ping_latency = tuple(self.client_ping_latency)
if client_ping_latency:
self.min_client_ping_latency = min(x for _,x in client_ping_latency)
self.avg_client_ping_latency, self.recent_client_ping_latency = latency_averages(client_ping_latency)
#server ping latency: from ping packets
server_ping_latency = tuple(self.server_ping_latency)
if server_ping_latency:
self.min_server_ping_latency = min(x for _,x in server_ping_latency)
self.avg_server_ping_latency, self.recent_server_ping_latency = latency_averages(server_ping_latency)
#set to 0 if we have less than 2 events in the last 60 seconds:
now = monotonic()
min_time = now-60
css = tuple(x for x in tuple(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 = safeint(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)
ftl = tuple(self.frame_total_latency)
if ftl:
edata = tuple((event_time, pixels, latency) for _, event_time, pixels, latency in ftl)
#(wid, event_time, no_of_pixels, latency)
self.avg_frame_total_latency = safeint(calculate_size_weighted_average(edata)[1])
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 t(v, ea, era):
a, ra = cystats.calculate_size_weighted_average(v)
self.assertEqual(
round(a), round(ea),
"average should be %s, got %s" % (round(ea), round(a)))
self.assertEqual(
round(ra), round(era), "recent average should be %s, got %s" %
(round(era), round(ra)))
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 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 test_calculate_timesize_weighted_average(self):
#event_time, size, elapsed_time
now = monotonic()
sample_size = 1000
data = []
ts = now - sample_size
for _ in range(sample_size):
s = random.randint(1000, 10000)
v = random.random()
data.append((ts, s, v))
ts += 1
a, ra = cystats.calculate_timesize_weighted_average(data)
assert a > 0 and ra > 0
#the calculations use the ratio of the size divided by the elapsed time,
#so check that a predictable ratio gives the expected value:
for x in (5, 1000):
v = [(now, i * x, x) for i in range(1, 1000)]
a, ra = cystats.calculate_size_weighted_average(v)
#but we need to round to an int to compare
self.assertEqual(x, iround(a),
"average should be %i, got %i" % (x, a))
self.assertEqual(x, iround(ra),
"recent average should be %i, got %i" % (x, ra))
def t(v, ea, era):
a, ra = cystats.calculate_size_weighted_average(v)
self.assertEqual(
iround(a), iround(ea),
"average should be %s, got %s" % (iround(ea), iround(a)))
self.assertEqual(
iround(ra), iround(era),
"recent average should be %s, got %s" %
(iround(era), iround(ra)))
#an old record won't make any difference
#compared with one that was taken just now:
for v in (1, 10, 1000):
#1 day ago:
if now > 60 * 60 * 24:
t([(now - 60 * 60 * 24, 1000, 1000), (now, 1000, v)], v, v)
t([(now - 60 * 60 * 24, 2 * 1000, 1000), (now, 1000, v)], v, v)
#1 hour ago:
if now > 60 * 60:
t([(now - 60 * 60, 1000, 10), (now, 1000, v)], v, v)
#but 100s ago starts to make a difference:
t([(now - 100, 1000, 1), (now, 1000, 100)], 99, 100)
#with only 10s:
t([(now - 10, 1000, 1), (now, 1000, 100)], 92, 100)
#1 second:
t([(now - 1, 1000, 1), (now, 1000, 100)], 67, 92)
#if using the same time, then size matters more:
v = [(now, 100 * 1000, 1000), (now, 50 * 1000, 1000)]
a, ra = cystats.calculate_size_weighted_average(v)
#recent is the same as "normal" average:
self.assertEqual(iround(a), iround(ra))
self.assertGreater(a, 75)
#real data:
T = monotonic()
v = [(T - 21.557095, 157684, 9110), (T - 22.23345, 3744, 1279),
(T - 22.376621, 3744, 706), (T - 22.515456, 3744, 1302),
(T - 23.013887, 78, 1342), (T - 43.707768, 78, 920),
(T - 44.043399, 78, 1558), (T - 44.046686, 78, 1119),
(T - 44.048169, 78, 1007), (T - 44.049807, 1716, 626),
(T - 44.053967, 78, 2841), (T - 44.23714, 78, 1393),
(T - 44.238555, 78, 2903), (T - 44.242623, 78, 1167),
(T - 44.244426, 1716, 1032), (T - 44.245675, 78, 720),
(T - 44.392009, 78, 784), (T - 44.392771, 78, 737),
(T - 44.396293, 78, 911), (T - 44.397466, 1716, 772),
(T - 44.398027, 78, 1234), (T - 44.538323, 78, 1200),
(T - 44.539683, 78, 586), (T - 44.542575, 78, 1203),
(T - 44.544646, 1716, 1129), (T - 44.546205, 78, 979),
(T - 44.701881, 78, 901), (T - 44.703987, 78, 448),
(T - 44.708965, 78, 474), (T - 44.711481, 1716, 1444),
(T - 44.713157, 78, 1033), (T - 44.848487, 78, 860),
(T - 44.850604, 78, 1172), (T - 44.857039, 78, 1367),
(T - 44.858723, 1716, 1078), (T - 44.859743, 78, 1876),
(T - 44.993883, 78, 824), (T - 44.99714, 78, 796),
(T - 45.001942, 78, 714), (T - 45.002884, 1716, 744),
(T - 45.004841, 78, 652), (T - 45.772856, 78, 652)]
raw_v = [x[2] for x in v]
min_v = min(raw_v)
max_v = max(raw_v)
a, ra = cystats.calculate_size_weighted_average(v)
self.assertLess(a, max_v)
self.assertLess(ra, max_v)
self.assertGreater(a, min_v)
self.assertGreater(ra, min_v)
