How to use

getHash

method

in

org.h2.mvstore.cache.CacheLongKeyLIRS

private void addToMap(Entry<V> e) {
  int index = getHash(e.key) & mask;
  e.mapNext = entries[index];
  entries[index] = e;
  usedMemory += e.memory;
  mapSize++;
}

/**
 * Check whether there is a resident entry for the given key. This
 * method does not adjust the internal state of the cache.
 *
 * @param key the key (may not be null)
 * @return true if there is a resident entry
 */
public boolean containsKey(long key) {
  int hash = getHash(key);
  return getSegment(hash).containsKey(key, hash);
}

/**
 * Get the value for the given key if the entry is cached. This method
 * adjusts the internal state of the cache sometimes, to ensure commonly
 * used entries stay in the cache.
 *
 * @param key the key (may not be null)
 * @return the value, or null if there is no resident entry
 */
public V get(long key) {
  int hash = getHash(key);
  return getSegment(hash).get(key, hash);
}

/**
 * Get the memory used for the given key.
 *
 * @param key the key (may not be null)
 * @return the memory, or 0 if there is no resident entry
 */
public int getMemory(long key) {
  int hash = getHash(key);
  return getSegment(hash).getMemory(key, hash);
}

private Entry<V> find(long key) {
  int hash = getHash(key);
  return getSegment(hash).find(key, hash);
}

/**
 * Add an entry to the cache. The entry may or may not exist in the
 * cache yet. This method will usually mark unknown entries as cold and
 * known entries as hot.
 *
 * @param key the key (may not be null)
 * @param value the value (may not be null)
 * @param memory the memory used for the given entry
 * @return the old value, or null if there was no resident entry
 */
public V put(long key, V value, int memory) {
  int hash = getHash(key);
  int segmentIndex = getSegmentIndex(hash);
  Segment<V> s = segments[segmentIndex];
  // check whether resize is required: synchronize on s, to avoid
  // concurrent resizes (concurrent reads read
  // from the old segment)
  synchronized (s) {
    s = resizeIfNeeded(s, segmentIndex);
    return s.put(key, hash, value, memory);
  }
}

/**
 * Remove an entry. Both resident and non-resident entries can be
 * removed.
 *
 * @param key the key (may not be null)
 * @return the old value, or null if there was no resident entry
 */
public V remove(long key) {
  int hash = getHash(key);
  int segmentIndex = getSegmentIndex(hash);
  Segment<V> s = segments[segmentIndex];
  // check whether resize is required: synchronize on s, to avoid
  // concurrent resizes (concurrent reads read
  // from the old segment)
  synchronized (s) {
    s = resizeIfNeeded(s, segmentIndex);
    return s.remove(key, hash);
  }
}

private void evictBlock() {
  // ensure there are not too many hot entries: right shift of 5 is
  // division by 32, that means if there are only 1/32 (3.125%) or
  // less cold entries, a hot entry needs to become cold
  while (queueSize <= (mapSize >>> 5) && stackSize > 0) {
    convertOldestHotToCold();
  }
  // the oldest resident cold entries become non-resident
  while (usedMemory > maxMemory && queueSize > 0) {
    Entry<V> e = queue.queuePrev;
    usedMemory -= e.memory;
    removeFromQueue(e);
    e.value = null;
    e.memory = 0;
    addToQueue(queue2, e);
    // the size of the non-resident-cold entries needs to be limited
    int maxQueue2Size = nonResidentQueueSize * (mapSize - queue2Size);
    if (maxQueue2Size >= 0) {
      while (queue2Size > maxQueue2Size) {
        e = queue2.queuePrev;
        int hash = getHash(e.key);
        remove(e.key, hash);
      }
    }
  }
}

Entry<V> e = find(s.key, getHash(s.key));
if (e == null) {
  e = copy(s);
Entry<V> e = find(s.key, getHash(s.key));
if (e == null) {
  e = copy(s);

private void addToMap(Entry<V> e) {
  int index = getHash(e.key) & mask;
  e.mapNext = entries[index];
  entries[index] = e;
  usedMemory += e.memory;
  mapSize++;
}

private void addToMap(Entry<V> e) {
  int index = getHash(e.key) & mask;
  e.mapNext = entries[index];
  entries[index] = e;
  usedMemory += e.memory;
  mapSize++;
}

private Entry<V> find(long key) {
  int hash = getHash(key);
  return getSegment(hash).find(key, hash);
}

private Entry<V> find(long key) {
  int hash = getHash(key);
  return getSegment(hash).find(key, hash);
}

/**
 * Get the memory used for the given key.
 *
 * @param key the key (may not be null)
 * @return the memory, or 0 if there is no resident entry
 */
public int getMemory(long key) {
  int hash = getHash(key);
  return getSegment(hash).getMemory(key, hash);
}

/**
 * Get the value for the given key if the entry is cached. This method
 * adjusts the internal state of the cache sometimes, to ensure commonly
 * used entries stay in the cache.
 *
 * @param key the key (may not be null)
 * @return the value, or null if there is no resident entry
 */
public V get(long key) {
  int hash = getHash(key);
  return getSegment(hash).get(key, hash);
}

/**
 * Check whether there is a resident entry for the given key. This
 * method does not adjust the internal state of the cache.
 *
 * @param key the key (may not be null)
 * @return true if there is a resident entry
 */
public boolean containsKey(long key) {
  int hash = getHash(key);
  return getSegment(hash).containsKey(key, hash);
}

/**
 * Get the value for the given key if the entry is cached. This method
 * adjusts the internal state of the cache sometimes, to ensure commonly
 * used entries stay in the cache.
 *
 * @param key the key (may not be null)
 * @return the value, or null if there is no resident entry
 */
public V get(long key) {
  int hash = getHash(key);
  return getSegment(hash).get(key, hash);
}

/**
 * Check whether there is a resident entry for the given key. This
 * method does not adjust the internal state of the cache.
 *
 * @param key the key (may not be null)
 * @return true if there is a resident entry
 */
public boolean containsKey(long key) {
  int hash = getHash(key);
  return getSegment(hash).containsKey(key, hash);
}

/**
 * Get the value for the given key if the entry is cached. This method
 * adjusts the internal state of the cache sometimes, to ensure commonly
 * used entries stay in the cache.
 *
 * @param key the key (may not be null)
 * @return the value, or null if there is no resident entry
 */
public V get(long key) {
  int hash = getHash(key);
  return getSegment(hash).get(key, hash);
}

/**
 * Check whether there is a resident entry for the given key. This
 * method does not adjust the internal state of the cache.
 *
 * @param key the key (may not be null)
 * @return true if there is a resident entry
 */
public boolean containsKey(long key) {
  int hash = getHash(key);
  return getSegment(hash).containsKey(key, hash);
}