Package com.tangosol.net.partition

Class ObservableSplittingBackingCache

    • Field Detail

      • MAX_PARTITION_MAP_UNIT_FACTOR

        protected static final int MAX_PARTITION_MAP_UNIT_FACTOR
        The maximum unit factor for partition maps.
        See Also:
        Constant Field Values

      • m_cHighUnits

        protected int m_cHighUnits
        High units is the number of units that triggers eviction. The value -1 indicates that this cache has not been instructed to override the high units of the underlying caches.

      • m_cLowUnits

        protected int m_cLowUnits
        Low units is the number of units to evict down to. The value -1 indicates that this cache has not been instructed to override the low units of the underlying caches.

      • m_cHighUnitsCalibrated

        protected int m_cHighUnitsCalibrated
        The high units adjusted based on the partition unit factor.

      • m_cLowUnitsCalibrated

        protected int m_cLowUnitsCalibrated
        The low units adjusted based on the partition unit factor.

      • m_nUnitFactor

        protected int m_nUnitFactor
        The unit factor. The value -1 indicates that this cache has not been instructed to override the unit factor of the underlying caches.

      • m_cExpiryDelayMillis

        protected int m_cExpiryDelayMillis
        The expiry delay. The value -1 indicates that this cache has not been instructed to override the expiry delay of the underlying caches.

      • m_cHighUnitFairShare

        protected int m_cHighUnitFairShare
        The fair share of high units for each partition map.

      • m_cLowUnitFairShare

        protected int m_cLowUnitFairShare
        The fair share of low units for each partition map.

      • m_policy

        protected ConfigurableCacheMap.EvictionPolicy m_policy
        The eviction policy. The value of null indicates that this cache has not been instructed to override the eviction policy of the underlying caches.

      • m_calculator

        protected ConfigurableCacheMap.UnitCalculator m_calculator
        The unit calculator. The value of null indicates that this cache has not been instructed to override the unit calculator of the underlying caches.

      • m_acache

        protected ConfigurableCacheMap[] m_acache
        A cached array of the backing ConfigurableCacheMap instances.

      • m_clzPartitionMap

        protected Class m_clzPartitionMap

    • Constructor Detail

      • ObservableSplittingBackingCache

        public ObservableSplittingBackingCache​(BackingMapManager bmm,
                                       String sName)
        Create a ObservableSplittingBackingCache that adds ConfigurableCacheMap functionality to an ObservableSplittingBackingMap.
        Parameters:
        bmm - a callback that knows how to create and release the backing maps that this ObservableSplittingBackingCache is responsible for
        sName - the cache name for which this backing map exists

    • Method Detail

      • getUnits

        public int getUnits()
        Determine the number of units that the cache currently stores.

        Note: It is expected that the return type will be widened to a long in Coherence 4.

        Specified by:
        getUnits in interface ConfigurableCacheMap
        Returns:
        the current size of the cache in units

      • getHighUnits

        public int getHighUnits()
        Determine the limit of the cache size in units. The cache will prune itself automatically once it reaches its maximum unit level. This is often referred to as the "high water mark" of the cache.

        Note: It is expected that the return type will be widened to a long in Coherence 4.

        Specified by:
        getHighUnits in interface ConfigurableCacheMap
        Returns:
        the limit of the cache size in units

      • setHighUnits

        public void setHighUnits​(int cMax)
        Update the maximum size of the cache in units. This is often referred to as the "high water mark" of the cache.

        Note: It is expected that the parameter will be widened to a long in Coherence 4.

        Specified by:
        setHighUnits in interface ConfigurableCacheMap
        Parameters:
        cMax - the new maximum size of the cache, in units

      • getLowUnits

        public int getLowUnits()
        Determine the point to which the cache will shrink when it prunes. This is often referred to as a "low water mark" of the cache. If the cache incrementally prunes, then this setting will have no effect.

        Note: It is expected that the parameter will be widened to a long in Coherence 4.

        Specified by:
        getLowUnits in interface ConfigurableCacheMap
        Returns:
        the number of units that the cache prunes to

      • setLowUnits

        public void setLowUnits​(int cUnits)
        Specify the point to which the cache will shrink when it prunes. This is often referred to as a "low water mark" of the cache.

        Note: It is expected that the parameter will be widened to a long in Coherence 4.

        Specified by:
        setLowUnits in interface ConfigurableCacheMap
        Parameters:
        cUnits - the number of units that the cache prunes to

      • getUnitFactor

        public int getUnitFactor()
        Determine the factor by which the Units, LowUnits and HighUnits properties are adjusted. Using a binary unit calculator, for example, the factor 1048576 could be used to count megabytes instead of bytes.

        Note: This property exists only to avoid changing the type of the units, low units and high units properties from 32-bit values to 64-bit values. It is expected that the parameter will be dropped in Coherence 4.

        Specified by:
        getUnitFactor in interface ConfigurableCacheMap
        Returns:
        the units factor; the default is 1

      • setUnitFactor

        public void setUnitFactor​(int nFactor)
        Determine the factor by which the Units, LowUnits and HighUnits properties are adjusted. Using a binary unit calculator, for example, the factor 1048576 could be used to count megabytes instead of bytes.

        Note: This property exists only to avoid changing the type of the units, low units and high units properties from 32-bit values to 64-bit values. It is expected that the parameter will be dropped in Coherence 4.

        Specified by:
        setUnitFactor in interface ConfigurableCacheMap
        Parameters:
        nFactor - the units factor; the default is 1

      • evict

        public void evict​(Object oKey)
        Evict a specified key from the cache, as if it had expired from the cache. If the key is not in the cache, then the method has no effect.
        Specified by:
        evict in interface ConfigurableCacheMap
        Parameters:
        oKey - the key to evict from the cache

      • evictAll

        public void evictAll​(Collection colKeys)
        Evict the specified keys from the cache, as if they had each expired from the cache.

        The result of this method is defined to be semantically the same as the following implementation: 

        
 for (Iterator iter = colKeys.iterator(); iter.hasNext(); )
     {
     Object oKey = iter.next();
     evict(oKey);
     }
        Specified by:
        evictAll in interface ConfigurableCacheMap
        Parameters:
        colKeys - a collection of keys to evict from the cache

      • evict

        public void evict()
        Evict all entries from the cache that are no longer valid, and potentially prune the cache size if the cache is size-limited and its size is above the caching low water mark.
        Specified by:
        evict in interface ConfigurableCacheMap

      • getExpiryDelay

        public int getExpiryDelay()
        Determine the default "time to live" for each individual cache entry.
        Specified by:
        getExpiryDelay in interface ConfigurableCacheMap
        Returns:
        the number of milliseconds that a cache entry value will live, or zero if cache entries are never automatically expired

      • setExpiryDelay

        public void setExpiryDelay​(int cMillis)
        Specify the default "time to live" for cache entries. This does not affect the already-scheduled expiry of existing entries.
        Specified by:
        setExpiryDelay in interface ConfigurableCacheMap
        Parameters:
        cMillis - the number of milliseconds that cache entries will live, or zero to disable automatic expiry

      • getNextExpiryTime

        public long getNextExpiryTime()
        Determine the next expiry time for the cache entries. This value is supposed to be used only by the "active" expiry algorithms, so for implementations that choose to return the value of zero the entries will be evicted as with pre-existing "passive" expiry approach.
        Specified by:
        getNextExpiryTime in interface ConfigurableCacheMap
        Returns:
        the earliest time (using the SafeClock) that one or more cache entries will expire or zero if the cache is empty, its entries never expire or the implementation chooses to avoid the pro-active eviction

      • getPartitionMapType

        public Class getPartitionMapType()
        Return the uniform type used by each partition map.
        Returns:
        the type of partition map

      • prepareUpdate

        protected void prepareUpdate​(Map mapPartition,
                             Map mapUpdate)
        Prepare mapPart, a map representing a partition, for the impending changes in which all of the mappings from mapUpdate will be copied to mapPart.

        This implementation will check if mapPart is under-allocated for high units. If this is the case, demand the entitled unit amount from other maps.

        Overrides:
        prepareUpdate in class ObservableSplittingBackingMap
        Parameters:
        mapPartition - the map to be mutated with the contents of mapUpdate
        mapUpdate - the map of changes to be applied

      • claimUnused

        protected void claimUnused​(ConfigurableCacheMap mapRequestor)
        Claim as many units as possible from existing maps without causing over-allocated maps to evict.
        Parameters:
        mapRequestor - the map requesting its fair share of units

      • claimAll

        protected void claimAll​(ConfigurableCacheMap mapRequestor)
        Claim the full entitlement of units for mapRequestor. This method should only be invoked if the map has insufficient units, based on a pending put request, however does not occupy its fair share.
        Parameters:
        mapRequestor - the map demanding its entitled fair share

      • adjustUnits

        protected void adjustUnits​(int cUnits)
        Adjust the number of units for each map with the pool of units provided. The units provided is a total across all maps with the adjustment per map being made as prescribed below.

        The provided units may be positive or negative, with the latter suggesting that this number of units should be retrieved, thus decremented, from child maps. If the provided units is positive, maps that are over-allocated may consumer the provided amount. If the provided units is negative maintain a positive delta between the fair share and their current high units may consume the minimum between what is available from the provided units and the determined delta. If the provided units is negative, those maps whose current high unit allocation is more than the fair share will have this delta decremented until the debt (cUnits) is reclaimed.

        Parameters:
        cUnits - the number of units to either disseminate (positive unit value) or retract across the maps

      • initializeConfiguredProperties

        protected void initializeConfiguredProperties()
        Initialize the configurable properties of this cache-map.

      • getPartitionCache

        protected ConfigurableCacheMap getPartitionCache​(Object oKey)
        Obtain the backing cache for a particular key. If the key is not owned by a partition represented by this ObservableSplittingBackingCache, then a runtime exception is thrown.
        Parameters:
        oKey - the key of the desired entry
        Returns:
        the backing cache

      • getPartitionCacheArray

        protected ConfigurableCacheMap[] getPartitionCacheArray()
        Obtain the array of backing caches.
        Returns:
        an array of all the per-partition backing caches

      • getCalibratedHighUnits

        protected int getCalibratedHighUnits()
        Determine the high units adjusted based on the partition unit factor.
        Returns:
        the limit of the cache size in units adjusted by partition unitFactor

      • getCalibratedLowUnits

        protected int getCalibratedLowUnits()
        Determine the low units adjusted based on the partition unit factor.
        Returns:
        the number of units adjusted by partition unitFactor that the cache prunes to

      • getPartitionUnitFactor

        protected int getPartitionUnitFactor()
        Determine the unit factor for individual partition maps.
        Returns:
        the unit factor for partition maps

      • getLowUnitFairShare

        protected int getLowUnitFairShare()
        Return the fair share of low-units per partition map.
        Returns:
        the fair share of low-units per partition map

      • getHighUnitFairShare

        protected int getHighUnitFairShare()
        Return the fair share of high-units per partition map.
        Returns:
        the fair share of high-units per partition map

      • calcUnitFairShare

        protected int calcUnitFairShare​(int cUnits)
        Return the fair share of units for each child maps. The units provided would typically be either the high or low units allowed for all maps under this map.
        Parameters:
        cUnits - the units to distribute across all child maps
        Returns:
        the fair share of units for each child map

      • instantiateEntrySet

        protected Set instantiateEntrySet()
        Factory pattern: Create a Set that represents the entries in the Map.
        Overrides:
        instantiateEntrySet in class AbstractKeySetBasedMap
        Returns:
        a new instance of Set that represents the entries in the Map