1. 包列表
  2. 类列表
  3. org.apache.hadoop.hbase.util.DirectMemoryUtils

Java 类org.apache.hadoop.hbase.util.DirectMemoryUtils 实例源码

项目：LCIndex-HBase-0.94.16    文件：CacheConfig.java    
/**
 * Returns the block cache or <code>null</code> in case none should be used.
 * @param conf The current configuration.
 * @return The block cache or <code>null</code>.
 */
private static synchronized BlockCache instantiateBlockCache(Configuration conf) {
  if (globalBlockCache != null) return globalBlockCache;
  if (blockCacheDisabled) return null;

  float cachePercentage =
      conf.getFloat(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY,
        HConstants.HFILE_BLOCK_CACHE_SIZE_DEFAULT);
  if (cachePercentage == 0L) {
    blockCacheDisabled = true;
    return null;
  }
  if (cachePercentage > 1.0) {
    throw new IllegalArgumentException(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY
        + " must be between 0.0 and 1.0, and not > 1.0");
  }

  // Calculate the amount of heap to give the heap.
  MemoryUsage mu = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
  long cacheSize = (long) (mu.getMax() * cachePercentage);
  int blockSize = conf.getInt("hbase.offheapcache.minblocksize", HFile.DEFAULT_BLOCKSIZE);
  long offHeapCacheSize =
      (long) (conf.getFloat("hbase.offheapcache.percentage", (float) 0) * DirectMemoryUtils
          .getDirectMemorySize());
  LOG.info("Allocating LruBlockCache with maximum size "
      + StringUtils.humanReadableInt(cacheSize));
  if (offHeapCacheSize <= 0) {
    globalBlockCache = new LruBlockCache(cacheSize, StoreFile.DEFAULT_BLOCKSIZE_SMALL, conf);
  } else {
    globalBlockCache =
        new DoubleBlockCache(cacheSize, offHeapCacheSize, StoreFile.DEFAULT_BLOCKSIZE_SMALL,
            blockSize, conf);
  }
  return globalBlockCache;
}
项目：LCIndex-HBase-0.94.16    文件：Slab.java    
void shutdown() {
  for (ByteBuffer aSlab : slabs) {
    try {
      DirectMemoryUtils.destroyDirectByteBuffer(aSlab);
    } catch (Exception e) {
      LOG.warn("Unable to deallocate direct memory during shutdown", e);
    }
  }
}
项目：HIndex    文件：Slab.java    
void shutdown() {
  for (ByteBuffer aSlab : slabs) {
    try {
      DirectMemoryUtils.destroyDirectByteBuffer(aSlab);
    } catch (Exception e) {
      LOG.warn("Unable to deallocate direct memory during shutdown", e);
    }
  }
}
项目：IRIndex    文件：CacheConfig.java    
/**
 * Returns the block cache or <code>null</code> in case none should be used.
 *
 * @param conf  The current configuration.
 * @return The block cache or <code>null</code>.
 */
private static synchronized BlockCache instantiateBlockCache(
    Configuration conf) {
  if (globalBlockCache != null) return globalBlockCache;
  if (blockCacheDisabled) return null;

  float cachePercentage = conf.getFloat(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY,
    HConstants.HFILE_BLOCK_CACHE_SIZE_DEFAULT);
  if (cachePercentage == 0L) {
    blockCacheDisabled = true;
    return null;
  }
  if (cachePercentage > 1.0) {
    throw new IllegalArgumentException(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY +
      " must be between 0.0 and 1.0, and not > 1.0");
  }

  // Calculate the amount of heap to give the heap.
  MemoryUsage mu = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
  long cacheSize = (long)(mu.getMax() * cachePercentage);
  int blockSize = conf.getInt("hbase.offheapcache.minblocksize",
      HFile.DEFAULT_BLOCKSIZE);
  long offHeapCacheSize =
    (long) (conf.getFloat("hbase.offheapcache.percentage", (float) 0) *
        DirectMemoryUtils.getDirectMemorySize());
  LOG.info("Allocating LruBlockCache with maximum size " +
    StringUtils.humanReadableInt(cacheSize));
  if (offHeapCacheSize <= 0) {
    globalBlockCache = new LruBlockCache(cacheSize,
        StoreFile.DEFAULT_BLOCKSIZE_SMALL, conf);
  } else {
    globalBlockCache = new DoubleBlockCache(cacheSize, offHeapCacheSize,
        StoreFile.DEFAULT_BLOCKSIZE_SMALL, blockSize, conf);
  }
  return globalBlockCache;
}
项目：IRIndex    文件：Slab.java    
void shutdown() {
  for (ByteBuffer aSlab : slabs) {
    try {
      DirectMemoryUtils.destroyDirectByteBuffer(aSlab);
    } catch (Exception e) {
      LOG.warn("Unable to deallocate direct memory during shutdown", e);
    }
  }
}
项目：RStore    文件：CacheConfig.java    
/**
 * Returns the block cache or <code>null</code> in case none should be used.
 *
 * @param conf  The current configuration.
 * @return The block cache or <code>null</code>.
 */
