public static int capacity(HashConfigWrapper conf, int size) { return capacity(conf, size, false); }
public static int nearestGreaterCapacity(int desiredCapacity, int currentSize) { return nearestGreaterCapacity(desiredCapacity, currentSize, false); }
public static long nearestGreaterCapacity(long desiredCapacity, long currentSize) { assert desiredCapacity >= 0L : "desiredCapacity must be non-negative"; if (desiredCapacity <= (long) MAX_REGULAR_INT_CAPACITY) return (long) nearestGreaterCapacity((int) desiredCapacity, (int) currentSize, false); if (desiredCapacity <= MAX_REGULAR_LONG_CAPACITY) { int capIndex = binarySearch(REGULAR_LONG_CAPACITIES, desiredCapacity); return capIndex < 0 ? REGULAR_LONG_CAPACITIES[~capIndex] : desiredCapacity; } return extraLargeCapacity(desiredCapacity); }
public static long capacity(HashConfigWrapper conf, long size) { assert size >= 0L : "size must be non-negative"; long desiredCapacity = conf.targetCapacity(size); if (desiredCapacity <= (long) MAX_REGULAR_INT_CAPACITY) return (long) capacity(conf, (int) size, (int) desiredCapacity, false); if (desiredCapacity <= MAX_REGULAR_LONG_CAPACITY) { int capIndex = binarySearch(REGULAR_LONG_CAPACITIES, desiredCapacity); if (capIndex >= 0) return desiredCapacity; capIndex = ~capIndex; long lesserCapacity = capIndex > 0 ? REGULAR_LONG_CAPACITIES[capIndex - 1] : (long) MAX_REGULAR_INT_CAPACITY; long greaterCapacity = REGULAR_CHAR_CAPACITIES[capIndex]; return chooseBetter(conf, size, desiredCapacity, lesserCapacity, greaterCapacity, greaterCapacity); } return extraLargeCapacity(desiredCapacity); }
private boolean isMaxCapacity(int capacity) { return QHashCapacities.isMaxCapacity(capacity, doubleSizedArrays()); }
private static long extraLargeCapacity(long desiredCapacity) { for (long c = desiredCapacity; c < Long.MAX_VALUE; c++) { if (isQHashPrime(c)) return c; } throw new IllegalArgumentException( "There isn't long qHash capacities higher than " + desiredCapacity); }
public static void main(String[] args) { long power = Long.parseLong(args[0]); double maxDiff = Double.parseDouble(args[1]); long[] capacities = generateRegularCapacities(1L << power, maxDiff); for (int i = 0; i < capacities.length; i += 10) { for (int j = i; j < Math.min(i + 10, capacities.length); j++) { System.out.print(capacities[j] + ", "); } System.out.println(); } }
private static boolean isQHashPrime(long i) { return (i % 4L == 3L) && isPrime(i); }
public static long capacity(HashConfigWrapper conf, long size) { assert size >= 0L : "size must be non-negative"; long desiredCapacity = conf.targetCapacity(size); if (desiredCapacity <= (long) MAX_REGULAR_INT_CAPACITY) return (long) capacity(conf, (int) size, (int) desiredCapacity, false); if (desiredCapacity <= MAX_REGULAR_LONG_CAPACITY) { int capIndex = binarySearch(REGULAR_LONG_CAPACITIES, desiredCapacity); if (capIndex >= 0) return desiredCapacity; capIndex = ~capIndex; long lesserCapacity = capIndex > 0 ? REGULAR_LONG_CAPACITIES[capIndex - 1] : (long) MAX_REGULAR_INT_CAPACITY; long greaterCapacity = REGULAR_CHAR_CAPACITIES[capIndex]; return chooseBetter(conf, size, desiredCapacity, lesserCapacity, greaterCapacity, greaterCapacity); } return extraLargeCapacity(desiredCapacity); }
private boolean isMaxCapacity(int capacity) { return QHashCapacities.isMaxCapacity(capacity, doubleSizedArrays()); }
private static long extraLargeCapacity(long desiredCapacity) { for (long c = desiredCapacity; c < Long.MAX_VALUE; c++) { if (isQHashPrime(c)) return c; } throw new IllegalArgumentException( "There isn't long qHash capacities higher than " + desiredCapacity); }
public static void main(String[] args) { long power = Long.parseLong(args[0]); double maxDiff = Double.parseDouble(args[1]); long[] capacities = generateRegularCapacities(1L << power, maxDiff); for (int i = 0; i < capacities.length; i += 10) { for (int j = i; j < Math.min(i + 10, capacities.length); j++) { System.out.print(capacities[j] + ", "); } System.out.println(); } }
private static boolean isQHashPrime(long i) { return (i % 4L == 3L) && isPrime(i); }
public static int capacity(HashConfigWrapper conf, int size) { return capacity(conf, size, false); }
public static int nearestGreaterCapacity(int desiredCapacity, int currentSize) { return nearestGreaterCapacity(desiredCapacity, currentSize, false); }
public static long nearestGreaterCapacity(long desiredCapacity, long currentSize) { assert desiredCapacity >= 0L : "desiredCapacity must be non-negative"; if (desiredCapacity <= (long) MAX_REGULAR_INT_CAPACITY) return (long) nearestGreaterCapacity((int) desiredCapacity, (int) currentSize, false); if (desiredCapacity <= MAX_REGULAR_LONG_CAPACITY) { int capIndex = binarySearch(REGULAR_LONG_CAPACITIES, desiredCapacity); return capIndex < 0 ? REGULAR_LONG_CAPACITIES[~capIndex] : desiredCapacity; } return extraLargeCapacity(desiredCapacity); }
private boolean isMaxCapacity(int capacity) { return QHashCapacities.isMaxCapacity(capacity, doubleSizedArrays()); }
long highPrime; for (long i = limit - 1L; ; i--) { if (isQHashPrime(i)) { highPrime = i; capacities.add(highPrime); long qPrimeNearToPowerOf2 = 0L; for (long i = minPrevPrime; i < highPrime; i++) { if (isQHashPrime(i)) { long lowerPowerOf2 = Long.highestOneBit(i); long avoidDiffWithPowerOf2 = lowerPowerOf2 >> avoidBitsAroundPowersOf2; break; for (long j = lowerPowerOf2 + avoidDiffWithPowerOf2; j > i; j--) { if (isQHashPrime(j)) { qPrimeNearToPowerOf2 = j; break; for (long j = higherPowerOf2 + avoidDiffWithPowerOf2; abs(higherPowerOf2 - i) < abs(higherPowerOf2 - j); j--) { if (isQHashPrime(j)) { qPrimeNearToPowerOf2 = j; break; if (isQHashPrime(i)) capacities.add(i);
/** For initial hash table construction and rehash to target load (shrink, tombstones purge). */ public static int capacity(HashConfigWrapper conf, int size, boolean doubleSizedArrays) { assert size >= 0 : "size must be non-negative"; return capacity(conf, size, conf.targetCapacity(size), doubleSizedArrays); }
private boolean tryRehashForExpansion() { int newCapacity = nearestGreaterCapacity(config.grow(capacity()), currentOrdinal, false); if (newCapacity > capacity()) { rehashTimer.start(); rehash(newCapacity); rehashCount++; rehashTimer.stop(); return true; } else { return false; } }