Context Navigation

← Previous Change
Wiki History
Next Change →

CacheInvalidation

Timestamp:: May 9, 2015, 11:53:37 PM (9 years ago)
Author:: figaro
Comment:: Cosmetic changes, added link to previous proposal

Legend:

: Unmodified
: Added
: Removed
: Modified

TracDev/Proposals/CacheInvalidation

-              v22
+              v23
 [[PageOutline(2-4)]]
+= The problem of cache invalidation =
+// This was the design discussion behind the `trac.cache` module ([source:trunk/trac/cache.py trunk], [source:branches/1.0-stable/trac/cache.py 1.0.x]). See also apidoc:api/trac_cache. //
+== Problem ==
+= The problem of cache invalidation
+This was the design discussion behind the `trac.cache` module ([source:trunk/trac/cache.py trunk], [source:branches/1.0-stable/trac/cache.py 1.0.x]). See also apidoc:api/trac_cache.
+== Problem
 Trac uses various caches at the component level, in order to speed-up costly tasks. Some examples are the recent addition of ticket fields cache (#6436), others are the InterMapTxt cache, the user permission cache, the oldest example being the Wiki page cache.
 Those cache are held at the level of `Component` instances. For a given class, there's one such instance per environment in any given server process. The first thing to take into account here is that those caches must be safely accessed and modified when accessed by concurrent threads (in multi-threaded web front ends, that is). That's not a big deal, and I think it's already handled appropriately.
 But due to the always possible concurrent access at the underlying database level by multiple processes, there's also a need to maintain a consistency and up-to-date status of those caches across all processes involved. Otherwise, you might do a change by the way of one request and the next request (even the GET following a redirect after your POST!) might be handled by a different server process which has a different "view" of the application state, and you end up confused at best, filing a bug on t.e.o at worst ;-)
+But due to the always possible concurrent access at the underlying database level by multiple processes, there's also a need to maintain a consistency and up-to-date status of those caches across all processes involved. Otherwise, you might do a change by the way of one request and the next request (even the GET following a redirect after your POST!) might be handled by a different server process which has a different "view" of the application state, and you end up confused at best, filing a bug on t.e.o at worst.
 This doesn't even have to imply a multi-process server setup, as all what is needed is e.g. a modification of the database done using trac-admin.
+== Current Situation ==
+This proposal was previously logged as wiki:TracDev/Proposals/Journaling.
+== Current Situation
 So the current solution to the above problem is to use some kind of global reset mechanism, which will not only invalidate the caches, but simply "throw away" all the `Component` instances of the environment that has been globally reset. That reset happens by the way of a simulated change on the TracIni file, triggered by a call to `self.config.touch()` from a component instance. The next time an environment instance is retrieved, the old environment instance is found to be out of date and a new one will be created (see `trac.env.open_environment`). Consequently, new Component instances will be created as well, and the caches will be repopulated as needed.
 Pros:
  - it works well ;-)
+ - it works well
 Cons:
 …
  - it's all or nothing - the more we rely on this mechanism for different caches, the more we'll aggravate the above situation. Ideally, invalidating one cache should not force all the other caches to be reset.
