Package com.tangosol.net.cache

Class SimpleMemoryCalculator

  • All Implemented Interfaces:
    ConfigurableCacheMap.UnitCalculator, OldCache.UnitCalculator
    Direct Known Subclasses:
    BinaryMemoryCalculator, SimpleMapIndex.IndexCalculator
    public class SimpleMemoryCalculator
extends Base
implements OldCache.UnitCalculator
    A UnitCalculator implementation that weighs a cache entry based upon the amount of physical memory (in bytes) required to store the entry.

    This implementation can only determine an accurate entry size if both the entry key and value object types are one of the following classes (or an array thereof or of the primitive forms thereof):

    • BigInteger
    • BigDecimal
    • Binary
    • Boolean
    • Byte
    • Character
    • Date
    • Double
    • Float
    • Integer
    • Long
    • Object
    • String
    • Time
    • Timestamp

    If either the key or value object is not one of these types, an exception will be thrown during the unit calculation.

    Author:
    jh 2005.12.20

    • Field Detail

      • SIZE_OBJECT_REF

        public static final int SIZE_OBJECT_REF
        The size (in bytes) of an object reference.

        On a 32 bit JVM, an object reference is 4 bytes. On a 64 bit JVM, an object reference is 8 bytes.

      • SIZE_OBJECT

        public static final int SIZE_OBJECT
        The size (in bytes) of an Object.

      • SIZE_BOOLEAN

        public static final int SIZE_BOOLEAN
        The size (in bytes) of a Boolean object.

      • SIZE_BYTE

        public static final int SIZE_BYTE
        The size (in bytes) of a Byte object.

      • SIZE_SHORT

        public static final int SIZE_SHORT
        The size (in bytes) of a Short object.

      • SIZE_CHARACTER

        public static final int SIZE_CHARACTER
        The size (in bytes) of a Character object.

      • SIZE_INTEGER

        public static final int SIZE_INTEGER
        The size (in bytes) of a Integer object.

      • SIZE_FLOAT

        public static final int SIZE_FLOAT
        The size (in bytes) of a Float object.

      • SIZE_LONG

        public static final int SIZE_LONG
        The size (in bytes) of a Long object.

      • SIZE_DOUBLE

        public static final int SIZE_DOUBLE
        The size (in bytes) of a Double object.

      • SIZE_DATE

        public static final int SIZE_DATE
        The size (in bytes) of a Date, Date or Time object.

      • SIZE_TIMESTAMP

        public static final int SIZE_TIMESTAMP
        The size (in bytes) of a Timestamp object.

      • SIZE_BIGINTEGER

        public static final int SIZE_BIGINTEGER
        The size (in bytes) of a BigInteger object.

      • SIZE_BIGDECIMAL

        public static final int SIZE_BIGDECIMAL
        The size (in bytes) of a BigDecimal object.

      • SIZE_STRING

        public static final int SIZE_STRING
        The minimum size (in bytes) of a String object.

      • SIZE_BINARY

        public static final int SIZE_BINARY
        The minimum size (in bytes) of a Binary object.

      • SIZE_ENTRY

        public static final int SIZE_ENTRY
        The minimum size (in bytes) of an LocalCache.Entry object.

      • MAP_FIXED_SIZES

        public static final Map MAP_FIXED_SIZES
        An immutable map of fixed-sized classes to instance size (in bytes).

      • MAP_PRIMITIVE_SIZES

        public static final Map MAP_PRIMITIVE_SIZES
        An immutable map of primitive types to their size (in bytes).

      • SIZE_BASIC_OBJECT

        protected static final int SIZE_BASIC_OBJECT
        The unaligned size of the simplest object.

    • Constructor Detail

      • SimpleMemoryCalculator

        public SimpleMemoryCalculator()

    • Method Detail

      • calculateUnits

        public int calculateUnits​(Object oKey,
                          Object oValue)
        Calculate a cache cost for the specified cache entry key and value.
        Specified by:
        calculateUnits in interface ConfigurableCacheMap.UnitCalculator
        Parameters:
        oKey - the cache key to evaluate for unit cost
        oValue - the cache value to evaluate for unit cost
        Returns:
        an integer value 0 or greater, with a larger value signifying a higher cost

      • getName

        public String getName()
        Obtain the name of the unit calculator. This is intended to be human readable for use in a monitoring tool; examples include "SimpleMemoryCalculator" and "BinaryMemoryCalculator".
        Specified by:
        getName in interface ConfigurableCacheMap.UnitCalculator
        Returns:
        the name of the unit calculator

      • getEntrySize

        protected int getEntrySize()
        Return the size of a map entry.
        Returns:
        the entry size

      • padMemorySize

        protected static int padMemorySize​(int cb)
        Round the given number of bytes to the next closest integer that is divisible by 8.

        This method is used to pad the result of a memory calculation assuming that fields are ordered to minimize padding and that allocation granularity is 8 bytes.

        Parameters:
        cb - the number of bytes to round
        Returns:
        the input, rounded up to the nearest multiple of 8

      • calculateShallowSize

        protected static int calculateShallowSize​(Class clz)
        Calculate the approximate number of bytes required to store an instance of the given class and its non-static fields in memory.

        The size calculation is shallow, in that fields that are references to variable-sized classes are not included in the estimate.

        Parameters:
        clz - the target class
        Returns:
        the number of bytes required to store an instance of the given class, including its non-static members

      • isInnerClass

        public static boolean isInnerClass​(Class clz)
        Return true if a given class is an inner class.
        Parameters:
        clz - the class to check
        Returns:
        true if the provided class is an inner class

      • main

        public static void main​(String[] asArg)
        Unit test.

        Usage: 

         java com.tangosol.net.cache.SimpleMemoryCalculator [class name]
        Parameters:
        asArg - command line arguments