WANObjectCache.php

Go to the documentation of this file.

<?php
use Liuggio\StatsdClient\Factory\StatsdDataFactoryInterface;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

class WANObjectCache implements IExpiringStore, IStoreKeyEncoder, LoggerAwareInterface {
    protected $cache;
    protected $processCaches = [];
    protected $logger;
    protected $stats;
    protected $asyncHandler;

    protected $mcrouterAware;
    protected $region;
    protected $cluster;
    protected $useInterimHoldOffCaching = true;
    protected $epoch;
    protected $secret;

    private $callbackDepth = 0;
    private $warmupCache = [];
    private $warmupKeyMisses = 0;

    private $wallClockOverride;

    const MAX_COMMIT_DELAY = 3;
    const MAX_READ_LAG = 7;
    const HOLDOFF_TTL = self::MAX_COMMIT_DELAY + self::MAX_READ_LAG + 1;

    const TTL_UNCACHEABLE = -1;

    const LOW_TTL = 30;
    const TTL_LAGGED = 30;

    const HOT_TTR = 900;
    const AGE_NEW = 60;

    const TSE_NONE = -1;

    const STALE_TTL_NONE = 0;
    const GRACE_TTL_NONE = 0;
    const HOLDOFF_TTL_NONE = 0;
    const HOLDOFF_NONE = self::HOLDOFF_TTL_NONE;

    const MIN_TIMESTAMP_NONE = 0.0;

    const PC_PRIMARY = 'primary:1000';

    const PASS_BY_REF = -1;

    private static $CHECK_KEY_TTL = self::TTL_YEAR;
    private static $INTERIM_KEY_TTL = 1;

    private static $LOCK_TTL = 10;
    private static $COOLOFF_TTL = 1;
    private static $RAMPUP_TTL = 30;

    private static $TINY_NEGATIVE = -0.000001;
    private static $TINY_POSTIVE = 0.000001;

    private static $SET_DELAY_HIGH_MS = 50;
    private static $RECENT_SET_LOW_MS = 50;
    private static $RECENT_SET_HIGH_MS = 100;

    private static $GENERATION_SLOW_SEC = 3;

    private static $PURGE_TIME = 0;
    private static $PURGE_HOLDOFF = 1;

    private static $VERSION = 1;

    private static $FLD_FORMAT_VERSION = 0;
    private static $FLD_VALUE = 1;
    private static $FLD_TTL = 2;
    private static $FLD_TIME = 3;
    private static  $FLD_FLAGS = 4;
    private static $FLD_VALUE_VERSION = 5;
    private static $FLD_GENERATION_TIME = 6;

    private static $VALUE_KEY_PREFIX = 'WANCache:v:';
    private static $INTERIM_KEY_PREFIX = 'WANCache:i:';
    private static $TIME_KEY_PREFIX = 'WANCache:t:';
    private static $MUTEX_KEY_PREFIX = 'WANCache:m:';
    private static $COOLOFF_KEY_PREFIX = 'WANCache:c:';

    private static $PURGE_VAL_PREFIX = 'PURGED:';

    public function __construct( array $params ) {
        $this->cache = $params['cache'];
        $this->region = $params['region'] ?? 'main';
        $this->cluster = $params['cluster'] ?? 'wan-main';
        $this->mcrouterAware = !empty( $params['mcrouterAware'] );
        $this->epoch = $params['epoch'] ?? 0;
        $this->secret = $params['secret'] ?? (string)$this->epoch;

        $this->setLogger( $params['logger'] ?? new NullLogger() );
        $this->stats = $params['stats'] ?? new NullStatsdDataFactory();
        $this->asyncHandler = $params['asyncHandler'] ?? null;
    }

    public function setLogger( LoggerInterface $logger ) {
        $this->logger = $logger;
    }

    public static function newEmpty() {
        return new static( [ 'cache' => new EmptyBagOStuff() ] );
    }

    final public function get(
        $key, &$curTTL = null, array $checkKeys = [], &$info = null
    ) {
        $curTTLs = self::PASS_BY_REF;
        $infoByKey = self::PASS_BY_REF;
        $values = $this->getMulti( [ $key ], $curTTLs, $checkKeys, $infoByKey );
        $curTTL = $curTTLs[$key] ?? null;
        if ( $info === self::PASS_BY_REF ) {
            $info = [
                'asOf' => $infoByKey[$key]['asOf'] ?? null,
                'tombAsOf' => $infoByKey[$key]['tombAsOf'] ?? null,
                'lastCKPurge' => $infoByKey[$key]['lastCKPurge'] ?? null,
                'version' => $infoByKey[$key]['version'] ?? null
            ];
        } else {
            $info = $infoByKey[$key]['asOf'] ?? null; // b/c
        }

        return $values[$key] ?? false;
    }

