python.AccumulatorCache.AccumulatorDecorator Class Reference

Collaboration diagram for python.AccumulatorCache.AccumulatorDecorator:

Classes
class	CacheStats

Public Member Functions
def	__init__ (self, func, size, verify, deepCopy)
def	getInfo (self)
def	printStats (cls)
def	suspendCaching (cls)
def	resumeCaching (cls)
def	clearCache (cls)
def	__get__ (self, obj, objtype)
def	__call__ (self, *args, **kwargs)
def	__del__ (self)

Static Public Attributes
int	VERIFY_NOTHING = 0
int	VERIFY_HASH = 1

Private Member Functions
def	_getHash (x)
def	_evict (x)
def	_evictAll (self)
def	_callImpl (self, *args, **kwargs)

Private Attributes
	_maxSize
	_func
	_cache
	_resultCache
	_verify
	_deepcopy
	_memoize

Static Private Attributes
bool	_memoize = True
	_stats

Detailed Description

Class for use in function decorators, implements memoization.

Instances are callable objects that use the
hash value calculated from positional and keyword arguments
to implement memoization. Methods for suspending and 
resuming memoization are provided.

Definition at line 38 of file AccumulatorCache.py.

Constructor & Destructor Documentation

__init__()

def python.AccumulatorCache.AccumulatorDecorator.__init__	(		self,
			func,
			size,
			verify,
			deepCopy
	)

See AccumulatorCache decorator for documentation of arguments.

Definition at line 61 of file AccumulatorCache.py.

    def __init__(self, func, size, verify, deepCopy):
        """See AccumulatorCache decorator for documentation of arguments."""
 
        functools.update_wrapper(self , func)
        self._maxSize = size
        self._func = func
        self._cache = {}
        self._resultCache = {}
        self._verify = verify
        self._deepcopy = deepCopy
 
        if self._verify not in [self.VERIFY_NOTHING, self.VERIFY_HASH]:
            raise RuntimeError(f"Invalid value for verify ({verify}) in AccumulatorCache for {func}")
 

__del__()

def python.AccumulatorCache.AccumulatorDecorator.__del__

(

self

)

Definition at line 224 of file AccumulatorCache.py.

    def __del__(self):
        self._evictAll()
 
 

Member Function Documentation

__call__()

def python.AccumulatorCache.AccumulatorDecorator.__call__	(		self,
		*	args,
		**	kwargs
	)

Definition at line 144 of file AccumulatorCache.py.

    def __call__(self, *args, **kwargs):
        cacheHit = None
        try:
            t0 = time.perf_counter()
            res, cacheHit = self._callImpl(*args, **kwargs)
            return res
        except NotHashable as e:
            _msg.warning(f"Argument value '{repr(e.value)}' in {self._func} is not hashable. "
                         "No caching is performed!")
            cacheHit = False
            return self._func(*args, **kwargs)  # perform regular function call
        finally:
            t1 = time.perf_counter()
            if cacheHit is True:
                self._stats[self].hits += 1
                self._stats[self].t_hits += (t1-t0)
            elif cacheHit is False:
                self._stats[self].misses += 1
                self._stats[self].t_misses += (t1-t0)
 

__get__()

def python.AccumulatorCache.AccumulatorDecorator.__get__	(		self,
			obj,
			objtype
	)

Support instance methods.

Definition at line 140 of file AccumulatorCache.py.

    def __get__(self, obj, objtype):
        """Support instance methods."""
        return functools.partial(self.__call__, obj)
 

_callImpl()

def python.AccumulatorCache.AccumulatorDecorator._callImpl (   self, *  args, **  kwargs  )

private

Implementation of __call__.

Returns: (result, cacheHit)

Definition at line 164 of file AccumulatorCache.py.

    def _callImpl(self, *args, **kwargs):
        """Implementation of __call__.
 
        Returns: (result, cacheHit)
        """
 
        # AccumulatorCache enabled?
        if not AccumulatorDecorator._memoize:
            return (self._func(*args , **kwargs), None)
 
        # frozen set makes the order of keyword arguments irrelevant
        hsh = hash( (tuple(AccumulatorDecorator._getHash(a) for a in args),
                     frozenset((hash(k), AccumulatorDecorator._getHash(v)) for k,v in kwargs.items())) )
 
        res = self._cache.get(hsh, None)
        if res is not None:
            cacheHit = None
            if AccumulatorDecorator.VERIFY_HASH == self._verify:
                resHsh = self._resultCache[hsh]
                chkHsh = AccumulatorDecorator._getHash(res)
                if chkHsh != resHsh:
                    _msg.debug("Hash of function result, cached using AccumulatorDecorator, changed.")
                    cacheHit = False
                    res = self._func(*args , **kwargs)
                    self._cache[hsh] = res
                    self._resultCache[hsh] = AccumulatorDecorator._getHash(res)
                else:
                    cacheHit = True
            else:
                cacheHit = True
 
            if self._deepcopy:
                return deepcopy(res), cacheHit
            else:
                # shallow copied CA still needs to undergo merging
                from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
                if isinstance(res, ComponentAccumulator):
                    res._wasMerged=False
                return res, cacheHit
 
        else:
            _msg.debug('Hash not found in AccumulatorCache for function %s' , self._func)
            if len(self._cache) >= self._maxSize:
                _msg.warning("Cache limit (%d) reached for %s.%s",
                             self._maxSize, self._func.__module__, self._func.__name__)
                oldest = self._cache.pop(next(iter(self._cache)))
                AccumulatorDecorator._evict(oldest)
 
            res = self._func(*args , **kwargs)
 
            if AccumulatorDecorator.VERIFY_HASH == self._verify:
                if len(self._resultCache) >= self._maxSize:
                    del self._resultCache[next(iter(self._resultCache))]
                self._resultCache[hsh] = AccumulatorDecorator._getHash(res)
                self._cache[hsh] = res
            else:
                self._cache[hsh] = res
 
            return (deepcopy(res) if self._deepcopy else res, False)
 

