io.questdb.std.Hash Maven / Gradle / Ivy
/*******************************************************************************
* ___ _ ____ ____
* / _ \ _ _ ___ ___| |_| _ \| __ )
* | | | | | | |/ _ \/ __| __| | | | _ \
* | |_| | |_| | __/\__ \ |_| |_| | |_) |
* \__\_\\__,_|\___||___/\__|____/|____/
*
* Copyright (c) 2014-2019 Appsicle
* Copyright (c) 2019-2020 QuestDB
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
package io.questdb.std;
public final class Hash {
static final int HASH_BITS = 0x7fffffff;
private Hash() {
}
/**
* Restricts hashCode() of the underlying char sequence to be no greater than max.
*
* @param s char sequence
* @param max max value of hashCode()
* @return power of 2 integer
*/
public static int boundedHash(CharSequence s, int max) {
return s == null ? -1 : (Chars.hashCode(s) & 0xFFFFFFF) & max;
}
/**
* Calculates positive integer hash of memory pointer using Java hashcode() algorithm.
*
* @param p memory pointer
* @param len memory length in bytes
* @return hash code
*/
public static int hashMem(long p, int len) {
long hash = 0;
final long hi = p + len;
while (hi - p > 7) {
hash = (hash << 5) - hash + Unsafe.getUnsafe().getLong(p);
p += Long.BYTES;
}
while (p < hi) {
hash = (hash << 5) - hash + Unsafe.getUnsafe().getByte(p++);
}
return spread((int) hash);
}
/**
* (copied from ConcurrentHashMap)
* Spreads (XORs) higher bits of hash to lower and also forces top
* bit to 0. Because the table uses power-of-two masking, sets of
* hashes that vary only in bits above the current mask will
* always collide. (Among known examples are sets of Float keys
* holding consecutive whole numbers in small tables.) So we
* apply a transform that spreads the impact of higher bits
* downward. There is a trade off between speed, utility, and
* quality of bit-spreading. Because many common sets of hashes
* are already reasonably distributed (so don't benefit from
* spreading), and because we use trees to handle large sets of
* collisions in bins, we just XOR some shifted bits in the
* cheapest possible way to reduce systematic lossage, as well as
* to incorporate impact of the highest bits that would otherwise
* never be used in index calculations because of table bounds.
*
* @param h hash code
* @return adjusted hash code
*/
public static int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}
}