    final public function getMulti(
        array $keys,
        &$curTTLs = [],
        array $checkKeys = [],
        &$info = null
    ) {
        $result = [];
        $curTTLs = [];
        $infoByKey = [];

        $vPrefixLen = strlen( self::$VALUE_KEY_PREFIX );
        $valueKeys = self::prefixCacheKeys( $keys, self::$VALUE_KEY_PREFIX );

        $checkKeysForAll = [];
        $checkKeysByKey = [];
        $checkKeysFlat = [];
        foreach ( $checkKeys as $i => $checkKeyGroup ) {
            $prefixed = self::prefixCacheKeys( (array)$checkKeyGroup, self::$TIME_KEY_PREFIX );
            $checkKeysFlat = array_merge( $checkKeysFlat, $prefixed );
            // Are these check keys for a specific cache key, or for all keys being fetched?
            if ( is_int( $i ) ) {
                $checkKeysForAll = array_merge( $checkKeysForAll, $prefixed );
            } else {
                $checkKeysByKey[$i] = $prefixed;
            }
        }

        // Fetch all of the raw values
        $keysGet = array_merge( $valueKeys, $checkKeysFlat );
        if ( $this->warmupCache ) {
            $wrappedValues = array_intersect_key( $this->warmupCache, array_flip( $keysGet ) );
            $keysGet = array_diff( $keysGet, array_keys( $wrappedValues ) ); // keys left to fetch
            $this->warmupKeyMisses += count( $keysGet );
        } else {
            $wrappedValues = [];
        }
        if ( $keysGet ) {
            $wrappedValues += $this->cache->getMulti( $keysGet );
        }
        // Time used to compare/init "check" keys (derived after getMulti() to be pessimistic)
        $now = $this->getCurrentTime();

        // Collect timestamps from all "check" keys
        $purgeValuesForAll = $this->processCheckKeys( $checkKeysForAll, $wrappedValues, $now );
        $purgeValuesByKey = [];
        foreach ( $checkKeysByKey as $cacheKey => $checks ) {
            $purgeValuesByKey[$cacheKey] =
                $this->processCheckKeys( $checks, $wrappedValues, $now );
        }

        // Get the main cache value for each key and validate them
        foreach ( $valueKeys as $vKey ) {
            $key = substr( $vKey, $vPrefixLen ); // unprefix
            list( $value, $keyInfo ) = $this->unwrap( $wrappedValues[$vKey] ?? false, $now );
            // Force dependent keys to be seen as stale for a while after purging
            // to reduce race conditions involving stale data getting cached
            $purgeValues = $purgeValuesForAll;
            if ( isset( $purgeValuesByKey[$key] ) ) {
                $purgeValues = array_merge( $purgeValues, $purgeValuesByKey[$key] );
            }

            $lastCKPurge = null; // timestamp of the highest check key
            foreach ( $purgeValues as $purge ) {
                $lastCKPurge = max( $purge[self::$PURGE_TIME], $lastCKPurge );
                $safeTimestamp = $purge[self::$PURGE_TIME] + $purge[self::$PURGE_HOLDOFF];
                if ( $value !== false && $safeTimestamp >= $keyInfo['asOf'] ) {
                    // How long ago this value was invalidated by *this* check key
                    $ago = min( $purge[self::$PURGE_TIME] - $now, self::$TINY_NEGATIVE );
                    // How long ago this value was invalidated by *any* known check key
                    $keyInfo['curTTL'] = min( $keyInfo['curTTL'], $ago );
                }
            }
            $keyInfo[ 'lastCKPurge'] = $lastCKPurge;

            if ( $value !== false ) {
                $result[$key] = $value;
            }
            if ( $keyInfo['curTTL'] !== null ) {
                $curTTLs[$key] = $keyInfo['curTTL'];
            }

            $infoByKey[$key] = ( $info === self::PASS_BY_REF )
                ? $keyInfo
                : $keyInfo['asOf']; // b/c
        }

        $info = $infoByKey;

        return $result;
    }

    private function processCheckKeys( array $timeKeys, array $wrappedValues, $now ) {
        $purgeValues = [];
        foreach ( $timeKeys as $timeKey ) {
            $purge = isset( $wrappedValues[$timeKey] )
                ? $this->parsePurgeValue( $wrappedValues[$timeKey] )
                : false;
            if ( $purge === false ) {
                // Key is not set or malformed; regenerate
                $newVal = $this->makePurgeValue( $now, self::HOLDOFF_TTL );
                $this->cache->add( $timeKey, $newVal, self::$CHECK_KEY_TTL );
                $purge = $this->parsePurgeValue( $newVal );
            }
            $purgeValues[] = $purge;
        }

        return $purgeValues;
    }

    final public function set( $key, $value, $ttl = self::TTL_INDEFINITE, array $opts = [] ) {
        $now = $this->getCurrentTime();
        $lag = $opts['lag'] ?? 0;
        $age = isset( $opts['since'] ) ? max( 0, $now - $opts['since'] ) : 0;
        $pending = $opts['pending'] ?? false;
        $lockTSE = $opts['lockTSE'] ?? self::TSE_NONE;
        $staleTTL = $opts['staleTTL'] ?? self::STALE_TTL_NONE;
        $creating = $opts['creating'] ?? false;
        $version = $opts['version'] ?? null;
        $walltime = $opts['walltime'] ?? 0.0;

        if ( $ttl < 0 ) {
            return true;
        }

        // Do not cache potentially uncommitted data as it might get rolled back
        if ( $pending ) {
            $this->logger->info(
                'Rejected set() for {cachekey} due to pending writes.',
                [ 'cachekey' => $key ]
            );

            return true; // no-op the write for being unsafe
        }

        $logicalTTL = null; // logical TTL override
        // Check if there's a risk of writing stale data after the purge tombstone expired
        if ( $lag === false || ( $lag + $age ) > self::MAX_READ_LAG ) {
            // Case A: any long-running transaction
            if ( $age > self::MAX_READ_LAG ) {
                if ( $lockTSE >= 0 ) {
                    // Store value as *almost* stale to avoid cache and mutex stampedes
                    $logicalTTL = self::TTL_SECOND;
                    $this->logger->info(
                        'Lowered set() TTL for {cachekey} due to snapshot lag.',
                        [ 'cachekey' => $key, 'lag' => $lag, 'age' => $age ]
                    );
                } else {
                    $this->logger->info(
                        'Rejected set() for {cachekey} due to snapshot lag.',
                        [ 'cachekey' => $key, 'lag' => $lag, 'age' => $age ]
                    );

                    return true; // no-op the write for being unsafe
                }
            // Case B: high replication lag; lower TTL instead of ignoring all set()s
            } elseif ( $lag === false || $lag > self::MAX_READ_LAG ) {
                if ( $lockTSE >= 0 ) {
                    $logicalTTL = min( $ttl ?: INF, self::TTL_LAGGED );
                } else {
                    $ttl = min( $ttl ?: INF, self::TTL_LAGGED );
                }
                $this->logger->warning(
                    'Lowered set() TTL for {cachekey} due to replication lag.',
                    [ 'cachekey' => $key, 'lag' => $lag, 'age' => $age ]
                );
            // Case C: medium length request with medium replication lag
            } elseif ( $lockTSE >= 0 ) {
                // Store value as *almost* stale to avoid cache and mutex stampedes
                $logicalTTL = self::TTL_SECOND;
                $this->logger->info(
                    'Lowered set() TTL for {cachekey} due to high read lag.',
                    [ 'cachekey' => $key, 'lag' => $lag, 'age' => $age ]
                );
            } else {
                $this->logger->info(
                    'Rejected set() for {cachekey} due to high read lag.',
                    [ 'cachekey' => $key, 'lag' => $lag, 'age' => $age ]
                );

                return true; // no-op the write for being unsafe
            }
        }

        // Wrap that value with time/TTL/version metadata
        $wrapped = $this->wrap( $value, $logicalTTL ?: $ttl, $version, $now, $walltime );
        $storeTTL = $ttl + $staleTTL;

        if ( $creating ) {
            $ok = $this->cache->add( self::$VALUE_KEY_PREFIX . $key, $wrapped, $storeTTL );
        } else {
            $ok = $this->cache->merge(
                self::$VALUE_KEY_PREFIX . $key,
                function ( $cache, $key, $cWrapped ) use ( $wrapped ) {
                    // A string value means that it is a tombstone; do nothing in that case
                    return ( is_string( $cWrapped ) ) ? false : $wrapped;
                },
                $storeTTL,
                1 // 1 attempt
            );
        }

        return $ok;
    }

