Java 类org.apache.hadoop.util.GSet 实例源码

项目：hadoop 文件：INodeMap.java

static INodeMap newInstance(INodeDirectory rootDir) {
  // Compute the map capacity by allocating 1% of total memory
  int capacity = LightWeightGSet.computeCapacity(1, "INodeMap");
  GSet<INode, INodeWithAdditionalFields> map
      = new LightWeightGSet<INode, INodeWithAdditionalFields>(capacity);
  map.put(rootDir);
  return new INodeMap(map);
}

项目：aliyun-oss-hadoop-fs 文件：INodeMap.java

static INodeMap newInstance(INodeDirectory rootDir) {
  // Compute the map capacity by allocating 1% of total memory
  int capacity = LightWeightGSet.computeCapacity(1, "INodeMap");
  GSet<INode, INodeWithAdditionalFields> map =
      new LightWeightGSet<>(capacity);
  map.put(rootDir);
  return new INodeMap(map);
}

项目：big-c 文件：INodeMap.java

static INodeMap newInstance(INodeDirectory rootDir) {
  // Compute the map capacity by allocating 1% of total memory
  int capacity = LightWeightGSet.computeCapacity(1, "INodeMap");
  GSet<INode, INodeWithAdditionalFields> map
      = new LightWeightGSet<INode, INodeWithAdditionalFields>(capacity);
  map.put(rootDir);
  return new INodeMap(map);
}

项目：hadoop-2.6.0-cdh5.4.3 文件：INodeMap.java

static INodeMap newInstance(INodeDirectory rootDir) {
  // Compute the map capacity by allocating 1% of total memory
  int capacity = LightWeightGSet.computeCapacity(1, "INodeMap");
  GSet<INode, INodeWithAdditionalFields> map
      = new LightWeightGSet<INode, INodeWithAdditionalFields>(capacity);
  map.put(rootDir);
  return new INodeMap(map);
}

项目：hadoop-plus 文件：INodeMap.java

static INodeMap newInstance(INodeDirectory rootDir) {
  // Compute the map capacity by allocating 1% of total memory
  int capacity = LightWeightGSet.computeCapacity(1, "INodeMap");
  GSet<INode, INodeWithAdditionalFields> map
      = new LightWeightGSet<INode, INodeWithAdditionalFields>(capacity);
  map.put(rootDir);
  return new INodeMap(map);
}

项目：FlexMap 文件：INodeMap.java

static INodeMap newInstance(INodeDirectory rootDir) {
  // Compute the map capacity by allocating 1% of total memory
  int capacity = LightWeightGSet.computeCapacity(1, "INodeMap");
  GSet<INode, INodeWithAdditionalFields> map
      = new LightWeightGSet<INode, INodeWithAdditionalFields>(capacity);
  map.put(rootDir);
  return new INodeMap(map);
}

项目：hadoop-TCP 文件：INodeMap.java

static INodeMap newInstance(INodeDirectory rootDir) {
  // Compute the map capacity by allocating 1% of total memory
  int capacity = LightWeightGSet.computeCapacity(1, "INodeMap");
  GSet<INode, INodeWithAdditionalFields> map
      = new LightWeightGSet<INode, INodeWithAdditionalFields>(capacity);
  map.put(rootDir);
  return new INodeMap(map);
}

项目：hardfs 文件：INodeMap.java

static INodeMap newInstance(INodeDirectory rootDir) {
  // Compute the map capacity by allocating 1% of total memory
  int capacity = LightWeightGSet.computeCapacity(1, "INodeMap");
  GSet<INode, INodeWithAdditionalFields> map
      = new LightWeightGSet<INode, INodeWithAdditionalFields>(capacity);
  map.put(rootDir);
  return new INodeMap(map);
}

项目：hadoop-on-lustre2 文件：INodeMap.java