+== Final implementation ==
+== Final implementation
 The final implementation, committed in [8071], is a refinement of the [#CacheManager CacheManager] idea.
 The documentation for this feature (starting with the content of this section) now lives in TracDev/CacheManager.
  * '''Creating a cached attribute''' is done by defining a retrieval function and decorating it with the '''`@cached_value`''' decorator. For example, for the wiki page names:
 …
  * The `cache` table is read the first time a cached attribute is accessed during a request. This avoids slowing down requests that don't touch cached attributes, like requests for static content for example.
 -----
 ''The sections below are kept as documentation of the implementation process.''
 == Idea 1: The `CacheManager` == #CacheManager
 This idea introduces a centralized cache manager component that manages cached data, retrieval from the database and invalidation of cached data. The assumption is that it doesn't make sense to retrieve data to be cached from the database more than once per HTTP request.
 …
 Comments and improvements are welcome. If this approach sounds reasonable, I'd like to do a prototype implementation and apply it to a few locations (the wiki page cache and ticket fields).
+=== Prototype implementation ===
+=== Prototype implementation
 A prototype implementation of this approach is available in [attachment:cache-manager-r7941.patch]. It implements the cache manager and has been applied to the wiki page, InterMapTxt and ticket field caches.
  * Creating a cached attribute is extremely simple: declare a retrieval function with the desired name of the attribute and apply the `@cached_value` or `@cached` decorator. For example, for the wiki pages:
+{{{
+#!python
+{{{#!python
 @cached_value('wiki.WikiSystem.pages')
 def pages(self, db):
 …
  * Invalidating a cached attribute is done by deleting the attribute:
+{{{
+#!python
+{{{#!python
 def wiki_page_added(self, page):
     if not self.has_page(page.name):
 …
  * To test the patch, the table `cache` must be created by hand in the database, as follows (for SQLite):
+{{{
+#!sql
+{{{#!sql
 CREATE TABLE cache (
     key text PRIMARY KEY,
     generation int
+    key TEXT PRIMARY KEY,
+    generation INT
 );
 }}}
 …
  * Two new `trac-admin` commands allow listing the `cache` table and invalidating one or more caches. They are intended for debugging purposes, and should probably be removed if the proposal is applied to trunk.
+=== Discussion ===
+=== Discussion
 '''Comments and testing are very welcome'''. The implementation is quite complete, except for the missing database upgrade module. I have only tested with several concurrent `tracd` instances so far.
+==== cboos: feedback ====
+==== cboos: feedback
 It's really nice, I like it a lot!
 …
 I've also added more documentation to the decorators and changed the order of the definitions in a top-down way (first the decorators, then the descriptors, ending with the proxy class), as I think it's easier to understand that way.
+==== rblank: ====
+==== rblank:
 Thanks for the improvement ideas, I'll integrate them shortly.
  - I'm not sure the DB race condition you describe can actually happen. At least with SQLite, issuing a `SELECT` sets the lock state to `SHARED`, which disallows writes, so it should not be possible to increase the generation between the data retrieval and fetching the generation. I don't know how this behaves with other databases, though. Maybe it's just safer to fetch the generation first.
 …
  - If the keys are auto-generated, the decorators don't need any arguments anymore. This allows simplifying them even more by dropping the `cached()` and `cached_value()` functions, and calling the descriptor classes `cached` and `cached_value` directly.
+==== cboos: ====
+==== cboos:
  - SELECT statements don't start a transaction in PySqlite, as opposed to the other DML statements. So in my understanding, each retrieval is "atomic" and I think there can indeed be a race condition between the SELECT(s) done for data retrieval and the SELECT for fetching the generation.
    As this picked my curiosity, I tried to see how multiple SELECTs could be done within a single transaction, and this is indeed possible, but a bit heavyweight: see e.g. pysqlite:IdRange, look for `def get_id_range`. So I think it's better to simply cope with the race.
 …
  - great, I didn't know one can do that
+==== cboos: !CacheManager used in non-Component classes ====
+==== cboos: !CacheManager used in non-Component classes
 When thinking about how to use the !CacheManager for getting the `youngest_rev` information from !CachedRepository, I saw two additional problems:
  - we can't use the decorators here, as the !CachedRepository is not a Component (and shouldn't be, as we may have many instances per environment)
 …
 So we need to access the !CacheManager directly, using something like:
+{{{
+#!python
+{{{#!python
     @property
     def metadata(self):
 …
 Do you see a better way to do it?
+==== rblank: ====
+==== rblank:
 Yes, by instantiating `CacheProxy` in the constructor and storing it as an instance attribute. This gives it the same interface as if `@cached` was used.
+{{{
+#!python
+{{{#!python
     self.metadata = CacheProxy('CachedRepository.metadata:' + self.name, self.get_metadata, env)
 }}}
 This does indeed require `env`, and changing that will make the `CachedRepository` unit tests a bit more complicated :-/
+==== rblank: Update with feedback ====
+==== rblank: Update with feedback
 The attachment:cache-manager-r7989.patch is an updated patch which should take into account all corner cases described above. Cache keys are now auto-generated from the module, class and attribute name. I have also added the database upgrade code, so the `db_version` is now 22.
 Are there any other issues that should be considered? If not, the next step would be to plan the integration into trunk. Are there any special considerations when upgrading the database version? What else (other than committing) must be done?
+==== cboos: feedback ====
+==== cboos: feedback
  - Last round of feedback:
    - The API documentation should also mention that `cached` and `cached_value`
 …
  - We could also think about adding some tests for this, though that might be more involved.
+==== rblank: ====
+==== rblank:
  - Replies to last round of feedback:
    - Will do.
    - That's what I tried first, but the error due to the `INSERT` rolled back the whole transaction. I'll have to find a way to do this in a single statement.
+==== cboos: ====
+==== cboos:
 Hm right, that can be problematic. So what about this:
+{{{
+#!python
+{{{#!python
     cursor.execute("SELECT generation FROM cache WHERE key=%s",
                    (key,))
 …
                            "WHERE key=%s", (key,))
 }}}
+If we were in a transaction, then I suppose the SELECT/INSERT
+sequence can't fail. Conversely, if it fails, then we were
+''not'' in a transaction, and we can follow-up with an UPDATE
+to recover from the failed INSERT.
+==== rblank: Alternative for atomic UPSERT ====
+If we were in a transaction, then I suppose the SELECT/INSERT sequence can't fail. Conversely, if it fails, then we were ''not'' in a transaction, and we can follow-up with an UPDATE to recover from the failed INSERT.
+==== rblank: Alternative for atomic UPSERT
 That could work, yes. How about this:
+{{{
+#!python
+{{{#!python
     cursor.execute("UPDATE cache SET generation=generation+1 "
                    "WHERE key=%s", (key,))
 …
 transaction if no rows are altered. We may have to use a dummy row that is always updated in addition to the desired row.
+==== cboos: ====
+==== cboos:
 Looks great! I don't think we can have something any simpler, in particular the UPDATE doesn't seem to return the number of modified rows for all backends (at least, that doesn't seem to be possible with SQLite3 and Pysqlite).
+==== rblank: Updated patch ====
+==== rblank: Updated patch
 The attachment:cache-manager-r7992.patch improves the docstrings for the decorators and the proxy, and makes invalidation atomic. I'll now ask for feedback on trac-dev.
+== Idea 2: Cache control ==
+== Idea 2: Cache control
 I'm currently thinking about the following solution.
+Each time a cache needs to be invalidated (i.e. in the current situations where we call `config.touch()`), we would instead call `env.cache_invalidate(cache_key)`, where `cache_key` is
+some unique key identifying that cache (e.g. "InterMapTxt" or "repository-''reponame''" for the MultipleRepositorySupport/Cache). This call will atomically increment some ''generation'' value associated to the key, in the db (that might be tricky - select for update for Pgsql, explicit transaction for Pysqlite). A simple `create table cachecontrol (key text, generation int)` should be enough.
+Each time a cache needs to be invalidated (i.e. in the current situations where we call `config.touch()`), we would instead call `env.cache_invalidate(cache_key)`, where `cache_key` is some unique key identifying that cache (e.g. "InterMapTxt" or "repository-''reponame''" for the MultipleRepositorySupport/Cache). This call will atomically increment some ''generation'' value associated to the key, in the db (that might be tricky - select for update for Pgsql, explicit transaction for Pysqlite). A simple `create table cachecontrol (key text, generation int)` should be enough.
 At periodic times, e.g. in `open_environment`, we would call `env.cache_update()`. That will do a `select * from cachecontrol`. The results are stored besides the previously known latest values, therefore we can quickly see which caches need a refresh.
 …
 Whenever a Component has to fetch a value from the cache, it will first call `env.cache_is_valid(cache_key)`. If the result is true, it can retrieve values from the cache. If not, the cache has to be updated first. Once the cache is refreshed, the component calls `env.cache_validate(cache_key)`.
+=== Example: InterMapTxt cache ===
+=== Example: InterMapTxt cache
 For convenience, if a Component only manages one cache (the common case), it can pass `self` instead of a string key and its class name will be used.
 Only the code changes for trac/env.py and trac/wiki/interwiki.py are roughly implemented (i.e. not tested yet - just to illustrate the above).
+Only the code changes for trac/env.py and trac/wiki/interwiki.py are roughly implemented. Not tested yet and just to illustrate the above.
 See attachment:cache_control-r7933.diff.
 For testing, manual creation of a cache_control table is needed:
 {{{
+{{{#!sql
 CREATE TABLE cache_control( key text primary key, generation int);
 }}}
 …
 That concludes my initial approach to the problem. Now let's take into account what was proposed in idea 1...
+=== Discussion ===
+=== Discussion
 While the two approaches are quite close in spirit, there are a few differences.
 …
 ''Indeed, the basic idea is the same. My goal was to push as much of the logic into the `CacheManager` as possible, so that cache users would only have two functionalities: get the data (this could even be hidden by using a `property`-like descriptor) and invalidate the cache. There should be no need for cache users to "remember to first check if the cache is valid, then ...": this logic is common to all cache users, and can be integrated into the cache manager.''
-''I'll get started on a prototype implementation as well, to see how simple I can make it for the cache user.''