_evict()

def python.AccumulatorCache.AccumulatorDecorator._evict (   x )

private

Called when x is removed from the cache

Definition at line 128 of file AccumulatorCache.py.

    def _evict(x):
        """Called when x is removed from the cache"""
        if isinstance(x, AccumulatorCachable):
            x._cacheEvict()
        elif isinstance(x, Iterable) and not isinstance(x, str):
            for el in x:
                AccumulatorDecorator._evict(el)
 

_evictAll()

def python.AccumulatorCache.AccumulatorDecorator._evictAll (   self )

private

Definition at line 136 of file AccumulatorCache.py.

    def _evictAll(self):
        for v in self._cache.values():
            AccumulatorDecorator._evict(v)
 

_getHash()

def python.AccumulatorCache.AccumulatorDecorator._getHash (   x )

private

Definition at line 119 of file AccumulatorCache.py.

    def _getHash(x):
        if hasattr(x, "athHash"):
            return x.athHash()
        elif isinstance(x, Hashable):
            return hash(x)
        elif isinstance(x, DataHandle):
            return hash(repr(x))
        raise NotHashable(x)
 

clearCache()

def python.AccumulatorCache.AccumulatorDecorator.clearCache

(

cls

)

Clear all accumulator caches

Definition at line 110 of file AccumulatorCache.py.

    def clearCache(cls):
        """Clear all accumulator caches"""
        for decor in cls._stats:
            decor._evictAll()
            decor._cache.clear()
            decor._resultCache.clear()
 
        cls._stats.clear()
 

getInfo()

def python.AccumulatorCache.AccumulatorDecorator.getInfo

(

self

)

Return a dictionary with information about the cache size and cache usage

Definition at line 75 of file AccumulatorCache.py.

    def getInfo(self):
        """Return a dictionary with information about the cache size and cache usage"""
        return {"cache_size" : len(self._cache),
                "misses" : self._stats[self].misses,
                "hits" : self._stats[self].hits,
                "function" : self._func,
                "result_cache_size" : len(self._resultCache)}
 

printStats()

def python.AccumulatorCache.AccumulatorDecorator.printStats

(

cls

)

Print cache statistics

Definition at line 84 of file AccumulatorCache.py.

    def printStats(cls):
        """Print cache statistics"""
        header = "%-70s |    Hits (time) |  Misses (time) |" % "AccumulatorCache"
        print("-"*len(header))
        print(header)
        print("-"*len(header))
        # Print sorted by hit+miss time:
        for func, stats in sorted(cls._stats.items(), key=lambda s:s[1].t_hits+s[1].t_misses, reverse=True):
            name = f"{func.__module__}.{func.__name__}"
            if len(name) > 70:
                name = '...' + name[-67:]
            print(f"{name:70} | {stats.hits:6} ({stats.t_hits:4.1f}s) | "
                  f"{stats.misses:6} ({stats.t_misses:4.1f}s) |")
        print("-"*len(header))
 

resumeCaching()

def python.AccumulatorCache.AccumulatorDecorator.resumeCaching

(

cls

)

Resume memoization for all instances of AccumulatorDecorator.

Definition at line 105 of file AccumulatorCache.py.

    def resumeCaching(cls):
        """Resume memoization for all instances of AccumulatorDecorator."""
        cls._memoize = True
 

suspendCaching()

def python.AccumulatorCache.AccumulatorDecorator.suspendCaching

(

cls

)

Suspend memoization for all instances of AccumulatorDecorator.

Definition at line 100 of file AccumulatorCache.py.

    def suspendCaching(cls):
        """Suspend memoization for all instances of AccumulatorDecorator."""
        cls._memoize = False
 

Member Data Documentation

_cache

python.AccumulatorCache.AccumulatorDecorator._cache

private

Definition at line 67 of file AccumulatorCache.py.

_deepcopy

python.AccumulatorCache.AccumulatorDecorator._deepcopy

private

Definition at line 70 of file AccumulatorCache.py.

_func

python.AccumulatorCache.AccumulatorDecorator._func

private

Definition at line 66 of file AccumulatorCache.py.

_maxSize

python.AccumulatorCache.AccumulatorDecorator._maxSize

private

Definition at line 65 of file AccumulatorCache.py.

_memoize [1/2]

bool python.AccumulatorCache.AccumulatorDecorator._memoize = True

staticprivate

Definition at line 47 of file AccumulatorCache.py.

_memoize [2/2]

python.AccumulatorCache.AccumulatorDecorator._memoize

private

Definition at line 102 of file AccumulatorCache.py.

_resultCache

python.AccumulatorCache.AccumulatorDecorator._resultCache

private

Definition at line 68 of file AccumulatorCache.py.

_stats

python.AccumulatorCache.AccumulatorDecorator._stats

staticprivate

Definition at line 59 of file AccumulatorCache.py.

_verify

python.AccumulatorCache.AccumulatorDecorator._verify

private

Definition at line 69 of file AccumulatorCache.py.

VERIFY_HASH

int python.AccumulatorCache.AccumulatorDecorator.VERIFY_HASH = 1

static

Definition at line 50 of file AccumulatorCache.py.

VERIFY_NOTHING

int python.AccumulatorCache.AccumulatorDecorator.VERIFY_NOTHING = 0

static

Definition at line 49 of file AccumulatorCache.py.

---

The documentation for this class was generated from the following file:

• AccumulatorCache.py