static INodeMap newInstance(INodeDirectory rootDir) {
  // Compute the map capacity by allocating 1% of total memory
  int capacity = LightWeightGSet.computeCapacity(1, "INodeMap");
  GSet<INode, INodeWithAdditionalFields> map
      = new LightWeightGSet<INode, INodeWithAdditionalFields>(capacity);
  map.put(rootDir);
  return new INodeMap(map);
}

项目：hadoop 文件：INodeMap.java

private INodeMap(GSet<INode, INodeWithAdditionalFields> map) {
  Preconditions.checkArgument(map != null);
  this.map = map;
}

项目：hadoop 文件：CacheManager.java

@VisibleForTesting
public GSet<CachedBlock, CachedBlock> getCachedBlocks() {
  assert namesystem.hasReadLock();
  return cachedBlocks;
}

项目：hadoop 文件：TestCacheDirectives.java

/**
 * Wait for the NameNode to have an expected number of cached blocks
 * and replicas.
 * @param nn NameNode
 * @param expectedCachedBlocks if -1, treat as wildcard
 * @param expectedCachedReplicas if -1, treat as wildcard
 * @throws Exception
 */
private static void waitForCachedBlocks(NameNode nn,
    final int expectedCachedBlocks, final int expectedCachedReplicas,
    final String logString) throws Exception {
  final FSNamesystem namesystem = nn.getNamesystem();
  final CacheManager cacheManager = namesystem.getCacheManager();
  LOG.info("Waiting for " + expectedCachedBlocks + " blocks with " +
           expectedCachedReplicas + " replicas.");
  GenericTestUtils.waitFor(new Supplier<Boolean>() {
    @Override
    public Boolean get() {
      int numCachedBlocks = 0, numCachedReplicas = 0;
      namesystem.readLock();
      try {
        GSet<CachedBlock, CachedBlock> cachedBlocks =
            cacheManager.getCachedBlocks();
        if (cachedBlocks != null) {
          for (Iterator<CachedBlock> iter = cachedBlocks.iterator();
              iter.hasNext(); ) {
            CachedBlock cachedBlock = iter.next();
            numCachedBlocks++;
            numCachedReplicas += cachedBlock.getDatanodes(Type.CACHED).size();
          }
        }
      } finally {
        namesystem.readUnlock();
      }

      LOG.info(logString + " cached blocks: have " + numCachedBlocks +
          " / " + expectedCachedBlocks + ".  " +
          "cached replicas: have " + numCachedReplicas +
          " / " + expectedCachedReplicas);

      if (expectedCachedBlocks == -1 ||
          numCachedBlocks == expectedCachedBlocks) {
        if (expectedCachedReplicas == -1 ||
            numCachedReplicas == expectedCachedReplicas) {
          return true;
        }
      }
      return false;
    }
  }, 500, 60000);
}

项目：aliyun-oss-hadoop-fs 文件：INodeMap.java

private INodeMap(GSet<INode, INodeWithAdditionalFields> map) {
  Preconditions.checkArgument(map != null);
  this.map = map;
}

项目：aliyun-oss-hadoop-fs 文件：CacheManager.java

@VisibleForTesting
public GSet<CachedBlock, CachedBlock> getCachedBlocks() {
  assert namesystem.hasReadLock();
  return cachedBlocks;
}

项目：aliyun-oss-hadoop-fs 文件：TestCacheDirectives.java

/**
 * Wait for the NameNode to have an expected number of cached blocks
 * and replicas.
 * @param nn NameNode
 * @param expectedCachedBlocks if -1, treat as wildcard
 * @param expectedCachedReplicas if -1, treat as wildcard
 * @throws Exception
 */