    final public function delete( $key, $ttl = self::HOLDOFF_TTL ) {
        if ( $ttl <= 0 ) {
            // Publish the purge to all datacenters
            $ok = $this->relayDelete( self::$VALUE_KEY_PREFIX . $key );
        } else {
            // Publish the purge to all datacenters
            $ok = $this->relayPurge( self::$VALUE_KEY_PREFIX . $key, $ttl, self::HOLDOFF_TTL_NONE );
        }

        $kClass = $this->determineKeyClassForStats( $key );
        $this->stats->increment( "wanobjectcache.$kClass.delete." . ( $ok ? 'ok' : 'error' ) );

        return $ok;
    }

    final public function getCheckKeyTime( $key ) {
        return $this->getMultiCheckKeyTime( [ $key ] )[$key];
    }

    final public function getMultiCheckKeyTime( array $keys ) {
        $rawKeys = [];
        foreach ( $keys as $key ) {
            $rawKeys[$key] = self::$TIME_KEY_PREFIX . $key;
        }

        $rawValues = $this->cache->getMulti( $rawKeys );
        $rawValues += array_fill_keys( $rawKeys, false );

        $times = [];
        foreach ( $rawKeys as $key => $rawKey ) {
            $purge = $this->parsePurgeValue( $rawValues[$rawKey] );
            if ( $purge !== false ) {
                $time = $purge[self::$PURGE_TIME];
            } else {
                // Casting assures identical floats for the next getCheckKeyTime() calls
                $now = (string)$this->getCurrentTime();
                $this->cache->add(
                    $rawKey,
                    $this->makePurgeValue( $now, self::HOLDOFF_TTL ),
                    self::$CHECK_KEY_TTL
                );
                $time = (float)$now;
            }

            $times[$key] = $time;
        }

        return $times;
    }

    final public function touchCheckKey( $key, $holdoff = self::HOLDOFF_TTL ) {
        // Publish the purge to all datacenters
        $ok = $this->relayPurge( self::$TIME_KEY_PREFIX . $key, self::$CHECK_KEY_TTL, $holdoff );

        $kClass = $this->determineKeyClassForStats( $key );
        $this->stats->increment( "wanobjectcache.$kClass.ck_touch." . ( $ok ? 'ok' : 'error' ) );

        return $ok;
    }

    final public function resetCheckKey( $key ) {
        // Publish the purge to all datacenters
        $ok = $this->relayDelete( self::$TIME_KEY_PREFIX . $key );

        $kClass = $this->determineKeyClassForStats( $key );
        $this->stats->increment( "wanobjectcache.$kClass.ck_reset." . ( $ok ? 'ok' : 'error' ) );

        return $ok;
    }

    final public function getWithSetCallback( $key, $ttl, $callback, array $opts = [] ) {
        $version = $opts['version'] ?? null;
        $pcTTL = $opts['pcTTL'] ?? self::TTL_UNCACHEABLE;
        $pCache = ( $pcTTL >= 0 )
            ? $this->getProcessCache( $opts['pcGroup'] ?? self::PC_PRIMARY )
            : null;

        // Use the process cache if requested as long as no outer cache callback is running.
        // Nested callback process cache use is not lag-safe with regard to HOLDOFF_TTL since
        // process cached values are more lagged than persistent ones as they are not purged.
        if ( $pCache && $this->callbackDepth == 0 ) {
            $cached = $pCache->get( $this->getProcessCacheKey( $key, $version ), INF, false );
            if ( $cached !== false ) {
                return $cached;
            }
        }

        $res = $this->fetchOrRegenerate( $key, $ttl, $callback, $opts );
        list( $value, $valueVersion, $curAsOf ) = $res;
        if ( $valueVersion !== $version ) {
            // Current value has a different version; use the variant key for this version.
            // Regenerate the variant value if it is not newer than the main value at $key
            // so that purges to the main key propagate to the variant value.
            list( $value ) = $this->fetchOrRegenerate(
                $this->makeGlobalKey( 'WANCache-key-variant', md5( $key ), $version ),
                $ttl,
                $callback,
                [ 'version' => null, 'minAsOf' => $curAsOf ] + $opts
            );
        }

        // Update the process cache if enabled
        if ( $pCache && $value !== false ) {
            $pCache->set( $this->getProcessCacheKey( $key, $version ), $value );
        }

        return $value;
    }

