Xavier Morel
9d37cecfca
Iteration methods on LRU were removed because they were not thread-safe and it's not clear that making them thread-safe is the correct thing to do, so not providing them seems saner. I thought I'd looked for usages of the LRU but apparently didn't look hard enough as I missed that it's used by the cron workers (apparently using the threaded server we only run crons for dbs currently living in the registry cache, the more you know). Convert these to iterating on the LRU's internal mapping, and also don't iterate on the LRU to clear its entries one by one when we can just clear the entire thing safely, although Registry.delete_all really seems completely unused. closes odoo/odoo#49023 Signed-off-by: Xavier Morel (xmo) <xmo@odoo.com>
236 lines
8.2 KiB
Python
236 lines
8.2 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
# decorator makes wrappers that have the same API as their wrapped function
|
|
from collections import defaultdict
|
|
from decorator import decorator
|
|
from inspect import signature
|
|
import logging
|
|
|
|
unsafe_eval = eval
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class ormcache_counter(object):
|
|
""" Statistic counters for cache entries. """
|
|
__slots__ = ['hit', 'miss', 'err']
|
|
|
|
def __init__(self):
|
|
self.hit = 0
|
|
self.miss = 0
|
|
self.err = 0
|
|
|
|
@property
|
|
def ratio(self):
|
|
return 100.0 * self.hit / (self.hit + self.miss or 1)
|
|
|
|
# statistic counters dictionary, maps (dbname, modelname, method) to counter
|
|
STAT = defaultdict(ormcache_counter)
|
|
|
|
|
|
class ormcache(object):
|
|
""" LRU cache decorator for model methods.
|
|
The parameters are strings that represent expressions referring to the
|
|
signature of the decorated method, and are used to compute a cache key::
|
|
|
|
@ormcache('model_name', 'mode')
|
|
def _compute_domain(self, model_name, mode="read"):
|
|
...
|
|
|
|
For the sake of backward compatibility, the decorator supports the named
|
|
parameter `skiparg`::
|
|
|
|
@ormcache(skiparg=1)
|
|
def _compute_domain(self, model_name, mode="read"):
|
|
...
|
|
|
|
Methods implementing this decorator should never return a Recordset,
|
|
because the underlying cursor will eventually be closed and raise a
|
|
`psycopg2.OperationalError`.
|
|
"""
|
|
def __init__(self, *args, **kwargs):
|
|
self.args = args
|
|
self.skiparg = kwargs.get('skiparg')
|
|
|
|
def __call__(self, method):
|
|
self.method = method
|
|
self.determine_key()
|
|
lookup = decorator(self.lookup, method)
|
|
lookup.clear_cache = self.clear
|
|
return lookup
|
|
|
|
def determine_key(self):
|
|
""" Determine the function that computes a cache key from arguments. """
|
|
if self.skiparg is None:
|
|
# build a string that represents function code and evaluate it
|
|
args = str(signature(self.method))[1:-1]
|
|
if self.args:
|
|
code = "lambda %s: (%s,)" % (args, ", ".join(self.args))
|
|
else:
|
|
code = "lambda %s: ()" % (args,)
|
|
self.key = unsafe_eval(code)
|
|
else:
|
|
# backward-compatible function that uses self.skiparg
|
|
self.key = lambda *args, **kwargs: args[self.skiparg:]
|
|
|
|
def lru(self, model):
|
|
counter = STAT[(model.pool.db_name, model._name, self.method)]
|
|
return model.pool.cache, (model._name, self.method), counter
|
|
|
|
def lookup(self, method, *args, **kwargs):
|
|
d, key0, counter = self.lru(args[0])
|
|
key = key0 + self.key(*args, **kwargs)
|
|
try:
|
|
r = d[key]
|
|
counter.hit += 1
|
|
return r
|
|
except KeyError:
|
|
counter.miss += 1
|
|
value = d[key] = self.method(*args, **kwargs)
|
|
return value
|
|
except TypeError:
|
|
_logger.warning("cache lookup error on %r", key, exc_info=True)
|
|
counter.err += 1
|
|
return self.method(*args, **kwargs)
|
|
|
|
def clear(self, model, *args):
|
|
""" Clear the registry cache """
|
|
model.pool._clear_cache()
|
|
|
|
|
|
class ormcache_context(ormcache):
|
|
""" This LRU cache decorator is a variant of :class:`ormcache`, with an
|
|
extra parameter ``keys`` that defines a sequence of dictionary keys. Those
|
|
keys are looked up in the ``context`` parameter and combined to the cache
|
|
key made by :class:`ormcache`.
|
|
"""
|
|
def __init__(self, *args, **kwargs):
|
|
super(ormcache_context, self).__init__(*args, **kwargs)
|
|
self.keys = kwargs['keys']
|
|
|
|
def determine_key(self):
|
|
""" Determine the function that computes a cache key from arguments. """
|
|
assert self.skiparg is None, "ormcache_context() no longer supports skiparg"
|
|
# build a string that represents function code and evaluate it
|
|
sign = signature(self.method)
|
|
args = str(sign)[1:-1]
|
|
cont_expr = "(context or {})" if 'context' in sign.parameters else "self._context"
|
|
keys_expr = "tuple(%s.get(k) for k in %r)" % (cont_expr, self.keys)
|
|
if self.args:
|
|
code = "lambda %s: (%s, %s)" % (args, ", ".join(self.args), keys_expr)
|
|
else:
|
|
code = "lambda %s: (%s,)" % (args, keys_expr)
|
|
self.key = unsafe_eval(code)
|
|
|
|
|
|
class ormcache_multi(ormcache):
|
|
""" This LRU cache decorator is a variant of :class:`ormcache`, with an
|
|
extra parameter ``multi`` that gives the name of a parameter. Upon call, the
|
|
corresponding argument is iterated on, and every value leads to a cache
|
|
entry under its own key.
|
|
"""
|
|
def __init__(self, *args, **kwargs):
|
|
super(ormcache_multi, self).__init__(*args, **kwargs)
|
|
self.multi = kwargs['multi']
|
|
|
|
def determine_key(self):
|
|
""" Determine the function that computes a cache key from arguments. """
|
|
assert self.skiparg is None, "ormcache_multi() no longer supports skiparg"
|
|
assert isinstance(self.multi, str), "ormcache_multi() parameter multi must be an argument name"
|
|
|
|
super(ormcache_multi, self).determine_key()
|
|
|
|
# key_multi computes the extra element added to the key
|
|
sign = signature(self.method)
|
|
args = str(sign)[1:-1]
|
|
code_multi = "lambda %s: %s" % (args, self.multi)
|
|
self.key_multi = unsafe_eval(code_multi)
|
|
|
|
# self.multi_pos is the position of self.multi in args
|
|
self.multi_pos = list(sign.parameters).index(self.multi)
|
|
|
|
def lookup(self, method, *args, **kwargs):
|
|
d, key0, counter = self.lru(args[0])
|
|
base_key = key0 + self.key(*args, **kwargs)
|
|
ids = self.key_multi(*args, **kwargs)
|
|
result = {}
|
|
missed = []
|
|
|
|
# first take what is available in the cache
|
|
for i in ids:
|
|
key = base_key + (i,)
|
|
try:
|
|
result[i] = d[key]
|
|
counter.hit += 1
|
|
except Exception:
|
|
counter.miss += 1
|
|
missed.append(i)
|
|
|
|
if missed:
|
|
# call the method for the ids that were not in the cache; note that
|
|
# thanks to decorator(), the multi argument will be bound and passed
|
|
# positionally in args.
|
|
args = list(args)
|
|
args[self.multi_pos] = missed
|
|
result.update(method(*args, **kwargs))
|
|
|
|
# store those new results back in the cache
|
|
for i in missed:
|
|
key = base_key + (i,)
|
|
d[key] = result[i]
|
|
|
|
return result
|
|
|
|
|
|
class dummy_cache(object):
|
|
""" Cache decorator replacement to actually do no caching. """
|
|
def __init__(self, *l, **kw):
|
|
pass
|
|
|
|
def __call__(self, fn):
|
|
fn.clear_cache = self.clear
|
|
return fn
|
|
|
|
def clear(self, *l, **kw):
|
|
pass
|
|
|
|
|
|
def log_ormcache_stats(sig=None, frame=None):
|
|
""" Log statistics of ormcache usage by database, model, and method. """
|
|
from odoo.modules.registry import Registry
|
|
import threading
|
|
|
|
me = threading.currentThread()
|
|
me_dbname = getattr(me, 'dbname', 'n/a')
|
|
|
|
for dbname, reg in sorted(Registry.registries.d.items()):
|
|
# set logger prefix to dbname
|
|
me.dbname = dbname
|
|
entries = defaultdict(int)
|
|
# beware: we use .keys() on purpose here (reg.cache is not a real dict)
|
|
for key in reg.cache.keys():
|
|
entries[key[:2]] += 1
|
|
# show entries sorted by model name, method name
|
|
for key in sorted(entries, key=lambda key: (key[0], key[1].__name__)):
|
|
model, method = key
|
|
stat = STAT[(dbname, model, method)]
|
|
_logger.info(
|
|
"%6d entries, %6d hit, %6d miss, %6d err, %4.1f%% ratio, for %s.%s",
|
|
entries[key], stat.hit, stat.miss, stat.err, stat.ratio, model, method.__name__,
|
|
)
|
|
|
|
me.dbname = me_dbname
|
|
|
|
|
|
def get_cache_key_counter(bound_method, *args, **kwargs):
|
|
""" Return the cache, key and stat counter for the given call. """
|
|
model = bound_method.__self__
|
|
ormcache = bound_method.clear_cache.__self__
|
|
cache, key0, counter = ormcache.lru(model)
|
|
key = key0 + ormcache.key(model, *args, **kwargs)
|
|
return cache, key, counter
|
|
|
|
# For backward compatibility
|
|
cache = ormcache
|