private static void waitForCachedBlocks(NameNode nn,
    final int expectedCachedBlocks, final int expectedCachedReplicas,
    final String logString) throws Exception {
  final FSNamesystem namesystem = nn.getNamesystem();
  final CacheManager cacheManager = namesystem.getCacheManager();
  LOG.info("Waiting for " + expectedCachedBlocks + " blocks with " +
           expectedCachedReplicas + " replicas.");
  GenericTestUtils.waitFor(new Supplier<Boolean>() {
    @Override
    public Boolean get() {
      int numCachedBlocks = 0, numCachedReplicas = 0;
      namesystem.readLock();
      try {
        GSet<CachedBlock, CachedBlock> cachedBlocks =
            cacheManager.getCachedBlocks();
        if (cachedBlocks != null) {
          for (Iterator<CachedBlock> iter = cachedBlocks.iterator();
              iter.hasNext(); ) {
            CachedBlock cachedBlock = iter.next();
            numCachedBlocks++;
            numCachedReplicas += cachedBlock.getDatanodes(Type.CACHED).size();
          }
        }
      } finally {
        namesystem.readUnlock();
      }

      LOG.info(logString + " cached blocks: have " + numCachedBlocks +
          " / " + expectedCachedBlocks + ".  " +
          "cached replicas: have " + numCachedReplicas +
          " / " + expectedCachedReplicas);

      if (expectedCachedBlocks == -1 ||
          numCachedBlocks == expectedCachedBlocks) {
        if (expectedCachedReplicas == -1 ||
            numCachedReplicas == expectedCachedReplicas) {
          return true;
        }
      }
      return false;
    }
  }, 500, 60000);
}

项目：big-c 文件：INodeMap.java

private INodeMap(GSet<INode, INodeWithAdditionalFields> map) {
  Preconditions.checkArgument(map != null);
  this.map = map;
}

项目：big-c 文件：CacheManager.java

@VisibleForTesting
public GSet<CachedBlock, CachedBlock> getCachedBlocks() {
  assert namesystem.hasReadLock();
  return cachedBlocks;
}

项目：big-c 文件：TestCacheDirectives.java

/**
 * Wait for the NameNode to have an expected number of cached blocks
 * and replicas.
 * @param nn NameNode
 * @param expectedCachedBlocks if -1, treat as wildcard
 * @param expectedCachedReplicas if -1, treat as wildcard
 * @throws Exception
 */
private static void waitForCachedBlocks(NameNode nn,
    final int expectedCachedBlocks, final int expectedCachedReplicas,
    final String logString) throws Exception {
  final FSNamesystem namesystem = nn.getNamesystem();
  final CacheManager cacheManager = namesystem.getCacheManager();
  LOG.info("Waiting for " + expectedCachedBlocks + " blocks with " +
           expectedCachedReplicas + " replicas.");
  GenericTestUtils.waitFor(new Supplier<Boolean>() {
    @Override
    public Boolean get() {
      int numCachedBlocks = 0, numCachedReplicas = 0;
      namesystem.readLock();
      try {
        GSet<CachedBlock, CachedBlock> cachedBlocks =
            cacheManager.getCachedBlocks();
        if (cachedBlocks != null) {
          for (Iterator<CachedBlock> iter = cachedBlocks.iterator();
              iter.hasNext(); ) {
            CachedBlock cachedBlock = iter.next();
            numCachedBlocks++;
            numCachedReplicas += cachedBlock.getDatanodes(Type.CACHED).size();
          }
        }
      } finally {
        namesystem.readUnlock();
      }

      LOG.info(logString + " cached blocks: have " + numCachedBlocks +
          " / " + expectedCachedBlocks + ".  " +
          "cached replicas: have " + numCachedReplicas +
          " / " + expectedCachedReplicas);

      if (expectedCachedBlocks == -1 ||
          numCachedBlocks == expectedCachedBlocks) {
        if (expectedCachedReplicas == -1 ||
            numCachedReplicas == expectedCachedReplicas) {
          return true;
        }
      }
      return false;
    }
  }, 500, 60000);
}

项目：hadoop-2.6.0-cdh5.4.3 文件：INodeMap.java

private INodeMap(GSet<INode, INodeWithAdditionalFields> map) {
  Preconditions.checkArgument(map != null);
  this.map = map;
}

