summary refs log tree commit diff
path: root/synapse/util/caches/expiringcache.py
blob: c6a5d0dfc0a99b7cb5e5374393038790b0241336 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
# Copyright 2015, 2016 OpenMarket Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import logging
from collections import OrderedDict
from typing import Any, Generic, Optional, TypeVar, Union, overload

import attr
from typing_extensions import Literal

from twisted.internet import defer

from synapse.config import cache as cache_config
from synapse.metrics.background_process_metrics import run_as_background_process
from synapse.util import Clock
from synapse.util.caches import EvictionReason, register_cache

logger = logging.getLogger(__name__)


SENTINEL: Any = object()


T = TypeVar("T")
KT = TypeVar("KT")
VT = TypeVar("VT")


class ExpiringCache(Generic[KT, VT]):
    def __init__(
        self,
        cache_name: str,
        clock: Clock,
        max_len: int = 0,
        expiry_ms: int = 0,
        reset_expiry_on_get: bool = False,
        iterable: bool = False,
    ):
        """
        Args:
            cache_name: Name of this cache, used for logging.
            clock
            max_len: Max size of dict. If the dict grows larger than this
                then the oldest items get automatically evicted. Default is 0,
                which indicates there is no max limit.
            expiry_ms: How long before an item is evicted from the cache
                in milliseconds. Default is 0, indicating items never get
                evicted based on time.
            reset_expiry_on_get: If true, will reset the expiry time for
                an item on access. Defaults to False.
            iterable: If true, the size is calculated by summing the
                sizes of all entries, rather than the number of entries.
        """
        self._cache_name = cache_name

        self._original_max_size = max_len

        self._max_size = int(max_len * cache_config.properties.default_factor_size)

        self._clock = clock

        self._expiry_ms = expiry_ms
        self._reset_expiry_on_get = reset_expiry_on_get

        self._cache: OrderedDict[KT, _CacheEntry] = OrderedDict()

        self.iterable = iterable

        self.metrics = register_cache("expiring", cache_name, self)

        if not self._expiry_ms:
            # Don't bother starting the loop if things never expire
            return

        def f() -> "defer.Deferred[None]":
            return run_as_background_process(
                "prune_cache_%s" % self._cache_name, self._prune_cache
            )

        self._clock.looping_call(f, self._expiry_ms / 2)

    def __setitem__(self, key: KT, value: VT) -> None:
        now = self._clock.time_msec()
        self._cache[key] = _CacheEntry(now, value)
        self.evict()

    def evict(self) -> None:
        # Evict if there are now too many items
        while self._max_size and len(self) > self._max_size:
            _key, value = self._cache.popitem(last=False)
            if self.iterable:
                self.metrics.inc_evictions(EvictionReason.size, len(value.value))
            else:
                self.metrics.inc_evictions(EvictionReason.size)

    def __getitem__(self, key: KT) -> VT:
        try:
            entry = self._cache[key]
            self.metrics.inc_hits()
        except KeyError:
            self.metrics.inc_misses()
            raise

        if self._reset_expiry_on_get:
            entry.time = self._clock.time_msec()

        return entry.value

    def pop(self, key: KT, default: T = SENTINEL) -> Union[VT, T]:
        """Removes and returns the value with the given key from the cache.

        If the key isn't in the cache then `default` will be returned if
        specified, otherwise `KeyError` will get raised.

        Identical functionality to `dict.pop(..)`.
        """

        value = self._cache.pop(key, SENTINEL)
        # The key was not found.
        if value is SENTINEL:
            if default is SENTINEL:
                raise KeyError(key)
            return default

        if self.iterable:
            self.metrics.inc_evictions(EvictionReason.invalidation, len(value.value))
        else:
            self.metrics.inc_evictions(EvictionReason.invalidation)

        return value.value

    def __contains__(self, key: KT) -> bool:
        return key in self._cache

    @overload
    def get(self, key: KT, default: Literal[None] = None) -> Optional[VT]:
        ...

    @overload
    def get(self, key: KT, default: T) -> Union[VT, T]:
        ...

    def get(self, key: KT, default: Optional[T] = None) -> Union[VT, Optional[T]]:
        try:
            return self[key]
        except KeyError:
            return default

    def setdefault(self, key: KT, value: VT) -> VT:
        try:
            return self[key]
        except KeyError:
            self[key] = value
            return value

    async def _prune_cache(self) -> None:
        if not self._expiry_ms:
            # zero expiry time means don't expire. This should never get called
            # since we have this check in start too.
            return
        begin_length = len(self)

        now = self._clock.time_msec()

        keys_to_delete = set()

        for key, cache_entry in self._cache.items():
            if now - cache_entry.time > self._expiry_ms:
                keys_to_delete.add(key)

        for k in keys_to_delete:
            value = self._cache.pop(k)
            if self.iterable:
                self.metrics.inc_evictions(EvictionReason.time, len(value.value))
            else:
                self.metrics.inc_evictions(EvictionReason.time)

        logger.debug(
            "[%s] _prune_cache before: %d, after len: %d",
            self._cache_name,
            begin_length,
            len(self),
        )

    def __len__(self) -> int:
        if self.iterable:
            return sum(len(entry.value) for entry in self._cache.values())
        else:
            return len(self._cache)

    def set_cache_factor(self, factor: float) -> bool:
        """
        Set the cache factor for this individual cache.

        This will trigger a resize if it changes, which may require evicting
        items from the cache.

        Returns:
            bool: Whether the cache changed size or not.
        """
        new_size = int(self._original_max_size * factor)
        if new_size != self._max_size:
            self._max_size = new_size
            self.evict()
            return True
        return False


@attr.s(slots=True, auto_attribs=True)
class _CacheEntry:
    time: int
    value: Any