Define a cache context that allows to temporarily add global tags

python/dune/perftool/generation/__init__.py

 from __future__ import absolute_import
 
-from dune.perftool.generation.cache import (generator_factory,
+from dune.perftool.generation.cache import (cache_context,
+                                            generator_factory,
                                             retrieve_cache_items,
                                             delete_cache_items,
                                             )

python/dune/perftool/generation/cache.py

@@ -7,9 +7,35 @@ a complex requirement structure. This includes:
 from __future__ import absolute_import
 from pytools import memoize
 
+
 # have one cache the module level. It is easier than handing around an instance of it.
 _cache = {}
 
+# Implement a context manager that allows to temporarily define tags globally.
+_cache_context_stack = []
+
+
+class _CacheContext(object):
+    def __init__(self, tags):
+        self.tags = tags
+
+    def __enter__(self):
+        _cache_context_stack.append(self.tags)
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        _cache_context_stack.pop()
+
+
+def cache_context(*tags):
+    return _CacheContext(tags)
+
+
+def _get_context_tags():
+    result = tuple()
+    for items in _cache_context_stack:
+        result = result + items
+    return result
+
 
 def _freeze(data):
     """ A function that deterministically generates an
@@ -105,6 +131,13 @@ class _RegisteredFunction(object):
                  ):
         self.func = func
         self.cache_key_generator = cache_key_generator
+
+        # Append the current context item tags to the given ones
+        if 'item_tags' in kwargs:
+            kwargs['item_tags'] = tuple(kwargs['item_tags']) + _get_context_tags()
+        else:
+            kwargs['item_tags'] = _get_context_tags()
+
         self.itemtype = _construct_cache_item_type("CacheItemType", **kwargs)
 
     def __call__(self, *args, **kwargs):