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, LoggerAwareInterface {
    protected $cache;
    protected $processCaches = [];
    protected $purgeChannel;
    protected $purgeRelayer;
    protected $mcrouterAware;
    protected $region;
    protected $cluster;
    protected $logger;
    protected $stats;
    protected $useInterimHoldOffCaching = true;
    protected $asyncHandler;
    protected $epoch;
 
    protected $lastRelayError = self::ERR_NONE;
 
    private $callbackDepth = 0;
    private $warmupCache = [];
    private $warmupKeyMisses = 0;
 
    private $wallClockOverride;
 
    const MAX_COMMIT_DELAY = 3;
    const MAX_READ_LAG = 7;
    const HOLDOFF_TTL = 11; // MAX_COMMIT_DELAY + MAX_READ_LAG + 1
 
    const CHECK_KEY_TTL = self::TTL_YEAR;
    const INTERIM_KEY_TTL = 1;
 
    const LOCK_TTL = 10;
    const LOW_TTL = 30;
 
    const AGE_NEW = 60;
    const HOT_TTR = 900;
    const HIT_RATE_HIGH = 1;
    const RAMPUP_TTL = 30;
 
    const TTL_UNCACHEABLE = -1;
    const TSE_NONE = -1;
    const TTL_LAGGED = 30;
    const HOLDOFF_NONE = 0;
    const STALE_TTL_NONE = 0;
    const GRACE_TTL_NONE = 0;
 
    const MIN_TIMESTAMP_NONE = 0.0;
 
    const TINY_NEGATIVE = -0.000001;
 
    const VERSION = 1;
 
    const FLD_VERSION = 0; // key to cache version number
    const FLD_VALUE = 1; // key to the cached value
    const FLD_TTL = 2; // key to the original TTL
    const FLD_TIME = 3; // key to the cache time
    const FLD_FLAGS = 4; // key to the flags bitfield
    const FLD_HOLDOFF = 5; // key to any hold-off TTL
 
    const FLG_STALE = 1;
 
    const ERR_NONE = 0; // no error
    const ERR_NO_RESPONSE = 1; // no response
    const ERR_UNREACHABLE = 2; // can't connect
    const ERR_UNEXPECTED = 3; // response gave some error
    const ERR_RELAY = 4; // relay broadcast failed
 
    const VALUE_KEY_PREFIX = 'WANCache:v:';
    const INTERIM_KEY_PREFIX = 'WANCache:i:';
    const TIME_KEY_PREFIX = 'WANCache:t:';
    const MUTEX_KEY_PREFIX = 'WANCache:m:';
 
    const PURGE_VAL_PREFIX = 'PURGED:';
 
    const VFLD_DATA = 'WOC:d'; // key to the value of versioned data
    const VFLD_VERSION = 'WOC:v'; // key to the version of the value present
 
    const PC_PRIMARY = 'primary:1000'; // process cache name and max key count
 
    const DEFAULT_PURGE_CHANNEL = 'wancache-purge';
 
    public function __construct( array $params ) {
        $this->cache = $params['cache'];
        $this->purgeChannel = $params['channels']['purge'] ?? self::DEFAULT_PURGE_CHANNEL;
        $this->purgeRelayer = $params['relayers']['purge'] ?? new EventRelayerNull( [] );
        $this->region = $params['region'] ?? 'main';
        $this->cluster = $params['cluster'] ?? 'wan-main';
        $this->mcrouterAware = !empty( $params['mcrouterAware'] );
        $this->epoch = $params['epoch'] ?? 1.0;
 
        $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 = [], &$asOf = null ) {
        $curTTLs = [];
        $asOfs = [];
        $values = $this->getMulti( [ $key ], $curTTLs, $checkKeys, $asOfs );
        $curTTL = $curTTLs[$key] ?? null;
        $asOf = $asOfs[$key] ?? null;
 
        return $values[$key] ?? false;
    }
 
    final public function getMulti(
        array $keys, &$curTTLs = [], array $checkKeys = [], array &$asOfs = []
    ) {
        $result = [];
        $curTTLs = [];
        $asOfs = [];
 
        $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 );
            // Is this 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] = isset( $checkKeysByKey[$i] )
                    ? array_merge( $checkKeysByKey[$i], $prefixed )
                    : $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 ) {
            if ( !isset( $wrappedValues[$vKey] ) ) {
                continue; // not found
            }
 
            $key = substr( $vKey, $vPrefixLen ); // unprefix
 
            list( $value, $curTTL ) = $this->unwrap( $wrappedValues[$vKey], $now );
            if ( $value !== false ) {
                $result[$key] = $value;
                // 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] );
                }
                foreach ( $purgeValues as $purge ) {
                    $safeTimestamp = $purge[self::FLD_TIME] + $purge[self::FLD_HOLDOFF];
                    if ( $safeTimestamp >= $wrappedValues[$vKey][self::FLD_TIME] ) {
                        // How long ago this value was invalidated by *this* check key
                        $ago = min( $purge[self::FLD_TIME] - $now, self::TINY_NEGATIVE );
                        // How long ago this value was invalidated by *any* known check key
                        $curTTL = min( $curTTL, $ago );
                    }
                }
            }
            $curTTLs[$key] = $curTTL;
            $asOfs[$key] = ( $value !== false ) ? $wrappedValues[$vKey][self::FLD_TIME] : null;
        }
 
        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 = 0, array $opts = [] ) {
        $now = $this->getCurrentTime();
        $lockTSE = $opts['lockTSE'] ?? self::TSE_NONE;
        $staleTTL = $opts['staleTTL'] ?? self::STALE_TTL_NONE;
        $age = isset( $opts['since'] ) ? max( 0, $now - $opts['since'] ) : 0;
        $lag = $opts['lag'] ?? 0;
 
        // Do not cache potentially uncommitted data as it might get rolled back
        if ( !empty( $opts['pending'] ) ) {
            $this->logger->info( 'Rejected set() for {cachekey} due to pending writes.',
                [ 'cachekey' => $key ] );
 
            return true; // no-op the write for being unsafe
        }
 
        $wrapExtra = []; // additional wrapped value fields
        // 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: read lag with "lockTSE"; save but record value as stale
            if ( $lockTSE >= 0 ) {
                $ttl = max( 1, (int)$lockTSE ); // set() expects seconds
                $wrapExtra[self::FLD_FLAGS] = self::FLG_STALE; // mark as stale
            // Case B: any long-running transaction; ignore this set()
            } elseif ( $age > self::MAX_READ_LAG ) {
                $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 C: high replication lag; lower TTL instead of ignoring all set()s
            } elseif ( $lag === false || $lag > self::MAX_READ_LAG ) {
                $ttl = $ttl ? min( $ttl, self::TTL_LAGGED ) : self::TTL_LAGGED;
                $this->logger->warning( 'Lowered set() TTL for {cachekey} due to replication lag.',
                    [ 'cachekey' => $key, 'lag' => $lag, 'age' => $age ] );
            // Case D: medium length request with medium replication lag; ignore this set()
            } 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, $ttl, $now ) + $wrapExtra;
 
        $func = function ( $cache, $key, $cWrapped ) use ( $wrapped ) {
            return ( is_string( $cWrapped ) )
                ? false // key is tombstoned; do nothing
                : $wrapped;
        };
 
        return $this->cache->merge( self::VALUE_KEY_PREFIX . $key, $func, $ttl + $staleTTL, 1 );
    }
 
    final public function delete( $key, $ttl = self::HOLDOFF_TTL ) {
        $key = self::VALUE_KEY_PREFIX . $key;
 
        if ( $ttl <= 0 ) {
            // Publish the purge to all datacenters
            $ok = $this->relayDelete( $key );
        } else {
            // Publish the purge to all datacenters
            $ok = $this->relayPurge( $key, $ttl, self::HOLDOFF_NONE );
        }
 
        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::FLD_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
        return $this->relayPurge( self::TIME_KEY_PREFIX . $key, self::CHECK_KEY_TTL, $holdoff );
    }
 
    final public function resetCheckKey( $key ) {
        // Publish the purge to all datacenters
        return $this->relayDelete( self::TIME_KEY_PREFIX . $key );
    }
 
    final public function getWithSetCallback( $key, $ttl, $callback, array $opts = [] ) {
        $pcTTL = $opts['pcTTL'] ?? self::TTL_UNCACHEABLE;
 
        // Try the process cache if enabled and the cache callback is not within a cache callback.
        // Process cache use in nested callbacks is not lag-safe with regard to HOLDOFF_TTL since
        // the in-memory value is further lagged than the shared one since it uses a blind TTL.
        if ( $pcTTL >= 0 && $this->callbackDepth == 0 ) {
            $group = $opts['pcGroup'] ?? self::PC_PRIMARY;
            $procCache = $this->getProcessCache( $group );
            $value = $procCache->has( $key, $pcTTL ) ? $procCache->get( $key ) : false;
        } else {
            $procCache = false;
            $value = false;
        }
 
        if ( $value === false ) {
            // Fetch the value over the network
            if ( isset( $opts['version'] ) ) {
                $version = $opts['version'];
                $asOf = null;
                $cur = $this->doGetWithSetCallback(
                    $key,
                    $ttl,
                    function ( $oldValue, &$ttl, &$setOpts, $oldAsOf )
                    use ( $callback, $version ) {
                        if ( is_array( $oldValue )
                            && array_key_exists( self::VFLD_DATA, $oldValue )
                            && array_key_exists( self::VFLD_VERSION, $oldValue )
                            && $oldValue[self::VFLD_VERSION] === $version
                        ) {
                            $oldData = $oldValue[self::VFLD_DATA];
                        } else {
                            // VFLD_DATA is not set if an old, unversioned, key is present
                            $oldData = false;
                            $oldAsOf = null;
                        }
 
                        return [
                            self::VFLD_DATA => $callback( $oldData, $ttl, $setOpts, $oldAsOf ),
                            self::VFLD_VERSION => $version
                        ];
                    },
                    $opts,
                    $asOf
                );
                if ( $cur[self::VFLD_VERSION] === $version ) {
                    // Value created or existed before with version; use it
                    $value = $cur[self::VFLD_DATA];
                } else {
                    // 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(
                        $this->makeGlobalKey( 'WANCache-key-variant', md5( $key ), $version ),
                        $ttl,
                        $callback,
                        // Regenerate value if not newer than $key
                        [ 'version' => null, 'minAsOf' => $asOf ] + $opts
                    );
                }
            } else {
                $value = $this->doGetWithSetCallback( $key, $ttl, $callback, $opts );
            }
 
            // Update the process cache if enabled
            if ( $procCache && $value !== false ) {
                $procCache->set( $key, $value );
            }
        }
 
        return $value;
    }
 
    protected function doGetWithSetCallback( $key, $ttl, $callback, array $opts, &$asOf = null ) {
        $lowTTL = $opts['lowTTL'] ?? min( self::LOW_TTL, $ttl );
        $lockTSE = $opts['lockTSE'] ?? self::TSE_NONE;
        $staleTTL = $opts['staleTTL'] ?? self::STALE_TTL_NONE;
        $graceTTL = $opts['graceTTL'] ?? self::GRACE_TTL_NONE;
        $checkKeys = $opts['checkKeys'] ?? [];
        $busyValue = $opts['busyValue'] ?? null;
        $popWindow = $opts['hotTTR'] ?? self::HOT_TTR;
        $ageNew = $opts['ageNew'] ?? self::AGE_NEW;
        $minTime = $opts['minAsOf'] ?? self::MIN_TIMESTAMP_NONE;
        $versioned = isset( $opts['version'] );
 
        // Get a collection name to describe this class of key
        $kClass = $this->determineKeyClass( $key );
 
        // Get the current key value
        $curTTL = null;
        $cValue = $this->get( $key, $curTTL, $checkKeys, $asOf ); // current value
        $value = $cValue; // return value
 
        $preCallbackTime = $this->getCurrentTime();
        // Determine if a cached value regeneration is needed or desired
        if ( $value !== false
            && $this->isAliveOrInGracePeriod( $curTTL, $graceTTL )
            && $this->isValid( $value, $versioned, $asOf, $minTime )
        ) {
            $preemptiveRefresh = (
                $this->worthRefreshExpiring( $curTTL, $lowTTL ) ||
                $this->worthRefreshPopular( $asOf, $ageNew, $popWindow, $preCallbackTime )
            );
 
            if ( !$preemptiveRefresh ) {
                $this->stats->increment( "wanobjectcache.$kClass.hit.good" );
 
                return $value;
            } elseif ( $this->asyncHandler ) {
                // Update the cache value later, such during post-send of an HTTP request
                $func = $this->asyncHandler;
                $func( function () use ( $key, $ttl, $callback, $opts, $asOf ) {
                    $opts['minAsOf'] = INF; // force a refresh
                    $this->doGetWithSetCallback( $key, $ttl, $callback, $opts, $asOf );
                } );
                $this->stats->increment( "wanobjectcache.$kClass.hit.refresh" );
 
                return $value;
            }
        }
 
        // A deleted key with a negative TTL left must be tombstoned
        $isTombstone = ( $curTTL !== null && $value === false );
        if ( $isTombstone && $lockTSE <= 0 ) {
            // Use the INTERIM value for tombstoned keys to reduce regeneration load
            $lockTSE = self::INTERIM_KEY_TTL;
        }
        // Assume a key is hot if requested soon after invalidation
        $isHot = ( $curTTL !== null && $curTTL <= 0 && abs( $curTTL ) <= $lockTSE );
        // Use the mutex if there is no value and a busy fallback is given
        $checkBusy = ( $busyValue !== null && $value === false );
        // Decide whether a single thread should handle regenerations.
        // This avoids stampedes when $checkKeys are bumped and when preemptive
        // renegerations take too long. It also reduces regenerations while $key
        // is tombstoned. This balances cache freshness with avoiding DB load.
        $useMutex = ( $isHot || ( $isTombstone && $lockTSE > 0 ) || $checkBusy );
 
        $lockAcquired = false;
        if ( $useMutex ) {
            // Acquire a datacenter-local non-blocking lock
            if ( $this->cache->add( self::MUTEX_KEY_PREFIX . $key, 1, self::LOCK_TTL ) ) {
                // Lock acquired; this thread should update the key
                $lockAcquired = true;
            } elseif ( $value !== false && $this->isValid( $value, $versioned, $asOf, $minTime ) ) {
                $this->stats->increment( "wanobjectcache.$kClass.hit.stale" );
                // If it cannot be acquired; then the stale value can be used
                return $value;
            } else {
                // Use the INTERIM value for tombstoned keys to reduce regeneration load.
                // For hot keys, either another thread has the lock or the lock failed;
                // use the INTERIM value from the last thread that regenerated it.
                $value = $this->getInterimValue( $key, $versioned, $minTime, $asOf );
                if ( $value !== false ) {
                    $this->stats->increment( "wanobjectcache.$kClass.hit.volatile" );
 
                    return $value;
                }
                // Use the busy fallback value if nothing else
                if ( $busyValue !== null ) {
                    $miss = is_infinite( $minTime ) ? 'renew' : 'miss';
                    $this->stats->increment( "wanobjectcache.$kClass.$miss.busy" );
 
                    return is_callable( $busyValue ) ? $busyValue() : $busyValue;
                }
            }
        }
 
        if ( !is_callable( $callback ) ) {
            throw new InvalidArgumentException( "Invalid cache miss callback provided." );
        }
 
        // Generate the new value from the callback...
        $setOpts = [];
        ++$this->callbackDepth;
        try {
            $value = call_user_func_array( $callback, [ $cValue, &$ttl, &$setOpts, $asOf ] );
        } finally {
            --$this->callbackDepth;
        }
        $valueIsCacheable = ( $value !== false && $ttl >= 0 );
 
        // When delete() is called, writes are write-holed by the tombstone,
        // 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 = $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
            $this->set( $key, $value, $ttl, $setOpts );
        }
 
        if ( $lockAcquired ) {
            // Avoid using delete() to avoid pointless mcrouter broadcasting
            $this->cache->changeTTL( self::MUTEX_KEY_PREFIX . $key, (int)$preCallbackTime - 60 );
        }
 
        $miss = is_infinite( $minTime ) ? 'renew' : 'miss';
        $this->stats->increment( "wanobjectcache.$kClass.$miss.compute" );
 
        return $value;
    }
 
    protected function getInterimValue( $key, $versioned, $minTime, &$asOf ) {
        if ( !$this->useInterimHoldOffCaching ) {
            return false; // disabled
        }
 
        $wrapped = $this->cache->get( self::INTERIM_KEY_PREFIX . $key );
        list( $value ) = $this->unwrap( $wrapped, $this->getCurrentTime() );
        if ( $value !== false && $this->isValid( $value, $versioned, $asOf, $minTime ) ) {
            $asOf = $wrapped[self::FLD_TIME];
 
            return $value;
        }
 
        return false;
    }
 
    protected function setInterimValue( $key, $wrapped, $tempTTL ) {
        $this->cache->merge(
            self::INTERIM_KEY_PREFIX . $key,
            function () use ( $wrapped ) {
                return $wrapped;
            },
            $tempTTL,
            1
        );
    }
 
    final public function getMultiWithSetCallback(
        ArrayIterator $keyedIds, $ttl, callable $callback, array $opts = []
    ) {
        $valueKeys = array_keys( $keyedIds->getArrayCopy() );
        $checkKeys = $opts['checkKeys'] ?? [];
        $pcTTL = $opts['pcTTL'] ?? self::TTL_UNCACHEABLE;
 
        // Load required keys into process cache in one go
        $this->warmupCache = $this->getRawKeysForWarmup(
            $this->getNonProcessCachedKeys( $valueKeys, $opts, $pcTTL ),
            $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 = []
    ) {
        $idsByValueKey = $keyedIds->getArrayCopy();
        $valueKeys = array_keys( $idsByValueKey );
        $checkKeys = $opts['checkKeys'] ?? [];
        $pcTTL = $opts['pcTTL'] ?? self::TTL_UNCACHEABLE;
        unset( $opts['lockTSE'] ); // incompatible
        unset( $opts['busyValue'] ); // incompatible
 
        // Load required keys into process cache in one go
        $keysGet = $this->getNonProcessCachedKeys( $valueKeys, $opts, $pcTTL );
        $this->warmupCache = $this->getRawKeysForWarmup( $keysGet, $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( $keysGet, $curTTLs, $checkKeys, $asOfs );
        foreach ( $keysGet as $key ) {
            if ( !array_key_exists( $key, $curByKey ) || $curTTLs[$key] < 0 ) {
                $idsRegen[] = $idsByValueKey[$key];
            }
        }
 
        // 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 ( $idsByValueKey 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::FLD_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, $component = null ) {
        return $this->cache->makeKey( ...func_get_args() );
    }
 
    public function makeGlobalKey( $class, $component = null ) {
        return $this->cache->makeGlobalKey( ...func_get_args() );
    }
 
    final public function makeMultiKeys( array $entities, callable $keyFunc ) {
        $map = [];
        foreach ( $entities as $entity ) {
            $map[$keyFunc( $entity, $this )] = $entity;
        }
 
        return new ArrayIterator( $map );
    }
 
    final public function getLastError() {
        if ( $this->lastRelayError ) {
            // If the cache and the relayer failed, focus on the latter.
            // An update not making it to the relayer means it won't show up
            // in other DCs (nor will consistent re-hashing see up-to-date values).
            // On the other hand, if just the cache update failed, then it should
            // eventually be applied by the relayer.
            return $this->lastRelayError;
        }
 
        $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();
        $this->lastRelayError = self::ERR_NONE;
    }
 
    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(), self::HOLDOFF_NONE ),
                $ttl
            );
        } elseif ( $this->purgeRelayer instanceof EventRelayerNull ) {
            // This handles the mcrouter and the single-DC case
            $ok = $this->cache->set(
                $key,
                $this->makePurgeValue( $this->getCurrentTime(), self::HOLDOFF_NONE ),
                $ttl
            );
        } else {
            $event = $this->cache->modifySimpleRelayEvent( [
                'cmd' => 'set',
                'key' => $key,
                'val' => 'PURGED:$UNIXTIME$:' . (int)$holdoff,
                'ttl' => max( $ttl, self::TTL_SECOND ),
                'sbt' => true, // substitute $UNIXTIME$ with actual microtime
            ] );
 
            $ok = $this->purgeRelayer->notify( $this->purgeChannel, $event );
            if ( !$ok ) {
                $this->lastRelayError = self::ERR_RELAY;
            }
        }
 
        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}" );
        } elseif ( $this->purgeRelayer instanceof EventRelayerNull ) {
            // Some other proxy handles broadcasting or there is only one datacenter
            $ok = $this->cache->delete( $key );
        } else {
            $event = $this->cache->modifySimpleRelayEvent( [
                'cmd' => 'delete',
                'key' => $key,
            ] );
 
            $ok = $this->purgeRelayer->notify( $this->purgeChannel, $event );
            if ( !$ok ) {
                $this->lastRelayError = self::ERR_RELAY;
            }
        }
 
        return $ok;
    }
 
    protected 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;
        }
 
        // 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
        // P(refresh) = 1/($refreshWindowSec * $popularHitsPerSec)
        $chance = 1 / ( self::HIT_RATE_HIGH * $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, $versioned, $asOf, $minTime ) {
        if ( $versioned && !isset( $value[self::VFLD_VERSION] ) ) {
            return false;
        } elseif ( $minTime > 0 && $asOf < $minTime ) {
            return false;
        }
 
        return true;
    }
 
    protected function wrap( $value, $ttl, $now ) {
        return [
            self::FLD_VERSION => self::VERSION,
            self::FLD_VALUE => $value,
            self::FLD_TTL => $ttl,
            self::FLD_TIME => $now
        ];
    }
 
    protected function unwrap( $wrapped, $now ) {
        // Check if the value is a tombstone
        $purge = $this->parsePurgeValue( $wrapped );
        if ( $purge !== false ) {
            // Purged values should always have a negative current $ttl
            $curTTL = min( $purge[self::FLD_TIME] - $now, self::TINY_NEGATIVE );
            return [ false, $curTTL ];
        }
 
        if ( !is_array( $wrapped ) // not found
            || !isset( $wrapped[self::FLD_VERSION] ) // wrong format
            || $wrapped[self::FLD_VERSION] !== self::VERSION // wrong version
        ) {
            return [ false, null ];
        }
 
        $flags = $wrapped[self::FLD_FLAGS] ?? 0;
        if ( ( $flags & self::FLG_STALE ) == self::FLG_STALE ) {
            // Treat as expired, with the cache time as the expiration
            $age = $now - $wrapped[self::FLD_TIME];
            $curTTL = min( -$age, self::TINY_NEGATIVE );
        } elseif ( $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;
        }
 
        if ( $wrapped[self::FLD_TIME] < $this->epoch ) {
            // Values this old are ignored
            return [ false, null ];
        }
 
        return [ $wrapped[self::FLD_VALUE], $curTTL ];
    }
 
    protected static function prefixCacheKeys( array $keys, $prefix ) {
        $res = [];
        foreach ( $keys as $key ) {
            $res[] = $prefix . $key;
        }
 
        return $res;
    }
 
    protected function determineKeyClass( $key ) {
        $parts = explode( ':', $key );
 
        return $parts[1] ?? $parts[0]; // sanity
    }
 
    protected 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::FLD_TIME => (float)$segments[1],
            self::FLD_HOLDOFF => (int)$segments[2],
        ];
    }
 
    protected function makePurgeValue( $timestamp, $holdoff ) {
        return self::PURGE_VAL_PREFIX . (float)$timestamp . ':' . (int)$holdoff;
    }
 
    protected function getProcessCache( $group ) {
        if ( !isset( $this->processCaches[$group] ) ) {
            list( , $n ) = explode( ':', $group );
            $this->processCaches[$group] = new MapCacheLRU( (int)$n );
        }
 
        return $this->processCaches[$group];
    }
 
    private function getNonProcessCachedKeys( array $keys, array $opts, $pcTTL ) {
        $keysFound = [];
        if ( isset( $opts['pcTTL'] ) && $opts['pcTTL'] > 0 && $this->callbackDepth == 0 ) {
            $pcGroup = $opts['pcGroup'] ?? self::PC_PRIMARY;
            $procCache = $this->getProcessCache( $pcGroup );
            foreach ( $keys as $key ) {
                if ( $procCache->has( $key, $pcTTL ) ) {
                    $keysFound[] = $key;
                }
            }
        }
 
        return array_diff( $keys, $keysFound );
    }
 
    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() {
        return $this->wallClockOverride ?: microtime( true );
    }
 
    public function setMockTime( &$time ) {
        $this->wallClockOverride =& $time;
        $this->cache->setMockTime( $time );
    }
}