Java MemoryMeter.isInitialized方法代码示例

import org.github.jamm.MemoryMeter; //导入方法依赖的package包/类
public void updateLiveRatio() throws RuntimeException
{
    if (!MemoryMeter.isInitialized())
    {
        // hack for openjdk.  we log a warning about this in the startup script too.
        logger.warn("MemoryMeter uninitialized (jamm not specified as java agent); assuming liveRatio of {}.  "
                    + " Usually this means cassandra-env.sh disabled jamm because you are using a buggy JRE; "
                    + " upgrade to the Sun JRE instead", cfs.liveRatio);
        return;
    }

    if (!meteringInProgress.add(cfs))
    {
        logger.debug("Metering already pending or active for {}; skipping liveRatio update", cfs);
        return;
    }

    meterExecutor.submit(new MeteringRunnable(cfs));
}
 

import org.github.jamm.MemoryMeter; //导入方法依赖的package包/类
public void updateLiveRatio() throws RuntimeException
{
    if (!MemoryMeter.isInitialized())
    {
        // hack for openjdk.  we log a warning about this in the startup script too.
        logger.error("MemoryMeter uninitialized (jamm not specified as java agent); assuming liveRatio of {}.  "
                     + " Usually this means cassandra-env.sh disabled jamm because you are using a buggy JRE; "
                     + " upgrade to the Sun JRE instead", cfs.liveRatio);
        return;
    }

    if (!meteringInProgress.add(cfs))
    {
        logger.debug("Metering already pending or active for {}; skipping liveRatio update", cfs);
        return;
    }

    meterExecutor.submit(new MeteringRunnable(cfs));
}
 

import org.github.jamm.MemoryMeter; //导入方法依赖的package包/类
/**
 * We can use Weighers.singleton() because Long can't be leaking memory
 * @return auto saving cache object
 */
private AutoSavingCache<KeyCacheKey, RowIndexEntry> initKeyCache()
{
    logger.info("Initializing key cache with capacity of {} MBs.", DatabaseDescriptor.getKeyCacheSizeInMB());

    long keyCacheInMemoryCapacity = DatabaseDescriptor.getKeyCacheSizeInMB() * 1024 * 1024;

    // as values are constant size we can use singleton weigher
    // where 48 = 40 bytes (average size of the key) + 8 bytes (size of value)
    ICache<KeyCacheKey, RowIndexEntry> kc;
    if (MemoryMeter.isInitialized())
    {
        kc = ConcurrentLinkedHashCache.create(keyCacheInMemoryCapacity);
    }
    else
    {
        logger.warn("MemoryMeter uninitialized (jamm not specified as java agent); KeyCache size in JVM Heap will not be calculated accurately. " +
                    "Usually this means cassandra-env.sh disabled jamm because you are using a buggy JRE; upgrade to the Sun JRE instead");
        /* We don't know the overhead size because memory meter is not enabled. */
        EntryWeigher<KeyCacheKey, RowIndexEntry> weigher = new EntryWeigher<KeyCacheKey, RowIndexEntry>()
        {
            public int weightOf(KeyCacheKey key, RowIndexEntry entry)
            {
                return key.key.length + entry.serializedSize();
            }
        };
        kc = ConcurrentLinkedHashCache.create(keyCacheInMemoryCapacity, weigher);
    }
    AutoSavingCache<KeyCacheKey, RowIndexEntry> keyCache = new AutoSavingCache<KeyCacheKey, RowIndexEntry>(kc, CacheType.KEY_CACHE, new KeyCacheSerializer());

    int keyCacheKeysToSave = DatabaseDescriptor.getKeyCacheKeysToSave();

    logger.info("Scheduling key cache save to each {} seconds (going to save {} keys).",
            DatabaseDescriptor.getKeyCacheSavePeriod(),
                keyCacheKeysToSave == Integer.MAX_VALUE ? "all" : keyCacheKeysToSave);

    keyCache.scheduleSaving(DatabaseDescriptor.getKeyCacheSavePeriod(), keyCacheKeysToSave);

    return keyCache;
}
 

import org.github.jamm.MemoryMeter; //导入方法依赖的package包/类
private static long measure(Object key)
{
    if (!MemoryMeter.isInitialized())
        return 1;

    return key instanceof MeasurableForPreparedCache
         ? ((MeasurableForPreparedCache)key).measureForPreparedCache(meter)
         : meter.measureDeep(key);
}
 