private static synchronized BlockCache instantiateBlockCache(
    Configuration conf) {
  if (globalBlockCache != null) return globalBlockCache;
  if (blockCacheDisabled) return null;

  float cachePercentage = conf.getFloat(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY,
    HConstants.HFILE_BLOCK_CACHE_SIZE_DEFAULT);
  if (cachePercentage == 0L) {
    blockCacheDisabled = true;
    return null;
  }
  if (cachePercentage > 1.0) {
    throw new IllegalArgumentException(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY +
      " must be between 0.0 and 1.0, and not > 1.0");
  }

  // Calculate the amount of heap to give the heap.
  MemoryUsage mu = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
  long cacheSize = (long)(mu.getMax() * cachePercentage);
  int blockSize = conf.getInt("hbase.offheapcache.minblocksize",
      HFile.DEFAULT_BLOCKSIZE);
  long offHeapCacheSize =
    (long) (conf.getFloat("hbase.offheapcache.percentage", (float) 0) *
        DirectMemoryUtils.getDirectMemorySize());
  LOG.info("Allocating LruBlockCache with maximum size " +
    StringUtils.humanReadableInt(cacheSize));
  if (offHeapCacheSize <= 0) {
    globalBlockCache = new LruBlockCache(cacheSize,
        StoreFile.DEFAULT_BLOCKSIZE_SMALL);
  } else {
    globalBlockCache = new DoubleBlockCache(cacheSize, offHeapCacheSize,
        StoreFile.DEFAULT_BLOCKSIZE_SMALL, blockSize, conf);
  }
  return globalBlockCache;
}
项目：RStore    文件：Slab.java    
void shutdown() {
  for (ByteBuffer aSlab : slabs) {
    try {
      DirectMemoryUtils.destroyDirectByteBuffer(aSlab);
    } catch (Exception e) {
      LOG.warn("Unable to deallocate direct memory during shutdown", e);
    }
  }
}
项目：PyroDB    文件：Slab.java    
void shutdown() {
  for (ByteBuffer aSlab : slabs) {
    try {
      DirectMemoryUtils.destroyDirectByteBuffer(aSlab);
    } catch (Exception e) {
      LOG.warn("Unable to deallocate direct memory during shutdown", e);
    }
  }
}
项目：c5    文件：Slab.java    
void shutdown() {
  for (ByteBuffer aSlab : slabs) {
    try {
      DirectMemoryUtils.destroyDirectByteBuffer(aSlab);
    } catch (Exception e) {
      LOG.warn("Unable to deallocate direct memory during shutdown", e);
    }
  }
}
项目：HBase-Research    文件：CacheConfig.java    
/**
 * Returns the block cache or <code>null</code> in case none should be used.
 *
 * @param conf  The current configuration.
 * @return The block cache or <code>null</code>.
 */
