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)