Allow run-time control of 3D model cache

Author: jonathanhogg

docs/install.md

@@ -197,6 +197,12 @@ code and so it may be useful if very fast switching is required – particularly
 if a program has very large loops that are being unrolled and there is
 insufficient gain from doing the unrolling.
 
+`--modelcache`
+: How long to cache unused 3D models for, in seconds (may be specified as a
+[time-code](language.md#time-codes)). Set this to `0` to disable clearing of the
+model cache completely – this may be a useful performance tweak for long-running
+programs that reference a fixed number of models.
+
 `--lockstep`
 : Turns on *non-realtime mode*. In this mode, the engine will generate frames
 as fast as possible (which may be quite slowly) while maintaining an evenly

src/flitter/engine/__main__.py

@@ -51,6 +51,7 @@ def main():
     parser.add_argument('--define', '-D', action='append', default=[], type=keyvalue, dest='defines', help="Define name for evaluation")
     parser.add_argument('--vmstats', action='store_true', default=False, help="Report VM statistics")
     parser.add_argument('--runtime', type=convert_timecode_to_float, help="Seconds to run for before exiting")
+    parser.add_argument('--modelcache', type=convert_timecode_to_float, default=300, help="Seconds to cache models for")
     parser.add_argument('--offscreen', action='store_true', default=False, help="Swap windows for offscreens")
     parser.add_argument('--opengles', action='store_true', default=False, help="Use OpenGL ES")
     parser.add_argument('program', nargs='+', help="Program(s) to load")
@@ -67,7 +68,7 @@ def main():
                                   state_file=args.state, reset_on_switch=args.resetonswitch, state_simplify_wait=args.simplifystate,
                                   realtime=not args.lockstep, defined_names=dict(args.defines), vm_stats=args.vmstats,
                                   run_time=args.runtime, offscreen=args.offscreen, disable_simplifier=args.nosimplify,
-                                  opengl_es=args.opengles)
+                                  opengl_es=args.opengles, model_cache_time=args.modelcache)
     for program in args.program:
         controller.load_page(program)
 

src/flitter/engine/control.py

@@ -25,7 +25,7 @@ class EngineController:
 
     def __init__(self, target_fps=60, screen=0, fullscreen=False, vsync=False, state_file=None,
                  reset_on_switch=False, state_simplify_wait=0, realtime=True, defined_names=None, vm_stats=False,
-                 run_time=None, offscreen=False, disable_simplifier=False, opengl_es=False):
+                 run_time=None, offscreen=False, disable_simplifier=False, opengl_es=False, model_cache_time=300):
         self.default_fps = target_fps
         self.target_fps = target_fps
         self.realtime = realtime
@@ -34,6 +34,7 @@ def __init__(self, target_fps=60, screen=0, fullscreen=False, vsync=False, state
         self.vsync = vsync
         self.offscreen = offscreen
         self.opengl_es = opengl_es
+        self.model_cache_time = model_cache_time
         self.reset_on_switch = reset_on_switch
         self.disable_simplifier = disable_simplifier
         self.state_simplify_wait = 0 if self.disable_simplifier else state_simplify_wait / 2
@@ -295,7 +296,8 @@ async def run(self):
 
                 del context
                 SharedCache.clean()
-                gc_pending |= Model.flush_caches()
+                if self.model_cache_time > 0:
+                    gc_pending |= Model.flush_caches(max_age=self.model_cache_time)
                 if gc_pending and (last_gc is None or now > last_gc + self.MINIMUM_GC_INTERVAL):
                     count = gc.collect(2)
                     gc_pending = False
@@ -336,21 +338,25 @@ async def run(self):
                     logger.trace("State dictionary size: {} keys", len(self.state))
                     if run_program is not None and run_program.stack is not None:
                         logger.trace("VM stack size: {:d}", run_program.stack.size)
+                    count = Model.cache_size()
+                    if count:
+                        logger.trace("Model cache size: {}", count)
 
         finally:
             self.global_state = {}
             self._references = {}
             self.pages = []
             program = run_program = current_program = context = None
-            Model.flush_caches(0, 0)
+            Model.flush_caches(max_size=0)
             SharedCache.clean(0)
             for renderers in self.renderers.values():
                 while renderers:
                     await renderers.pop().destroy()
             if self.vm_stats:
                 log_vm_stats()
             count = gc.collect(2)
-            logger.trace("Collected {} objects (full collection)", count)
+            if count:
+                logger.trace("Collected {} objects (full collection)", count)
             counts = numbers_cache_counts()
             if counts:
                 logger.debug("Numbers cache: {}", ", ".join(f"{size}x{count}" for size, count in counts.items()))

src/flitter/render/window/models.pyx

@@ -108,11 +108,15 @@ cpdef void fill_in_normals(vertices_array, faces_array):
 
 cdef class Model:
     @staticmethod
-    def flush_caches(double max_age=300, int64_t max_size=2500):
+    def cache_size():
+        return len(ModelCache)
+
+    @staticmethod
+    def flush_caches(double max_age=0, int64_t max_size=-1):
         cdef double now = perf_counter()
         cdef double cutoff = now - max_age
         cdef Model model
-        cdef int64_t count=len(ModelCache), unload_count=0
+        cdef int64_t count=len(ModelCache), unload_count=0, runs=0
         cdef list unloaded = []
         cdef bint aggressive=False, full_collect=False
         while True:
@@ -128,11 +132,12 @@ cdef class Model:
                         full_collect |= model.uncache(True)
                 else:
                     full_collect |= model.uncache(False)
-                if (model.touch_timestamp <= cutoff or aggressive and model.touch_timestamp < now and count > max_size) and model.dependents is None:
+                if (cutoff > 0 and model.touch_timestamp <= cutoff or aggressive and count > max_size) and model.dependents is None:
                     unloaded.append(model)
                     count -= 1
+            runs += 1
             if not unloaded:
-                if count > max_size and not aggressive:
+                if max_size >= 0 and count > max_size and not aggressive:
                     aggressive = True
                 else:
                     break
@@ -143,7 +148,10 @@ cdef class Model:
                 del ModelCache[model.id]
                 unload_count += 1
         if unload_count:
-            logger.trace("Unloaded {} models from cache, {} remaining", unload_count, count)
+            if count:
+                logger.trace("Unloaded {} models from cache in {} run(s), {} remaining", unload_count, runs, count)
+            else:
+                logger.trace("Emptied {} models from cache in {} run(s)", unload_count, runs)
         return full_collect
 
     @staticmethod