private static synchronized BlockCache instantiateBlockCache(
    Configuration conf) {
  if (globalBlockCache != null) return globalBlockCache;
  if (blockCacheDisabled) return null;

  float cachePercentage = conf.getFloat(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY,
    HConstants.HFILE_BLOCK_CACHE_SIZE_DEFAULT);
  if (cachePercentage == 0L) {
    blockCacheDisabled = true;
    return null;
  }
  if (cachePercentage > 1.0) {
    throw new IllegalArgumentException(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY +
      " must be between 0.0 and 1.0, and not > 1.0");
  }

  // Calculate the amount of heap to give the heap.
  MemoryUsage mu = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
  long cacheSize = (long)(mu.getMax() * cachePercentage);
  int blockSize = conf.getInt("hbase.offheapcache.minblocksize",
      HFile.DEFAULT_BLOCKSIZE);
  long offHeapCacheSize =
    (long) (conf.getFloat("hbase.offheapcache.percentage", (float) 0) *
        DirectMemoryUtils.getDirectMemorySize());
  LOG.info("Allocating LruBlockCache with maximum size " +
    StringUtils.humanReadableInt(cacheSize));
  if (offHeapCacheSize <= 0) {
    globalBlockCache = new LruBlockCache(cacheSize,
        StoreFile.DEFAULT_BLOCKSIZE_SMALL, conf);
  } else {
    globalBlockCache = new DoubleBlockCache(cacheSize, offHeapCacheSize,
        StoreFile.DEFAULT_BLOCKSIZE_SMALL, blockSize, conf);
  }
  return globalBlockCache;
}
项目：HBase-Research    文件：Slab.java    
void shutdown() {
  for (ByteBuffer aSlab : slabs) {
    try {
      DirectMemoryUtils.destroyDirectByteBuffer(aSlab);
    } catch (Exception e) {
      LOG.warn("Unable to deallocate direct memory during shutdown", e);
    }
  }
}
项目：hbase-0.94.8-qod    文件：CacheConfig.java    
/**
 * Returns the block cache or <code>null</code> in case none should be used.
 *
 * @param conf  The current configuration.
 * @return The block cache or <code>null</code>.
 */
private static synchronized BlockCache instantiateBlockCache(
    Configuration conf) {
  if (globalBlockCache != null) return globalBlockCache;
  if (blockCacheDisabled) return null;

  float cachePercentage = conf.getFloat(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY,
    HConstants.HFILE_BLOCK_CACHE_SIZE_DEFAULT);
  if (cachePercentage == 0L) {
    blockCacheDisabled = true;
    return null;
  }
  if (cachePercentage > 1.0) {
    throw new IllegalArgumentException(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY +
      " must be between 0.0 and 1.0, and not > 1.0");
  }

  // Calculate the amount of heap to give the heap.
  MemoryUsage mu = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
  long cacheSize = (long)(mu.getMax() * cachePercentage);
  int blockSize = conf.getInt("hbase.offheapcache.minblocksize",
      HFile.DEFAULT_BLOCKSIZE);
  long offHeapCacheSize =
    (long) (conf.getFloat("hbase.offheapcache.percentage", (float) 0) *
        DirectMemoryUtils.getDirectMemorySize());
  LOG.info("Allocating LruBlockCache with maximum size " +
    StringUtils.humanReadableInt(cacheSize));
  if (offHeapCacheSize <= 0) {
    globalBlockCache = new LruBlockCache(cacheSize,
        StoreFile.DEFAULT_BLOCKSIZE_SMALL, conf);
  } else {
    globalBlockCache = new DoubleBlockCache(cacheSize, offHeapCacheSize,
        StoreFile.DEFAULT_BLOCKSIZE_SMALL, blockSize, conf);
  }
  return globalBlockCache;
}
项目：hbase-0.94.8-qod    文件：Slab.java    
void shutdown() {
  for (ByteBuffer aSlab : slabs) {
    try {
      DirectMemoryUtils.destroyDirectByteBuffer(aSlab);
    } catch (Exception e) {
      LOG.warn("Unable to deallocate direct memory during shutdown", e);
    }
  }
}
项目：hbase-0.94.8-qod    文件：CacheConfig.java    
/**
 * Returns the block cache or <code>null</code> in case none should be used.
 *
 * @param conf  The current configuration.
 * @return The block cache or <code>null</code>.
 */