    private function fetchOrRegenerate( $key, $ttl, $callback, array $opts ) {
        $checkKeys = $opts['checkKeys'] ?? [];
        $graceTTL = $opts['graceTTL'] ?? self::GRACE_TTL_NONE;
        $minAsOf = $opts['minAsOf'] ?? self::MIN_TIMESTAMP_NONE;
        $hotTTR = $opts['hotTTR'] ?? self::HOT_TTR;
        $lowTTL = $opts['lowTTL'] ?? min( self::LOW_TTL, $ttl );
        $ageNew = $opts['ageNew'] ?? self::AGE_NEW;
        $touchedCb = $opts['touchedCallback'] ?? null;
        $initialTime = $this->getCurrentTime();

        $kClass = $this->determineKeyClassForStats( $key );

        // Get the current key value and its metadata
        $curTTL = self::PASS_BY_REF;
        $curInfo = self::PASS_BY_REF; 
        $curValue = $this->get( $key, $curTTL, $checkKeys, $curInfo );
        // Apply any $touchedCb invalidation timestamp to get the "last purge timestamp"
        list( $curTTL, $LPT ) = $this->resolveCTL( $curValue, $curTTL, $curInfo, $touchedCb );
        // Use the cached value if it exists and is not due for synchronous regeneration
        if (
            $this->isValid( $curValue, $curInfo['asOf'], $minAsOf ) &&
            $this->isAliveOrInGracePeriod( $curTTL, $graceTTL )
        ) {
            $preemptiveRefresh = (
                $this->worthRefreshExpiring( $curTTL, $lowTTL ) ||
                $this->worthRefreshPopular( $curInfo['asOf'], $ageNew, $hotTTR, $initialTime )
            );
            if ( !$preemptiveRefresh ) {
                $this->stats->increment( "wanobjectcache.$kClass.hit.good" );

                return [ $curValue, $curInfo['version'], $curInfo['asOf'] ];
            } elseif ( $this->scheduleAsyncRefresh( $key, $ttl, $callback, $opts ) ) {
                $this->stats->increment( "wanobjectcache.$kClass.hit.refresh" );

                return [ $curValue, $curInfo['version'], $curInfo['asOf'] ];
            }
        }

        // Determine if there is stale or volatile cached value that is still usable
        $isKeyTombstoned = ( $curInfo['tombAsOf'] !== null );
        if ( $isKeyTombstoned ) {
            // Key is write-holed; use the (volatile) interim key as an alternative
            list( $possValue, $possInfo ) = $this->getInterimValue( $key, $minAsOf );
            // Update the "last purge time" since the $touchedCb timestamp depends on $value
            $LPT = $this->resolveTouched( $possValue, $LPT, $touchedCb );
        } else {
            $possValue = $curValue;
            $possInfo = $curInfo;
        }

        // Avoid overhead from callback runs, regeneration locks, and cache sets during
        // hold-off periods for the key by reusing very recently generated cached values
        if (
            $this->isValid( $possValue, $possInfo['asOf'], $minAsOf, $LPT ) &&
            $this->isVolatileValueAgeNegligible( $initialTime - $possInfo['asOf'] )
        ) {
            $this->stats->increment( "wanobjectcache.$kClass.hit.volatile" );

            return [ $possValue, $possInfo['version'], $curInfo['asOf'] ];
        }

        $lockTSE = $opts['lockTSE'] ?? self::TSE_NONE;
        $busyValue = $opts['busyValue'] ?? null;
        $staleTTL = $opts['staleTTL'] ?? self::STALE_TTL_NONE;
        $version = $opts['version'] ?? null;

        // Determine whether one thread per datacenter should handle regeneration at a time
        $useRegenerationLock =
            // Note that since tombstones no-op set(), $lockTSE and $curTTL cannot be used to
            // deduce the key hotness because |$curTTL| will always keep increasing until the
            // tombstone expires or is overwritten by a new tombstone. Also, even if $lockTSE
            // is not set, constant regeneration of a key for the tombstone lifetime might be
            // very expensive. Assume tombstoned keys are possibly hot in order to reduce
            // the risk of high regeneration load after the delete() method is called.
            $isKeyTombstoned ||
            // Assume a key is hot if requested soon ($lockTSE seconds) after invalidation.
            // This avoids stampedes when timestamps from $checkKeys/$touchedCb bump.
            ( $curTTL !== null && $curTTL <= 0 && abs( $curTTL ) <= $lockTSE ) ||
            // Assume a key is hot if there is no value and a busy fallback is given.
            // This avoids stampedes on eviction or preemptive regeneration taking too long.
            ( $busyValue !== null && $possValue === false );

        // If a regeneration lock is required, threads that do not get the lock will try to use
        // the stale value, the interim value, or the $busyValue placeholder, in that order. If
        // none of those are set then all threads will bypass the lock and regenerate the value.
        $hasLock = $useRegenerationLock && $this->claimStampedeLock( $key );
        if ( $useRegenerationLock && !$hasLock ) {
            if ( $this->isValid( $possValue, $possInfo['asOf'], $minAsOf ) ) {
                $this->stats->increment( "wanobjectcache.$kClass.hit.stale" );

                return [ $possValue, $possInfo['version'], $curInfo['asOf'] ];
            } elseif ( $busyValue !== null ) {
                $miss = is_infinite( $minAsOf ) ? 'renew' : 'miss';
                $this->stats->increment( "wanobjectcache.$kClass.$miss.busy" );

                return [ $this->resolveBusyValue( $busyValue ), $version, $curInfo['asOf'] ];
            }
        }

        // Generate the new value given any prior value with a matching version
        $setOpts = [];
        $preCallbackTime = $this->getCurrentTime();
        ++$this->callbackDepth;
        try {
            $value = $callback(
                ( $curInfo['version'] === $version ) ? $curValue : false,
                $ttl,
                $setOpts,
                ( $curInfo['version'] === $version ) ? $curInfo['asOf'] : null
            );
        } finally {
            --$this->callbackDepth;
        }
        $postCallbackTime = $this->getCurrentTime();

        // How long it took to fetch, validate, and generate the value
        $elapsed = max( $postCallbackTime - $initialTime, 0.0 );

        // Attempt to save the newly generated value if applicable
        if (
            // Callback yielded a cacheable value
            ( $value !== false && $ttl >= 0 ) &&
            // Current thread was not raced out of a regeneration lock or key is tombstoned
            ( !$useRegenerationLock || $hasLock || $isKeyTombstoned ) &&
            // Key does not appear to be undergoing a set() stampede
            $this->checkAndSetCooloff( $key, $kClass, $elapsed, $lockTSE, $hasLock )
        ) {
            // How long it took to generate the value
            $walltime = max( $postCallbackTime - $preCallbackTime, 0.0 );
            $this->stats->timing( "wanobjectcache.$kClass.regen_walltime", 1e3 * $walltime );
            // If the key is write-holed then use the (volatile) interim key as an alternative
            if ( $isKeyTombstoned ) {
                $this->setInterimValue( $key, $value, $lockTSE, $version, $walltime );
            } else {
                $finalSetOpts = [
                    'since' => $setOpts['since'] ?? $preCallbackTime,
                    'version' => $version,
                    'staleTTL' => $staleTTL,
                    'lockTSE' => $lockTSE, // informs lag vs performance trade-offs
                    'creating' => ( $curValue === false ), // optimization
                    'walltime' => $walltime
                ] + $setOpts;
                $this->set( $key, $value, $ttl, $finalSetOpts );
            }
        }

        $this->yieldStampedeLock( $key, $hasLock );

        $miss = is_infinite( $minAsOf ) ? 'renew' : 'miss';
        $this->stats->increment( "wanobjectcache.$kClass.$miss.compute" );

        return [ $value, $version, $curInfo['asOf'] ];
    }