import org.github.jamm.MemoryMeter; //导入方法依赖的package包/类
public void updateLiveRatio() throws RuntimeException
{
    if (!MemoryMeter.isInitialized())
    {
        // hack for openjdk.  we log a warning about this in the startup script too.
        logger.warn("MemoryMeter uninitialized (jamm not specified as java agent); assuming liveRatio of 10.0.  Usually this means cassandra-env.sh disabled jamm because you are using a buggy JRE; upgrade to the Sun JRE instead");
        cfs.liveRatio = 10.0;
        return;
    }

    if (!meteringInProgress.add(cfs))
    {
        logger.debug("Metering already pending or active for {}; skipping liveRatio update", cfs);
        return;
    }

    Runnable runnable = new Runnable()
    {
        public void run()
        {
            try
            {
                activelyMeasuring = Memtable.this;

                long start = System.currentTimeMillis();
                // ConcurrentSkipListMap has cycles, so measureDeep will have to track a reference to EACH object it visits.
                // So to reduce the memory overhead of doing a measurement, we break it up to row-at-a-time.
                long deepSize = meter.measure(columnFamilies);
                int objects = 0;
                for (Map.Entry<RowPosition, ColumnFamily> entry : columnFamilies.entrySet())
                {
                    deepSize += meter.measureDeep(entry.getKey()) + meter.measureDeep(entry.getValue());
                    objects += entry.getValue().getColumnCount();
                }
                double newRatio = (double) deepSize / currentSize.get();

                if (newRatio < MIN_SANE_LIVE_RATIO)
                {
                    logger.warn("setting live ratio to minimum of {} instead of {}", MIN_SANE_LIVE_RATIO, newRatio);
                    newRatio = MIN_SANE_LIVE_RATIO;
                }
                if (newRatio > MAX_SANE_LIVE_RATIO)
                {
                    logger.warn("setting live ratio to maximum of {} instead of {}", MAX_SANE_LIVE_RATIO, newRatio);
                    newRatio = MAX_SANE_LIVE_RATIO;
                }

                // we want to be very conservative about our estimate, since the penalty for guessing low is OOM
                // death.  thus, higher estimates are believed immediately; lower ones are averaged w/ the old
                if (newRatio > cfs.liveRatio)
                    cfs.liveRatio = newRatio;
                else
                    cfs.liveRatio = (cfs.liveRatio + newRatio) / 2.0;

                logger.info("{} liveRatio is {} (just-counted was {}).  calculation took {}ms for {} columns",
                            cfs, cfs.liveRatio, newRatio, System.currentTimeMillis() - start, objects);
                activelyMeasuring = null;
            }
            finally
            {
                meteringInProgress.remove(cfs);
            }
        }
    };

    meterExecutor.submit(runnable);
}
 

import org.github.jamm.MemoryMeter; //导入方法依赖的package包/类
public void updateLiveRatio()
{
    if (!MemoryMeter.isInitialized())
    {
        // hack for openjdk.  we log a warning about this in the startup script too.
        logger.warn("MemoryMeter uninitialized (jamm not specified as java agent); assuming liveRatio of 10.0.  Usually this means cassandra-env.sh disabled jamm because you are using a buggy JRE; upgrade to the Sun JRE instead");
        cfs.liveRatio = 10.0;
        return;
    }

    Runnable runnable = new Runnable()
    {
        public void run()
        {
            activelyMeasuring = Memtable.this;

            long start = System.currentTimeMillis();
            // ConcurrentSkipListMap has cycles, so measureDeep will have to track a reference to EACH object it visits.
            // So to reduce the memory overhead of doing a measurement, we break it up to row-at-a-time.
            long deepSize = meter.measure(columnFamilies);
            int objects = 0;
            for (Map.Entry<DecoratedKey, ColumnFamily> entry : columnFamilies.entrySet())
            {
                deepSize += meter.measureDeep(entry.getKey()) + meter.measureDeep(entry.getValue());
                objects += entry.getValue().getColumnCount();
            }
            double newRatio = (double) deepSize / currentThroughput.get();

            if (newRatio < MIN_SANE_LIVE_RATIO)
            {
                logger.warn("setting live ratio to minimum of 1.0 instead of {}", newRatio);
                newRatio = MIN_SANE_LIVE_RATIO;
            }
            if (newRatio > MAX_SANE_LIVE_RATIO)
            {
                logger.warn("setting live ratio to maximum of 64 instead of {}", newRatio);
                newRatio = MAX_SANE_LIVE_RATIO;
            }
            cfs.liveRatio = Math.max(cfs.liveRatio, newRatio);

            logger.info("{} liveRatio is {} (just-counted was {}).  calculation took {}ms for {} columns",
                        new Object[]{ cfs, cfs.liveRatio, newRatio, System.currentTimeMillis() - start, objects });
            activelyMeasuring = null;
        }
    };

    try
    {
        meterExecutor.submit(runnable);
    }
    catch (RejectedExecutionException e)
    {
        logger.debug("Meter thread is busy; skipping liveRatio update for {}", cfs);
    }
}