private static synchronized BlockCache instantiateBlockCache(
    Configuration conf) {
  if (globalBlockCache != null) return globalBlockCache;
  if (blockCacheDisabled) return null;

  float cachePercentage = conf.getFloat(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY,
    HConstants.HFILE_BLOCK_CACHE_SIZE_DEFAULT);
  if (cachePercentage == 0L) {
    blockCacheDisabled = true;
    return null;
  }
  if (cachePercentage > 1.0) {
    throw new IllegalArgumentException(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY +
      " must be between 0.0 and 1.0, and not > 1.0");
  }

  // Calculate the amount of heap to give the heap.
  MemoryUsage mu = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
  long cacheSize = (long)(mu.getMax() * cachePercentage);
  int blockSize = conf.getInt("hbase.offheapcache.minblocksize",
      HFile.DEFAULT_BLOCKSIZE);
  long offHeapCacheSize =
    (long) (conf.getFloat("hbase.offheapcache.percentage", (float) 0) *
        DirectMemoryUtils.getDirectMemorySize());
  LOG.info("Allocating LruBlockCache with maximum size " +
    StringUtils.humanReadableInt(cacheSize));
  if (offHeapCacheSize <= 0) {
    globalBlockCache = new LruBlockCache(cacheSize,
        StoreFile.DEFAULT_BLOCKSIZE_SMALL, conf);
  } else {
    globalBlockCache = new DoubleBlockCache(cacheSize, offHeapCacheSize,
        StoreFile.DEFAULT_BLOCKSIZE_SMALL, blockSize, conf);
  }
  return globalBlockCache;
}
项目：hbase-0.94.8-qod    文件：Slab.java    
void shutdown() {
  for (ByteBuffer aSlab : slabs) {
    try {
      DirectMemoryUtils.destroyDirectByteBuffer(aSlab);
    } catch (Exception e) {
      LOG.warn("Unable to deallocate direct memory during shutdown", e);
    }
  }
}
项目：DominoHBase    文件：Slab.java    
void shutdown() {
  for (ByteBuffer aSlab : slabs) {
    try {
      DirectMemoryUtils.destroyDirectByteBuffer(aSlab);
    } catch (Exception e) {
      LOG.warn("Unable to deallocate direct memory during shutdown", e);
    }
  }
}
项目：hindex    文件：CacheConfig.java    
/**
 * Returns the block cache or <code>null</code> in case none should be used.
 *
 * @param conf  The current configuration.
 * @return The block cache or <code>null</code>.
 */
private static synchronized BlockCache instantiateBlockCache(
    Configuration conf) {
  if (globalBlockCache != null) return globalBlockCache;
  if (blockCacheDisabled) return null;

  float cachePercentage = conf.getFloat(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY,
    HConstants.HFILE_BLOCK_CACHE_SIZE_DEFAULT);
  if (cachePercentage == 0L) {
    blockCacheDisabled = true;
    return null;
  }
  if (cachePercentage > 1.0) {
    throw new IllegalArgumentException(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY +
      " must be between 0.0 and 1.0, and not > 1.0");
  }

  // Calculate the amount of heap to give the heap.
  MemoryUsage mu = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
  long cacheSize = (long)(mu.getMax() * cachePercentage);
  int blockSize = conf.getInt("hbase.offheapcache.minblocksize",
      HFile.DEFAULT_BLOCKSIZE);
  long offHeapCacheSize =
    (long) (conf.getFloat("hbase.offheapcache.percentage", (float) 0) *
        DirectMemoryUtils.getDirectMemorySize());
  LOG.info("Allocating LruBlockCache with maximum size " +
    StringUtils.humanReadableInt(cacheSize));
  if (offHeapCacheSize <= 0) {
    globalBlockCache = new LruBlockCache(cacheSize,
        StoreFile.DEFAULT_BLOCKSIZE_SMALL, conf);
  } else {
    globalBlockCache = new DoubleBlockCache(cacheSize, offHeapCacheSize,
        StoreFile.DEFAULT_BLOCKSIZE_SMALL, blockSize, conf);
  }
  return globalBlockCache;
}
项目：hindex    文件：Slab.java    
void shutdown() {
  for (ByteBuffer aSlab : slabs) {
    try {
      DirectMemoryUtils.destroyDirectByteBuffer(aSlab);
    } catch (Exception e) {
      LOG.warn("Unable to deallocate direct memory during shutdown", e);
    }
  }
}