    private function claimStampedeLock( $key ) {
        // Note that locking is not bypassed due to I/O errors; this avoids stampedes
        return $this->cache->add( self::$MUTEX_KEY_PREFIX . $key, 1, self::$LOCK_TTL );
    }

    private function yieldStampedeLock( $key, $hasLock ) {
        if ( $hasLock ) {
            // The backend might be a mcrouter proxy set to broadcast DELETE to *all* the local
            // datacenter cache servers via OperationSelectorRoute (for increased consistency).
            // Since that would be excessive for these locks, use TOUCH to expire the key.
            $this->cache->changeTTL( self::$MUTEX_KEY_PREFIX . $key, $this->getCurrentTime() - 60 );
        }
    }

    private function isVolatileValueAgeNegligible( $age ) {
        return ( $age < mt_rand( self::$RECENT_SET_LOW_MS, self::$RECENT_SET_HIGH_MS ) / 1e3 );
    }

    private function checkAndSetCooloff( $key, $kClass, $elapsed, $lockTSE, $hasLock ) {
        $this->stats->timing( "wanobjectcache.$kClass.regen_set_delay", 1e3 * $elapsed );

        // If $lockTSE is set, the lock was bypassed because there was no stale/interim value,
        // and $elapsed indicates that regeration is slow, then there is a risk of set()
        // stampedes with large blobs. With a typical scale-out infrastructure, CPU and query
        // load from $callback invocations is distributed among appservers and replica DBs,
        // but cache operations for a given key route to a single cache server (e.g. striped
        // consistent hashing).
        if ( $lockTSE < 0 || $hasLock ) {
            return true; // either not a priori hot or thread has the lock
        } elseif ( $elapsed <= self::$SET_DELAY_HIGH_MS * 1e3 ) {
            return true; // not enough time for threads to pile up
        }

        $this->cache->clearLastError();
        if (
            !$this->cache->add( self::$COOLOFF_KEY_PREFIX . $key, 1, self::$COOLOFF_TTL ) &&
            // Don't treat failures due to I/O errors as the key being in cooloff
            $this->cache->getLastError() === BagOStuff::ERR_NONE
        ) {
            $this->stats->increment( "wanobjectcache.$kClass.cooloff_bounce" );

            return false;
        }

        return true;
    }

    private function resolveCTL( $value, $curTTL, $curInfo, $touchedCallback ) {
        if ( $touchedCallback === null || $value === false ) {
            return [ $curTTL, max( $curInfo['tombAsOf'], $curInfo['lastCKPurge'] ) ];
        }

        $touched = $touchedCallback( $value );
        if ( $touched !== null && $touched >= $curInfo['asOf'] ) {
            $curTTL = min( $curTTL, self::$TINY_NEGATIVE, $curInfo['asOf'] - $touched );
        }

        return [ $curTTL, max( $curInfo['tombAsOf'], $curInfo['lastCKPurge'], $touched ) ];
    }

    private function resolveTouched( $value, $lastPurge, $touchedCallback ) {
        return ( $touchedCallback === null || $value === false )
            ? $lastPurge // nothing to derive the "touched timestamp" from
            : max( $touchedCallback( $value ), $lastPurge );
    }

    private function getInterimValue( $key, $minAsOf ) {
        $now = $this->getCurrentTime();

        if ( $this->useInterimHoldOffCaching ) {
            $wrapped = $this->cache->get( self::$INTERIM_KEY_PREFIX . $key );

            list( $value, $keyInfo ) = $this->unwrap( $wrapped, $now );
            if ( $this->isValid( $value, $keyInfo['asOf'], $minAsOf ) ) {
                return [ $value, $keyInfo ];
            }
        }

        return $this->unwrap( false, $now );
    }

    private function setInterimValue( $key, $value, $ttl, $version, $walltime ) {
        $ttl = max( self::$INTERIM_KEY_TTL, (int)$ttl );

        $wrapped = $this->wrap( $value, $ttl, $version, $this->getCurrentTime(), $walltime );
        $this->cache->merge(
            self::$INTERIM_KEY_PREFIX . $key,
            function () use ( $wrapped ) {
                return $wrapped;
            },
            $ttl,
            1
        );
    }

    private function resolveBusyValue( $busyValue ) {
        return ( $busyValue instanceof Closure ) ? $busyValue() : $busyValue;
    }

    final public function getMultiWithSetCallback(
        ArrayIterator $keyedIds, $ttl, callable $callback, array $opts = []
    ) {
        // Load required keys into process cache in one go
        $this->warmupCache = $this->getRawKeysForWarmup(
            $this->getNonProcessCachedMultiKeys( $keyedIds, $opts ),
            $opts['checkKeys'] ?? []
        );
        $this->warmupKeyMisses = 0;

        // Wrap $callback to match the getWithSetCallback() format while passing $id to $callback
        $id = null; // current entity ID
        $func = function ( $oldValue, &$ttl, &$setOpts, $oldAsOf ) use ( $callback, &$id ) {
            return $callback( $id, $oldValue, $ttl, $setOpts, $oldAsOf );
        };

        $values = [];
        foreach ( $keyedIds as $key => $id ) { // preserve order
            $values[$key] = $this->getWithSetCallback( $key, $ttl, $func, $opts );
        }

        $this->warmupCache = [];

        return $values;
    }

