void updateSketch(const DataTypeT& data)
{
uint64_t v = MurmurHash64A(&data,
sizeof(DataTypeT), seed_);
uint32_t bit = (v & 0xFFFFFFFF) % BITSIZE;
sketch_.set(bit);
}
void updateSketch(const DataTypeT& data)
{
uint64_t v = MurmurHash64A(&data,
sizeof(DataTypeT), seed_);
uint8_t lsb = LSB(v/fm_k_);
sketch_[v % fm_k_].set(lsb);
level2sketches_[v % fm_k_].updateBucket(lsb, data);
}
static unsigned long
hs_hash(const void *object, unsigned long seed)
{
const char *c = object;
unsigned long h;
h = (unsigned long)MurmurHash64A(c, strlen(c), seed);
return h;
}
ERL_NIF_TERM
erlang_murmurhash64a_1_impl(ErlNifEnv* env, int, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin;
uint64_t h;
if (!check_and_unpack_data(env, argv[0], &bin)) {
return enif_make_badarg(env);
}
h = MurmurHash64A(bin.data, bin.size, 0);
return enif_make_uint64(env, h);
}
void test_updateM() {
byte results[] = {3, 4, 3, 3};
uint b = 2;
Hyperloglog *hll = create_hll(b, 0);
uint64_t digest;
for (uint32_t i = 0; i < 10; i++) {
digest = MurmurHash64A(&i, 4, 42);
updateM(hll, digest);
}
assert_array_eq(results, hll->M, hll->m, byte);
free(hll);
}
const font_setting_cache *gdimm_setting_cache::lookup(const gdimm_setting_trait *setting_trait)
{
#ifdef _M_X64
uint64_t cache_trait = MurmurHash64A(setting_trait, sizeof(gdimm_setting_trait), 0);
#else
uint64_t cache_trait = MurmurHash64B(setting_trait, sizeof(gdimm_setting_trait), 0);
#endif // _M_X64
// if the setting for the specified font is not found
// construct setting cache for the font and return
map<uint64_t, font_setting_cache>::const_iterator iter = _cache.find(cache_trait);
if (iter == _cache.end())
{
// double-check lock
gdimm_lock lock(LOCK_SETTING_CACHE);
iter = _cache.find(cache_trait);
if (iter == _cache.end())
{
font_setting_cache new_cache;
wcs_convert(gdipp_get_gdimm_setting(L"auto_hinting", setting_trait), reinterpret_cast<WORD *>(&new_cache.auto_hinting));
wcs_convert(gdipp_get_gdimm_setting(L"embedded_bitmap", setting_trait), &new_cache.embedded_bitmap);
wcs_convert(gdipp_get_gdimm_setting(L"embolden", setting_trait), &new_cache.embolden);
wcs_convert(gdipp_get_gdimm_setting(L"gamma/red", setting_trait), &new_cache.gamma.red);
wcs_convert(gdipp_get_gdimm_setting(L"gamma/green", setting_trait), &new_cache.gamma.green);
wcs_convert(gdipp_get_gdimm_setting(L"gamma/blue", setting_trait), &new_cache.gamma.blue);
wcs_convert(gdipp_get_gdimm_setting(L"hinting", setting_trait), reinterpret_cast<WORD *>(&new_cache.hinting));
wcs_convert(gdipp_get_gdimm_setting(L"kerning", setting_trait), &new_cache.kerning);
wcs_convert(gdipp_get_gdimm_setting(L"renderer", setting_trait), reinterpret_cast<WORD *>(&new_cache.renderer));
wcs_convert(gdipp_get_gdimm_setting(L"render_mode/mono", setting_trait), reinterpret_cast<WORD *>(&new_cache.render_mode.mono));
wcs_convert(gdipp_get_gdimm_setting(L"render_mode/gray", setting_trait), reinterpret_cast<WORD *>(&new_cache.render_mode.gray));
wcs_convert(gdipp_get_gdimm_setting(L"render_mode/subpixel", setting_trait), reinterpret_cast<WORD *>(&new_cache.render_mode.subpixel));
wcs_convert(gdipp_get_gdimm_setting(L"render_mode/pixel_geometry", setting_trait), reinterpret_cast<WORD *>(&new_cache.render_mode.pixel_geometry));
wcs_convert(gdipp_get_gdimm_setting(L"render_mode/aliased_text", setting_trait), reinterpret_cast<WORD *>(&new_cache.render_mode.aliased_text));
wcs_convert(gdipp_get_gdimm_setting(L"shadow/offset_x", setting_trait), &new_cache.shadow.offset_x);
wcs_convert(gdipp_get_gdimm_setting(L"shadow/offset_x", setting_trait), &new_cache.shadow.offset_y);
wcs_convert(gdipp_get_gdimm_setting(L"shadow/alpha", setting_trait), reinterpret_cast<WORD *>(&new_cache.shadow.alpha));
_cache[cache_trait] = new_cache;
}
}
return &_cache[cache_trait];
}
static bucket2 * search_kmer ( hashtable2 * ht, kmer_t2 * t_kmer )
{
uint64_t hv = MurmurHash64A ( t_kmer, sizeof ( kmer_t2 ), 0 );
size_t hash_idx = ( size_t ) ( hv % ht->ht_sz );
bucket2 * starter = ht->store_pos[hash_idx];
while ( starter )
{
if ( kmerCompare ( & ( starter->kmer_t2 ), t_kmer ) == 0 )
{
return starter;
}
starter = starter->nxt_bucket;
}
return NULL;
}
static vertex2 * search_vertex ( vertex_hash2 * v_ht, kmer_t2 * vertex_kmer ) //fixed ...
{
uint64_t hv = MurmurHash64A ( vertex_kmer->kmer, sizeof ( kmer_t2 ), 0 ); //hash value
uint64_t idx = ( size_t ) ( hv % v_ht->ht_sz );
vertex2 * ver = ( v_ht->store_pos ) [idx];
while ( ver )
{
if ( kmerCompare ( & ( ver->kmer_t2 ), vertex_kmer ) == 0 )
{
return ver;
}
ver = ver->next;
}
return NULL;
}
void ring_murmurhash64a(void *pPointer)
{
char *key = NULL;
int keylen;
int seed = 0;
uint64_t out;
int ret_type = 0;
if (RING_API_PARACOUNT < 2 || RING_API_PARACOUNT > 3) {
RING_API_ERROR(RING_API_MISS2PARA);
return ;
}
if (!RING_API_ISSTRING(1)) {
RING_API_ERROR("murmurhash64a expects the first parameter to be a string");
return;
}
if (!RING_API_ISNUMBER(2)) {
RING_API_ERROR("murmurhash64a expects the first parameter to be an integer");
return;
}
key = RING_API_GETSTRING(1);
keylen = strlen(key);
seed = RING_API_GETNUMBER(2);
if (RING_API_PARACOUNT == 3) {
if (RING_API_ISNUMBER(3)) {
ret_type = RING_API_GETNUMBER(3);
if (!is_bool(ret_type)) {
RING_API_ERROR("Third parameter should be boolean value\n");
}
} else {
RING_API_ERROR("murmurhash64a expects the third parameter to be an integer\n");
}
}
out = MurmurHash64A(key, keylen, seed);
MH_RETURN_LONG(out, ret_type);
}
static ssize_t murmur2_64_handler(machine_t *machine, request_t *request){ // {{{
uint64_t hash = 0;
data_t *key = NULL;
murmur_userdata *userdata = (murmur_userdata *)machine->userdata;
key = hash_data_find(request, userdata->input);
if(key == NULL){
if(userdata->fatal == 0)
return machine_pass(machine, request);
return error("input key not supplied");
}
hash = MurmurHash64A(key, 0);
request_t r_next[] = {
{ userdata->output, DATA_UINT64T(hash) },
hash_next(request)
};
return machine_pass(machine, r_next);
} // }}}
sqlite3_stmt *YesqlClient::construct_sql_insert(const TableId& table, const Key& key, const ValueMap& values){
sqlite3_stmt* ret = nullptr;
bool prepared = false;
std::string sql;
sql.append("INSERT OR REPLACE INTO ");
sql.append(table);
sql.append(" (");
sql.append(KEYNAME);
sql.append(",");
for (auto& it: values){
sql.append(it.first);
sql.append(",");
}
sql.back() = ')';
sql.append(" VALUES (");
sql.append("?,");
for (auto& it : values){
sql.append("?,");
}
sql.back() = ')';
int rc = stmt_cache(STMT_INDEX_INSERT, sql.c_str(), &ret);
if (rc == SQLITE_OK){
int count = 1;
rc = sqlite3_bind_int64(ret, count++, MurmurHash64A(key.c_str(), (int) key.length()));
//rc = sqlite3_bind_text(ret, count++, key.c_str(), (int) key.length(), SQLITE_STATIC);
for (auto& it : values){
if (rc != SQLITE_OK) break;
rc = sqlite3_bind_text(ret, count++, it.second.c_str(), (int) it.second.length(), SQLITE_STATIC);
}
}
if (rc != SQLITE_OK){
LOG("Error %s insert: %s\n\tSQL was: %s\n", (prepared) ? "binding" : "preparing",
sqlite3_errmsg(_dbhandle), sql.c_str());
//sqlite3_finalize(ret);
ret = nullptr;
}
return ret;
}
static vertex2 * put_vertex ( vertex_hash2 * v_ht, kmer_t2 vertex_kmer, int & is_found ) //63 127 differ fixed
{
uint64_t hv = MurmurHash64A ( vertex_kmer.kmer, sizeof ( kmer_t2 ), 0 ); //hash value
uint64_t idx = ( size_t ) ( hv % v_ht->ht_sz );
vertex2 * ver = ( v_ht->store_pos ) [idx];
if ( !ver )
{
( v_ht->store_pos ) [idx] = ( vertex2 * ) malloc ( sizeof ( vertex2 ) );
ver = ( v_ht->store_pos ) [idx];
ver->kmer_t2 = vertex_kmer;
ver->left = NULL;
ver->right = NULL;
ver->next = NULL;
is_found = 0;
return ver;
}
while ( ver )
{
if ( kmerCompare ( & ( ver->kmer_t2 ), &vertex_kmer ) == 0 )
{
is_found = 1;
return ver;
}
if ( ver->next == NULL ) { break; }
ver = ver->next;
}
is_found = 0;
ver->next = ( vertex2 * ) malloc ( sizeof ( vertex2 ) );
ver->next->kmer_t2 = vertex_kmer;
ver->next->left = NULL;
ver->next->right = NULL;
ver->next->next = NULL;
return ver->next;
}
sqlite3_stmt *YesqlClient::construct_sql_update(const TableId& table, const Key& key, const ValueMap& values){
sqlite3_stmt* ret = nullptr;
bool prepared = false;
std::string sql;
sql.append("UPDATE OR FAIL ");
sql.append(table);
sql.append(" SET ");
for (auto& it : values){
sql.append(it.first);
sql.append("=upper(");
sql.append(it.first);
sql.append("),");
}
sql.back() = ' ';
sql.append("WHERE ");
sql.append(KEYNAME);
sql.append("=?");
int rc = stmt_cache(STMT_INDEX_UPDATE, sql.c_str(), &ret);
if (rc == SQLITE_OK){
int count = 1;
prepared = true;
//for (auto& it : values){
// rc = sqlite3_bind_text(ret, count++, it.second.c_str(), (int) it.second.length(), SQLITE_STATIC);
// if (rc != SQLITE_OK) break;
//}
rc = sqlite3_bind_int64(ret, count, MurmurHash64A(key.c_str(), (int) key.length()));
//rc = sqlite3_bind_text(ret, count, key.c_str(), (int) key.length(), SQLITE_STATIC);
}
if (rc != SQLITE_OK){
LOG("Error %s update: %s\n\tSQL was: %s\n", (prepared) ? "binding" : "preparing",
sqlite3_errmsg(_dbhandle), sql.c_str());
//sqlite3_finalize(ret);
ret = nullptr;
}
return ret;
}
uint64_t hash(void *key) {
return MurmurHash64A(key, 8, 0x9747b28c);
}
inline uint64_t get_hash() {
return MurmurHash64A(&key, sizeof(key), 0x818c4070) & ary->size_mask;
}
/**
* eblob_l2hash_key() - second hash for eblob key
*/
static inline __attribute_pure__
eblob_l2hash_t eblob_l2hash_key(const struct eblob_key *key)
{
assert(key != NULL);
return MurmurHash64A(key, EBLOB_ID_SIZE, 0);
}
inline int bind_key(sqlite3_stmt* stmt, const Key& key){
return sqlite3_bind_int64(stmt, 1, MurmurHash64A(key.c_str(), (int) key.length()));
//return sqlite3_bind_text(stmt, 1, key.c_str(), (int) key.length(), SQLITE_STATIC);
}
size_t session_hash::operator()(const session_key& sk) const {
return MurmurHash64A(&sk, sizeof(sk), 0xee6b27eb);
}