def run(self):
self.capture_filename = self.get_capture()
self.check(os.path.exists(self.capture_filename), "Didn't generate capture in make_capture")
rdtest.log.print("Loading capture")
memory_before: int = rd.GetCurrentProcessMemoryUsage()
start_time = time.time()
self.controller = rdtest.open_capture(self.capture_filename, opts=self.get_replay_options())
duration = time.time() - start_time
memory_after: int = rd.GetCurrentProcessMemoryUsage()
memory_increase = memory_after - memory_before
rdtest.log.print("Loaded capture in {:02} seconds, consuming {} bytes of memory".format(duration, memory_increase))
if memory_increase > 1200*1000*1000:
raise rdtest.TestFailureException("Memory usage is too high".format(duration))
else:
rdtest.log.success("Memory usage is OK")
if rd.IsReleaseBuild():
if duration >= 2.5:
raise rdtest.TestFailureException("Time to load is too high")
rdtest.log.success("Time to load is OK")
else:
rdtest.log.print("Not checking time to load in non-release build")
if self.controller is not None:
self.controller.Shutdown()
def check_capture(self):
memory: int = rd.GetCurrentProcessMemoryUsage()
if memory > 500 * 1000 * 1000:
raise rdtest.TestFailureException(
"Memory usage of {} is too high".format(memory))
rdtest.log.success(
"Capture {} opened with reasonable memory ({})".format(
self.demos_frame_cap, memory))
def repeat_load(self, path):
memory_peak = memory_baseline = 0
for i in range(20):
rdtest.log.print("Loading for iteration {}".format(i))
try:
controller = rdtest.open_capture(path)
except RuntimeError as err:
rdtest.log.print("Skipping. Can't open {}: {}".format(
path, err))
return
# Do nothing, just ensure it's loaded
memory_usage: int = rd.GetCurrentProcessMemoryUsage()
# We measure the baseline memory usage during the second peak to avoid any persistent caches etc that might
# not be full
if i == 1:
memory_baseline = memory_usage
memory_peak = max(memory_peak, memory_usage)
controller.Shutdown()
pct_over = 'N/A'
if memory_baseline > 0:
pct_over = '{:.2f}%'.format(
(memory_usage / memory_baseline) * 100)
rdtest.log.success(
"Succeeded iteration {}, memory usage was {} ({} of baseline)".
format(i, memory_usage, pct_over))
pct_over = '{:.2f}%'.format((memory_peak / memory_baseline) * 100)
msg = 'peak memory usage was {}, {} compared to baseline {}'.format(
memory_peak, pct_over, memory_baseline)
if memory_baseline * 1.25 < memory_peak:
raise rdtest.TestFailureException(msg)
else:
rdtest.log.success(msg)