    final public function getMultiWithUnionSetCallback(
        ArrayIterator $keyedIds, $ttl, callable $callback, array $opts = []
    ) {
        $checkKeys = $opts['checkKeys'] ?? [];
        unset( $opts['lockTSE'] ); // incompatible
        unset( $opts['busyValue'] ); // incompatible

        // Load required keys into process cache in one go
        $keysByIdGet = $this->getNonProcessCachedMultiKeys( $keyedIds, $opts );
        $this->warmupCache = $this->getRawKeysForWarmup( $keysByIdGet, $checkKeys );
        $this->warmupKeyMisses = 0;

        // IDs of entities known to be in need of regeneration
        $idsRegen = [];

        // Find out which keys are missing/deleted/stale
        $curTTLs = [];
        $asOfs = [];
        $curByKey = $this->getMulti( $keysByIdGet, $curTTLs, $checkKeys, $asOfs );
        foreach ( $keysByIdGet as $id => $key ) {
            if ( !array_key_exists( $key, $curByKey ) || $curTTLs[$key] < 0 ) {
                $idsRegen[] = $id;
            }
        }

        // Run the callback to populate the regeneration value map for all required IDs
        $newSetOpts = [];
        $newTTLsById = array_fill_keys( $idsRegen, $ttl );
        $newValsById = $idsRegen ? $callback( $idsRegen, $newTTLsById, $newSetOpts ) : [];

        // Wrap $callback to match the getWithSetCallback() format while passing $id to $callback
        $id = null; // current entity ID
        $func = function ( $oldValue, &$ttl, &$setOpts, $oldAsOf )
            use ( $callback, &$id, $newValsById, $newTTLsById, $newSetOpts )
        {
            if ( array_key_exists( $id, $newValsById ) ) {
                // Value was already regerated as expected, so use the value in $newValsById
                $newValue = $newValsById[$id];
                $ttl = $newTTLsById[$id];
                $setOpts = $newSetOpts;
            } else {
                // Pre-emptive/popularity refresh and version mismatch cases are not detected
                // above and thus $newValsById has no entry. Run $callback on this single entity.
                $ttls = [ $id => $ttl ];
                $newValue = $callback( [ $id ], $ttls, $setOpts )[$id];
                $ttl = $ttls[$id];
            }

            return $newValue;
        };

        // Run the cache-aside logic using warmupCache instead of persistent cache queries
        $values = [];
        foreach ( $keyedIds as $key => $id ) { // preserve order
            $values[$key] = $this->getWithSetCallback( $key, $ttl, $func, $opts );
        }

        $this->warmupCache = [];

        return $values;
    }

    final public function reap( $key, $purgeTimestamp, &$isStale = false ) {
        $minAsOf = $purgeTimestamp + self::HOLDOFF_TTL;
        $wrapped = $this->cache->get( self::$VALUE_KEY_PREFIX . $key );
        if ( is_array( $wrapped ) && $wrapped[self::$FLD_TIME] < $minAsOf ) {
            $isStale = true;
            $this->logger->warning( "Reaping stale value key '$key'." );
            $ttlReap = self::HOLDOFF_TTL; // avoids races with tombstone creation
            $ok = $this->cache->changeTTL( self::$VALUE_KEY_PREFIX . $key, $ttlReap );
            if ( !$ok ) {
                $this->logger->error( "Could not complete reap of key '$key'." );
            }

            return $ok;
        }

        $isStale = false;

        return true;
    }

    final public function reapCheckKey( $key, $purgeTimestamp, &$isStale = false ) {
        $purge = $this->parsePurgeValue( $this->cache->get( self::$TIME_KEY_PREFIX . $key ) );
        if ( $purge && $purge[self::$PURGE_TIME] < $purgeTimestamp ) {
            $isStale = true;
            $this->logger->warning( "Reaping stale check key '$key'." );
            $ok = $this->cache->changeTTL( self::$TIME_KEY_PREFIX . $key, self::TTL_SECOND );
            if ( !$ok ) {
                $this->logger->error( "Could not complete reap of check key '$key'." );
            }

            return $ok;
        }

        $isStale = false;

        return false;
    }

    public function makeKey( $class, ...$components ) {
        return $this->cache->makeKey( ...func_get_args() );
    }

    public function makeGlobalKey( $class, ...$components ) {
        return $this->cache->makeGlobalKey( ...func_get_args() );
    }

    public function hash256( $component ) {
        return hash_hmac( 'sha256', $component, $this->secret );
    }

    final public function makeMultiKeys( array $ids, $keyCallback ) {
        $idByKey = [];
        foreach ( $ids as $id ) {
            // Discourage triggering of automatic makeKey() hashing in some backends
            if ( strlen( $id ) > 64 ) {
                $this->logger->warning( __METHOD__ . ": long ID '$id'; use hash256()" );
            }
            $key = $keyCallback( $id, $this );
            // Edge case: ignore key collisions due to duplicate $ids like "42" and 42
            if ( !isset( $idByKey[$key] ) ) {
                $idByKey[$key] = $id;
            } elseif ( (string)$id !== (string)$idByKey[$key] ) {
                throw new UnexpectedValueException(
                    "Cache key collision; IDs ('$id','{$idByKey[$key]}') map to '$key'"
                );
            }
        }

        return new ArrayIterator( $idByKey );
    }

    final public function multiRemap( array $ids, array $res ) {
        if ( count( $ids ) !== count( $res ) ) {
            // If makeMultiKeys() is called on a list of non-unique IDs, then the resulting
            // ArrayIterator will have less entries due to "first appearance" de-duplication
            $ids = array_keys( array_flip( $ids ) );
            if ( count( $ids ) !== count( $res ) ) {
                throw new UnexpectedValueException( "Multi-key result does not match ID list" );
            }
        }

        return array_combine( $ids, $res );
    }