项目：hadoop-2.6.0-cdh5.4.3 文件：CacheManager.java

@VisibleForTesting
public GSet<CachedBlock, CachedBlock> getCachedBlocks() {
  assert namesystem.hasReadLock();
  return cachedBlocks;
}

项目：hadoop-2.6.0-cdh5.4.3 文件：TestCacheDirectives.java

/**
 * Wait for the NameNode to have an expected number of cached blocks
 * and replicas.
 * @param nn NameNode
 * @param expectedCachedBlocks if -1, treat as wildcard
 * @param expectedCachedReplicas if -1, treat as wildcard
 * @throws Exception
 */
private static void waitForCachedBlocks(NameNode nn,
    final int expectedCachedBlocks, final int expectedCachedReplicas,
    final String logString) throws Exception {
  final FSNamesystem namesystem = nn.getNamesystem();
  final CacheManager cacheManager = namesystem.getCacheManager();
  LOG.info("Waiting for " + expectedCachedBlocks + " blocks with " +
           expectedCachedReplicas + " replicas.");
  GenericTestUtils.waitFor(new Supplier<Boolean>() {
    @Override
    public Boolean get() {
      int numCachedBlocks = 0, numCachedReplicas = 0;
      namesystem.readLock();
      try {
        GSet<CachedBlock, CachedBlock> cachedBlocks =
            cacheManager.getCachedBlocks();
        if (cachedBlocks != null) {
          for (Iterator<CachedBlock> iter = cachedBlocks.iterator();
              iter.hasNext(); ) {
            CachedBlock cachedBlock = iter.next();
            numCachedBlocks++;
            numCachedReplicas += cachedBlock.getDatanodes(Type.CACHED).size();
          }
        }
      } finally {
        namesystem.readUnlock();
      }

      LOG.info(logString + " cached blocks: have " + numCachedBlocks +
          " / " + expectedCachedBlocks + ".  " +
          "cached replicas: have " + numCachedReplicas +
          " / " + expectedCachedReplicas);

      if (expectedCachedBlocks == -1 ||
          numCachedBlocks == expectedCachedBlocks) {
        if (expectedCachedReplicas == -1 ||
            numCachedReplicas == expectedCachedReplicas) {
          return true;
        }
      }
      return false;
    }
  }, 500, 60000);
}

项目：hadoop-plus 文件：INodeMap.java

private INodeMap(GSet<INode, INodeWithAdditionalFields> map) {
  Preconditions.checkArgument(map != null);
  this.map = map;
}

项目：FlexMap 文件：INodeMap.java

private INodeMap(GSet<INode, INodeWithAdditionalFields> map) {
  Preconditions.checkArgument(map != null);
  this.map = map;
}

项目：FlexMap 文件：CacheManager.java

@VisibleForTesting
public GSet<CachedBlock, CachedBlock> getCachedBlocks() {
  assert namesystem.hasReadLock();
  return cachedBlocks;
}

项目：FlexMap 文件：TestCacheDirectives.java

/**
 * Wait for the NameNode to have an expected number of cached blocks
 * and replicas.
 * @param nn NameNode
 * @param expectedCachedBlocks if -1, treat as wildcard
 * @param expectedCachedReplicas if -1, treat as wildcard
 * @throws Exception
 */
