const TTL_LAGGED = 30;
/** Idiom for delete() for "no hold-off" */
const HOLDOFF_NONE = 0;
+ /** Idiom for set()/getWithSetCallback() for "do not augment the storage medium TTL" */
+ const STALE_TTL_NONE = 0;
+
/** Idiom for getWithSetCallback() for "no minimum required as-of timestamp" */
const MIN_TIMESTAMP_NONE = 0.0;
* @return WANObjectCache
*/
public static function newEmpty() {
- return new self( [
+ return new static( [
'cache' => new EmptyBagOStuff(),
'pool' => 'empty'
] );
$wrappedValues += $this->cache->getMulti( $keysGet );
}
// Time used to compare/init "check" keys (derived after getMulti() to be pessimistic)
- $now = microtime( true );
+ $now = $this->getCurrentTime();
// Collect timestamps from all "check" keys
$purgeValuesForAll = $this->processCheckKeys( $checkKeysForAll, $wrappedValues, $now );
* they certainly should not see ones that ended up getting rolled back.
* Default: false
* - lockTSE : if excessive replication/snapshot lag is detected, then store the value
- * with this TTL and flag it as stale. This is only useful if the reads for
- * this key use getWithSetCallback() with "lockTSE" set.
+ * with this TTL and flag it as stale. This is only useful if the reads for this key
+ * use getWithSetCallback() with "lockTSE" set. Note that if "staleTTL" is set
+ * then it will still add on to this TTL in the excessive lag scenario.
* Default: WANObjectCache::TSE_NONE
* - staleTTL : Seconds to keep the key around if it is stale. The get()/getMulti()
* methods return such stale values with a $curTTL of 0, and getWithSetCallback()
* will call the regeneration callback in such cases, passing in the old value
* and its as-of time to the callback. This is useful if adaptiveTTL() is used
* on the old value's as-of time when it is verified as still being correct.
- * Default: 0.
+ * Default: WANObjectCache::STALE_TTL_NONE.
* @note Options added in 1.28: staleTTL
* @return bool Success
*/
final public function set( $key, $value, $ttl = 0, array $opts = [] ) {
- $now = microtime( true );
+ $now = $this->getCurrentTime();
$lockTSE = isset( $opts['lockTSE'] ) ? $opts['lockTSE'] : self::TSE_NONE;
+ $staleTTL = isset( $opts['staleTTL'] ) ? $opts['staleTTL'] : self::STALE_TTL_NONE;
$age = isset( $opts['since'] ) ? max( 0, $now - $opts['since'] ) : 0;
$lag = isset( $opts['lag'] ) ? $opts['lag'] : 0;
- $staleTTL = isset( $opts['staleTTL'] ) ? $opts['staleTTL'] : 0;
// Do not cache potentially uncommitted data as it might get rolled back
if ( !empty( $opts['pending'] ) ) {
$time = $purge[self::FLD_TIME];
} else {
// Casting assures identical floats for the next getCheckKeyTime() calls
- $now = (string)microtime( true );
+ $now = (string)$this->getCurrentTime();
$this->cache->add( $key,
$this->makePurgeValue( $now, self::HOLDOFF_TTL ),
self::CHECK_KEY_TTL
* on all keys that should be changed. When get() is called on those
* keys, the relevant "check" keys must be supplied for this to work.
*
- * The "check" key essentially represents a last-modified field.
- * When touched, the field will be updated on all cache servers.
- * Keys using it via get(), getMulti(), or getWithSetCallback() will
- * be invalidated. It is treated as being HOLDOFF_TTL seconds in the future
- * by those methods to avoid race conditions where dependent keys get updated
- * with stale values (e.g. from a DB replica DB).
- *
- * This is typically useful for keys with hardcoded names or in some cases
- * dynamically generated names where a low number of combinations exist.
- * When a few important keys get a large number of hits, a high cache
- * time is usually desired as well as "lockTSE" logic. The resetCheckKey()
- * method is less appropriate in such cases since the "time since expiry"
- * cannot be inferred, causing any get() after the reset to treat the key
- * as being "hot", resulting in more stale value usage.
+ * The "check" key essentially represents a last-modified time of an entity.
+ * When the key is touched, the timestamp will be updated to the current time.
+ * Keys using the "check" key via get(), getMulti(), or getWithSetCallback() will
+ * be invalidated. The timestamp of "check" is treated as being HOLDOFF_TTL seconds
+ * in the future by get*() methods in order to avoid race conditions where keys are
+ * updated with stale values (e.g. from a DB replica DB).
+ *
+ * This method is typically useful for keys with hardcoded names or in some cases
+ * dynamically generated names, provided the number of such keys is modest. It sets a
+ * high TTL on the "check" key, making it possible to know the timestamp of the last
+ * change to the corresponding entities in most cases.
+ *
+ * When a few important keys get a large number of hits, a high cache time is usually
+ * desired as well as "lockTSE" logic. The resetCheckKey() method is less appropriate
+ * in such cases since the "time since expiry" cannot be inferred, causing any get()
+ * after the reset to treat the key as being "hot", resulting in more stale value usage.
*
* Note that "check" keys won't collide with other regular keys.
*
* to, any temporary ejection of that server will cause the value to be
* seen as purged as a new server will initialize the "check" key.
*
- * The advantage is that this does not place high TTL keys on every cache
- * server, making it better for code that will cache many different keys
- * and either does not use lockTSE or uses a low enough TTL anyway.
- *
- * This is typically useful for keys with dynamically generated names
- * where a high number of combinations exist.
+ * The advantage here is that the "check" keys, which have high TTLs, will only
+ * be created when a get*() method actually uses that key. This is better when
+ * a large number of "check" keys are invalided in a short period of time.
*
* Note that "check" keys won't collide with other regular keys.
*
* Default: WANObjectCache::LOW_TTL.
* - ageNew: Consider popularity refreshes only once a key reaches this age in seconds.
* Default: WANObjectCache::AGE_NEW.
+ * - staleTTL: Seconds to keep the key around if it is stale. This means that on cache
+ * miss the callback may get $oldValue/$oldAsOf values for keys that have already been
+ * expired for this specified time. This is useful if adaptiveTTL() is used on the old
+ * value's as-of time when it is verified as still being correct.
+ * Default: WANObjectCache::STALE_TTL_NONE
* @return mixed Value found or written to the key
* @note Options added in 1.28: version, busyValue, hotTTR, ageNew, pcGroup, minAsOf
* @note Callable type hints are not used to avoid class-autoloading
// Value existed before with a different version; use variant key.
// Reflect purges to $key by requiring that this key value be newer.
$value = $this->doGetWithSetCallback(
- 'cache-variant:' . md5( $key ) . ":$version",
+ $this->makeGlobalKey( 'WANCache-key-variant', md5( $key ), $version ),
$ttl,
$callback,
// Regenerate value if not newer than $key
protected function doGetWithSetCallback( $key, $ttl, $callback, array $opts, &$asOf = null ) {
$lowTTL = isset( $opts['lowTTL'] ) ? $opts['lowTTL'] : min( self::LOW_TTL, $ttl );
$lockTSE = isset( $opts['lockTSE'] ) ? $opts['lockTSE'] : self::TSE_NONE;
+ $staleTTL = isset( $opts['staleTTL'] ) ? $opts['staleTTL'] : self::STALE_TTL_NONE;
$checkKeys = isset( $opts['checkKeys'] ) ? $opts['checkKeys'] : [];
$busyValue = isset( $opts['busyValue'] ) ? $opts['busyValue'] : null;
$popWindow = isset( $opts['hotTTR'] ) ? $opts['hotTTR'] : self::HOT_TTR;
$cValue = $this->get( $key, $curTTL, $checkKeys, $asOf ); // current value
$value = $cValue; // return value
- $preCallbackTime = microtime( true );
+ $preCallbackTime = $this->getCurrentTime();
// Determine if a cached value regeneration is needed or desired
if ( $value !== false
&& $curTTL > 0
// so use a special INTERIM key to pass the new value around threads.
if ( ( $isTombstone && $lockTSE > 0 ) && $valueIsCacheable ) {
$tempTTL = max( 1, (int)$lockTSE ); // set() expects seconds
- $newAsOf = microtime( true );
+ $newAsOf = $this->getCurrentTime();
$wrapped = $this->wrap( $value, $tempTTL, $newAsOf );
// Avoid using set() to avoid pointless mcrouter broadcasting
$this->setInterimValue( $key, $wrapped, $tempTTL );
if ( $valueIsCacheable ) {
$setOpts['lockTSE'] = $lockTSE;
+ $setOpts['staleTTL'] = $staleTTL;
// Use best known "since" timestamp if not provided
$setOpts += [ 'since' => $preCallbackTime ];
// Update the cache; this will fail if the key is tombstoned
*/
protected function getInterimValue( $key, $versioned, $minTime, &$asOf ) {
$wrapped = $this->cache->get( self::INTERIM_KEY_PREFIX . $key );
- list( $value ) = $this->unwrap( $wrapped, microtime( true ) );
+ list( $value ) = $this->unwrap( $wrapped, $this->getCurrentTime() );
if ( $value !== false && $this->isValid( $value, $versioned, $asOf, $minTime ) ) {
$asOf = $wrapped[self::FLD_TIME];
/**
* @see BagOStuff::makeKey()
- * @param string $keys,... Key component (starting with a key collection name)
+ * @param string $class Key class
+ * @param string $component [optional] Key component (starting with a key collection name)
* @return string Colon-delimited list of $keyspace followed by escaped components of $args
* @since 1.27
*/
- public function makeKey() {
+ public function makeKey( $class, $component = null ) {
return call_user_func_array( [ $this->cache, __FUNCTION__ ], func_get_args() );
}
/**
* @see BagOStuff::makeGlobalKey()
- * @param string $keys,... Key component (starting with a key collection name)
+ * @param string $class Key class
+ * @param string $component [optional] Key component (starting with a key collection name)
* @return string Colon-delimited list of $keyspace followed by escaped components of $args
* @since 1.27
*/
- public function makeGlobalKey() {
+ public function makeGlobalKey( $class, $component = null ) {
return call_user_func_array( [ $this->cache, __FUNCTION__ ], func_get_args() );
}
* $ttl = $cache->adaptiveTTL( $mtime, $cache::TTL_DAY );
* @endcode
*
+ * Another use case is when there are no applicable "last modified" fields in the DB,
+ * and there are too many dependencies for explicit purges to be viable, and the rate of
+ * change to relevant content is unstable, and it is highly valued to have the cached value
+ * be as up-to-date as possible.
+ *
+ * Example usage:
+ * @code
+ * $query = "<some complex query>";
+ * $idListFromComplexQuery = $cache->getWithSetCallback(
+ * $cache->makeKey( 'complex-graph-query', $hashOfQuery ),
+ * GraphQueryClass::STARTING_TTL,
+ * function ( $oldValue, &$ttl, array &$setOpts, $oldAsOf ) use ( $query, $cache ) {
+ * $gdb = $this->getReplicaGraphDbConnection();
+ * // Account for any snapshot/replica DB lag
+ * $setOpts += GraphDatabase::getCacheSetOptions( $gdb );
+ *
+ * $newList = iterator_to_array( $gdb->query( $query ) );
+ * sort( $newList, SORT_NUMERIC ); // normalize
+ *
+ * $minTTL = GraphQueryClass::MIN_TTL;
+ * $maxTTL = GraphQueryClass::MAX_TTL;
+ * if ( $oldValue !== false ) {
+ * // Note that $oldAsOf is the last time this callback ran
+ * $ttl = ( $newList === $oldValue )
+ * // No change: cache for 150% of the age of $oldValue
+ * ? $cache->adaptiveTTL( $oldAsOf, $maxTTL, $minTTL, 1.5 )
+ * // Changed: cache for %50 of the age of $oldValue
+ * : $cache->adaptiveTTL( $oldAsOf, $maxTTL, $minTTL, .5 );
+ * }
+ *
+ * return $newList;
+ * },
+ * [
+ * // Keep stale values around for doing comparisons for TTL calculations.
+ * // High values improve long-tail keys hit-rates, though might waste space.
+ * 'staleTTL' => GraphQueryClass::GRACE_TTL
+ * ]
+ * );
+ * @endcode
+ *
* @param int|float $mtime UNIX timestamp
* @param int $maxTTL Maximum TTL (seconds)
* @param int $minTTL Minimum TTL (seconds); Default: 30
return $minTTL; // no last-modified time provided
}
- $age = time() - $mtime;
+ $age = $this->getCurrentTime() - $mtime;
return (int)min( $maxTTL, max( $minTTL, $factor * $age ) );
}
if ( $this->purgeRelayer instanceof EventRelayerNull ) {
// This handles the mcrouter and the single-DC case
$ok = $this->cache->set( $key,
- $this->makePurgeValue( microtime( true ), self::HOLDOFF_NONE ),
+ $this->makePurgeValue( $this->getCurrentTime(), self::HOLDOFF_NONE ),
$ttl
);
} else {
* @return bool
*/
protected function worthRefreshExpiring( $curTTL, $lowTTL ) {
- if ( $curTTL >= $lowTTL ) {
+ if ( $lowTTL <= 0 ) {
+ return false;
+ } elseif ( $curTTL >= $lowTTL ) {
return false;
} elseif ( $curTTL <= 0 ) {
return true;
* @return bool
*/
protected function worthRefreshPopular( $asOf, $ageNew, $timeTillRefresh, $now ) {
+ if ( $ageNew < 0 || $timeTillRefresh <= 0 ) {
+ return false;
+ }
+
$age = $now - $asOf;
$timeOld = $age - $ageNew;
if ( $timeOld <= 0 ) {
return isset( $parts[1] ) ? $parts[1] : $parts[0]; // sanity
}
+ /**
+ * @return float UNIX timestamp
+ * @codeCoverageIgnore
+ */
+ protected function getCurrentTime() {
+ return microtime( true );
+ }
+
/**
* @param string $value Wrapped value like "PURGED:<timestamp>:<holdoff>"
* @return array|bool Array containing a UNIX timestamp (float) and holdoff period (integer),