    final public function getLastError() {
        $code = $this->cache->getLastError();
        switch ( $code ) {
            case BagOStuff::ERR_NONE:
                return self::ERR_NONE;
            case BagOStuff::ERR_NO_RESPONSE:
                return self::ERR_NO_RESPONSE;
            case BagOStuff::ERR_UNREACHABLE:
                return self::ERR_UNREACHABLE;
            default:
                return self::ERR_UNEXPECTED;
        }
    }

    final public function clearLastError() {
        $this->cache->clearLastError();
    }

    public function clearProcessCache() {
        $this->processCaches = [];
    }

    final public function useInterimHoldOffCaching( $enabled ) {
        $this->useInterimHoldOffCaching = $enabled;
    }

    public function getQoS( $flag ) {
        return $this->cache->getQoS( $flag );
    }

    public function adaptiveTTL( $mtime, $maxTTL, $minTTL = 30, $factor = 0.2 ) {
        if ( is_float( $mtime ) || ctype_digit( $mtime ) ) {
            $mtime = (int)$mtime; // handle fractional seconds and string integers
        }

        if ( !is_int( $mtime ) || $mtime <= 0 ) {
            return $minTTL; // no last-modified time provided
        }

        $age = $this->getCurrentTime() - $mtime;

        return (int)min( $maxTTL, max( $minTTL, $factor * $age ) );
    }

    final public function getWarmupKeyMisses() {
        return $this->warmupKeyMisses;
    }

    protected function relayPurge( $key, $ttl, $holdoff ) {
        if ( $this->mcrouterAware ) {
            // See https://github.com/facebook/mcrouter/wiki/Multi-cluster-broadcast-setup
            // Wildcards select all matching routes, e.g. the WAN cluster on all DCs
            $ok = $this->cache->set(
                "/*/{$this->cluster}/{$key}",
                $this->makePurgeValue( $this->getCurrentTime(), $holdoff ),
                $ttl
            );
        } else {
            // Some other proxy handles broadcasting or there is only one datacenter
            $ok = $this->cache->set(
                $key,
                $this->makePurgeValue( $this->getCurrentTime(), $holdoff ),
                $ttl
            );
        }

        return $ok;
    }

    protected function relayDelete( $key ) {
        if ( $this->mcrouterAware ) {
            // See https://github.com/facebook/mcrouter/wiki/Multi-cluster-broadcast-setup
            // Wildcards select all matching routes, e.g. the WAN cluster on all DCs
            $ok = $this->cache->delete( "/*/{$this->cluster}/{$key}" );
        } else {
            // Some other proxy handles broadcasting or there is only one datacenter
            $ok = $this->cache->delete( $key );
        }

        return $ok;
    }

    private function scheduleAsyncRefresh( $key, $ttl, $callback, $opts ) {
        if ( !$this->asyncHandler ) {
            return false;
        }
        // Update the cache value later, such during post-send of an HTTP request
        $func = $this->asyncHandler;
        $func( function () use ( $key, $ttl, $callback, $opts ) {
            $opts['minAsOf'] = INF; // force a refresh
            $this->fetchOrRegenerate( $key, $ttl, $callback, $opts );
        } );

        return true;
    }

    private function isAliveOrInGracePeriod( $curTTL, $graceTTL ) {
        if ( $curTTL > 0 ) {
            return true;
        } elseif ( $graceTTL <= 0 ) {
            return false;
        }

        $ageStale = abs( $curTTL ); // seconds of staleness
        $curGTTL = ( $graceTTL - $ageStale ); // current grace-time-to-live
        if ( $curGTTL <= 0 ) {
            return false; //  already out of grace period
        }

        // Chance of using a stale value is the complement of the chance of refreshing it
        return !$this->worthRefreshExpiring( $curGTTL, $graceTTL );
    }

    protected function worthRefreshExpiring( $curTTL, $lowTTL ) {
        if ( $lowTTL <= 0 ) {
            return false;
        } elseif ( $curTTL >= $lowTTL ) {
            return false;
        } elseif ( $curTTL <= 0 ) {
            return false;
        }

        $chance = ( 1 - $curTTL / $lowTTL );

        return mt_rand( 1, 1e9 ) <= 1e9 * $chance;
    }

    protected function worthRefreshPopular( $asOf, $ageNew, $timeTillRefresh, $now ) {
        if ( $ageNew < 0 || $timeTillRefresh <= 0 ) {
            return false;
        }

        $age = $now - $asOf;
        $timeOld = $age - $ageNew;
        if ( $timeOld <= 0 ) {
            return false;
        }

        $popularHitsPerSec = 1;
        // Lifecycle is: new, ramp-up refresh chance, full refresh chance.
        // Note that the "expected # of refreshes" for the ramp-up time range is half
        // of what it would be if P(refresh) was at its full value during that time range.
        $refreshWindowSec = max( $timeTillRefresh - $ageNew - self::$RAMPUP_TTL / 2, 1 );
        // P(refresh) * (# hits in $refreshWindowSec) = (expected # of refreshes)
        // P(refresh) * ($refreshWindowSec * $popularHitsPerSec) = 1 (by definition)
        // P(refresh) = 1/($refreshWindowSec * $popularHitsPerSec)
        $chance = 1 / ( $popularHitsPerSec * $refreshWindowSec );

        // Ramp up $chance from 0 to its nominal value over RAMPUP_TTL seconds to avoid stampedes
        $chance *= ( $timeOld <= self::$RAMPUP_TTL ) ? $timeOld / self::$RAMPUP_TTL : 1;

        return mt_rand( 1, 1e9 ) <= 1e9 * $chance;
    }

    protected function isValid( $value, $asOf, $minAsOf, $purgeTime = null ) {
        // Avoid reading any key not generated after the latest delete() or touch
        $safeMinAsOf = max( $minAsOf, $purgeTime + self::$TINY_POSTIVE );

        if ( $value === false ) {
            return false;
        } elseif ( $safeMinAsOf > 0 && $asOf < $minAsOf ) {
            return false;
        }

        return true;
    }