private static void waitForCachedBlocks(NameNode nn,
    final int expectedCachedBlocks, final int expectedCachedReplicas,
    final String logString) throws Exception {
  final FSNamesystem namesystem = nn.getNamesystem();
  final CacheManager cacheManager = namesystem.getCacheManager();
  LOG.info("Waiting for " + expectedCachedBlocks + " blocks with " +
           expectedCachedReplicas + " replicas.");
  GenericTestUtils.waitFor(new Supplier<Boolean>() {
    @Override
    public Boolean get() {
      int numCachedBlocks = 0, numCachedReplicas = 0;
      namesystem.readLock();
      try {
        GSet<CachedBlock, CachedBlock> cachedBlocks =
            cacheManager.getCachedBlocks();
        if (cachedBlocks != null) {
          for (Iterator<CachedBlock> iter = cachedBlocks.iterator();
              iter.hasNext(); ) {
            CachedBlock cachedBlock = iter.next();
            numCachedBlocks++;
            numCachedReplicas += cachedBlock.getDatanodes(Type.CACHED).size();
          }
        }
      } finally {
        namesystem.readUnlock();
      }

      LOG.info(logString + " cached blocks: have " + numCachedBlocks +
          " / " + expectedCachedBlocks + ".  " +
          "cached replicas: have " + numCachedReplicas +
          " / " + expectedCachedReplicas);

      if (expectedCachedBlocks == -1 ||
          numCachedBlocks == expectedCachedBlocks) {
        if (expectedCachedReplicas == -1 ||
            numCachedReplicas == expectedCachedReplicas) {
          return true;
        }
      }
      return false;
    }
  }, 500, 60000);
}

项目：hadoop-TCP 文件：INodeMap.java

private INodeMap(GSet<INode, INodeWithAdditionalFields> map) {
  Preconditions.checkArgument(map != null);
  this.map = map;
}

项目：hardfs 文件：INodeMap.java

private INodeMap(GSet<INode, INodeWithAdditionalFields> map) {
  Preconditions.checkArgument(map != null);
  this.map = map;
}

项目：hadoop-on-lustre2 文件：INodeMap.java

private INodeMap(GSet<INode, INodeWithAdditionalFields> map) {
  Preconditions.checkArgument(map != null);
  this.map = map;
}

项目：hadoop-on-lustre2 文件：CacheManager.java

@VisibleForTesting
public GSet<CachedBlock, CachedBlock> getCachedBlocks() {
  assert namesystem.hasReadLock();
  return cachedBlocks;
}

项目：hadoop-on-lustre2 文件：TestCacheDirectives.java

/**
 * Wait for the NameNode to have an expected number of cached blocks
 * and replicas.
 * @param nn NameNode
 * @param expectedCachedBlocks if -1, treat as wildcard
 * @param expectedCachedReplicas if -1, treat as wildcard
 * @throws Exception
 */
private static void waitForCachedBlocks(NameNode nn,
    final int expectedCachedBlocks, final int expectedCachedReplicas,
    final String logString) throws Exception {
  final FSNamesystem namesystem = nn.getNamesystem();
  final CacheManager cacheManager = namesystem.getCacheManager();
  LOG.info("Waiting for " + expectedCachedBlocks + " blocks with " +
           expectedCachedReplicas + " replicas.");
  GenericTestUtils.waitFor(new Supplier<Boolean>() {
    @Override
    public Boolean get() {
      int numCachedBlocks = 0, numCachedReplicas = 0;
      namesystem.readLock();
      try {
        GSet<CachedBlock, CachedBlock> cachedBlocks =
            cacheManager.getCachedBlocks();
        if (cachedBlocks != null) {
          for (Iterator<CachedBlock> iter = cachedBlocks.iterator();
              iter.hasNext(); ) {
            CachedBlock cachedBlock = iter.next();
            numCachedBlocks++;
            numCachedReplicas += cachedBlock.getDatanodes(Type.CACHED).size();
          }
        }
      } finally {
        namesystem.readUnlock();
      }
      if (expectedCachedBlocks == -1 ||
          numCachedBlocks == expectedCachedBlocks) {
        if (expectedCachedReplicas == -1 ||
            numCachedReplicas == expectedCachedReplicas) {
          return true;
        }
      }
      LOG.info(logString + " cached blocks: have " + numCachedBlocks +
          " / " + expectedCachedBlocks + ".  " +
          "cached replicas: have " + numCachedReplicas +
          " / " + expectedCachedReplicas);
      return false;
    }
  }, 500, 60000);
}