    private function wrap( $value, $ttl, $version, $now, $walltime ) {
        // Returns keys in ascending integer order for PHP7 array packing:
        // https://nikic.github.io/2014/12/22/PHPs-new-hashtable-implementation.html
        $wrapped = [
            self::$FLD_FORMAT_VERSION => self::$VERSION,
            self::$FLD_VALUE => $value,
            self::$FLD_TTL => $ttl,
            self::$FLD_TIME => $now
        ];
        if ( $version !== null ) {
            $wrapped[self::$FLD_VALUE_VERSION] = $version;
        }
        if ( $walltime >= self::$GENERATION_SLOW_SEC ) {
            $wrapped[self::$FLD_GENERATION_TIME] = $walltime;
        }

        return $wrapped;
    }

    private function unwrap( $wrapped, $now ) {
        $value = false;
        $info = [ 'asOf' => null, 'curTTL' => null, 'version' => null, 'tombAsOf' => null ];

        if ( is_array( $wrapped ) ) {
            // Entry expected to be a cached value; validate it
            if (
                ( $wrapped[self::$FLD_FORMAT_VERSION] ?? null ) === self::$VERSION &&
                $wrapped[self::$FLD_TIME] >= $this->epoch
            ) {
                if ( $wrapped[self::$FLD_TTL] > 0 ) {
                    // Get the approximate time left on the key
                    $age = $now - $wrapped[self::$FLD_TIME];
                    $curTTL = max( $wrapped[self::$FLD_TTL] - $age, 0.0 );
                } else {
                    // Key had no TTL, so the time left is unbounded
                    $curTTL = INF;
                }
                $value = $wrapped[self::$FLD_VALUE];
                $info['version'] = $wrapped[self::$FLD_VALUE_VERSION] ?? null;
                $info['asOf'] = $wrapped[self::$FLD_TIME];
                $info['curTTL'] = $curTTL;
            }
        } else {
            // Entry expected to be a tombstone; parse it
            $purge = $this->parsePurgeValue( $wrapped );
            if ( $purge !== false ) {
                // Tombstoned keys should always have a negative current $ttl
                $info['curTTL'] = min( $purge[self::$PURGE_TIME] - $now, self::$TINY_NEGATIVE );
                $info['tombAsOf'] = $purge[self::$PURGE_TIME];
            }
        }

        return [ $value, $info ];
    }

    protected static function prefixCacheKeys( array $keys, $prefix ) {
        $res = [];
        foreach ( $keys as $key ) {
            $res[] = $prefix . $key;
        }

        return $res;
    }

    private function determineKeyClassForStats( $key ) {
        $parts = explode( ':', $key, 3 );

        return $parts[1] ?? $parts[0]; // sanity
    }

    private function parsePurgeValue( $value ) {
        if ( !is_string( $value ) ) {
            return false;
        }

        $segments = explode( ':', $value, 3 );
        if (
            !isset( $segments[0] ) ||
            !isset( $segments[1] ) ||
            "{$segments[0]}:" !== self::$PURGE_VAL_PREFIX
        ) {
            return false;
        }

        if ( !isset( $segments[2] ) ) {
            // Back-compat with old purge values without holdoff
            $segments[2] = self::HOLDOFF_TTL;
        }

        if ( $segments[1] < $this->epoch ) {
            // Values this old are ignored
            return false;
        }

        return [
            self::$PURGE_TIME => (float)$segments[1],
            self::$PURGE_HOLDOFF => (int)$segments[2],
        ];
    }

    private function makePurgeValue( $timestamp, $holdoff ) {
        return self::$PURGE_VAL_PREFIX . (float)$timestamp . ':' . (int)$holdoff;
    }

    private function getProcessCache( $group ) {
        if ( !isset( $this->processCaches[$group] ) ) {
            list( , $size ) = explode( ':', $group );
            $this->processCaches[$group] = new MapCacheLRU( (int)$size );
        }

        return $this->processCaches[$group];
    }

    private function getProcessCacheKey( $key, $version ) {
        return $key . ' ' . (int)$version;
    }

    private function getNonProcessCachedMultiKeys( ArrayIterator $keys, array $opts ) {
        $pcTTL = $opts['pcTTL'] ?? self::TTL_UNCACHEABLE;

        $keysMissing = [];
        if ( $pcTTL > 0 && $this->callbackDepth == 0 ) {
            $version = $opts['version'] ?? null;
            $pCache = $this->getProcessCache( $opts['pcGroup'] ?? self::PC_PRIMARY );
            foreach ( $keys as $key => $id ) {
                if ( !$pCache->has( $this->getProcessCacheKey( $key, $version ), $pcTTL ) ) {
                    $keysMissing[$id] = $key;
                }
            }
        }

        return $keysMissing;
    }

    private function getRawKeysForWarmup( array $keys, array $checkKeys ) {
        if ( !$keys ) {
            return [];
        }

        $keysWarmUp = [];
        // Get all the value keys to fetch...
        foreach ( $keys as $key ) {
            $keysWarmUp[] = self::$VALUE_KEY_PREFIX . $key;
        }
        // Get all the check keys to fetch...
        foreach ( $checkKeys as $i => $checkKeyOrKeys ) {
            if ( is_int( $i ) ) {
                // Single check key that applies to all value keys
                $keysWarmUp[] = self::$TIME_KEY_PREFIX . $checkKeyOrKeys;
            } else {
                // List of check keys that apply to value key $i
                $keysWarmUp = array_merge(
                    $keysWarmUp,
                    self::prefixCacheKeys( $checkKeyOrKeys, self::$TIME_KEY_PREFIX )
                );
            }
        }

        $warmupCache = $this->cache->getMulti( $keysWarmUp );
        $warmupCache += array_fill_keys( $keysWarmUp, false );

        return $warmupCache;
    }

    protected function getCurrentTime() {
        if ( $this->wallClockOverride ) {
            return $this->wallClockOverride;
        }

        $clockTime = (float)time(); // call this first
        // microtime() uses an initial gettimeofday() call added to usage clocks.
        // This can severely drift from time() and the microtime() value of other threads
        // due to undercounting of the amount of time elapsed. Instead of seeing the current
        // time as being in the past, use the value of time(). This avoids setting cache values
        // that will immediately be seen as expired and possibly cause stampedes.
        return max( microtime( true ), $clockTime );
    }

    public function setMockTime( &$time ) {
        $this->wallClockOverride =& $time;
        $this->cache->setMockTime( $time );
    }
}