hash_u getHash(const char * seq, int length) { //for ( int i = 0; i < length; i++ ) { cout << *(seq + i); } cout << endl; bool use64 = length > 16; char data[use64 ? 8 : 4]; #ifdef ARCH_32 MurmurHash3_x86_32(seq, length > 16 ? 16 : length, seed, data); if ( use64 ) { MurmurHash3_x86_32(seq + 16, length - 16, seed, data + 4); } #else MurmurHash3_x64_128(seq, length, seed, data); #endif hash_u hash; if ( use64 ) { hash.hash64 = *((hash64_t *)data); } else { hash.hash32 = *((hash32_t *)data); } return hash; }
void fillWriterVectors(const std::deque<BSONObj>& ops, std::vector<std::vector<BSONObj>>* writerVectors) { for (std::deque<BSONObj>::const_iterator it = ops.begin(); it != ops.end(); ++it) { const BSONElement e = it->getField("ns"); verify(e.type() == String); const char* ns = e.valuestr(); int len = e.valuestrsize(); uint32_t hash = 0; MurmurHash3_x86_32(ns, len, 0, &hash); const char* opType = it->getField("op").valuestrsafe(); if (getGlobalServiceContext()->getGlobalStorageEngine()->supportsDocLocking() && isCrudOpType(opType)) { BSONElement id; switch (opType[0]) { case 'u': id = it->getField("o2").Obj()["_id"]; break; case 'd': case 'i': id = it->getField("o").Obj()["_id"]; break; } const size_t idHash = BSONElement::Hasher()(id); MurmurHash3_x86_32(&idHash, sizeof(idHash), hash, &hash); } (*writerVectors)[hash % writerVectors->size()].push_back(*it); } }
static uint32_t add_to_filter(uint32_t filter, uint16_t value) { uint32_t hash1, hash2; MurmurHash3_x86_32((const void*)&value, 2, SEED1, (void*)&hash1); MurmurHash3_x86_32((const void*)&value, 2, SEED2, (void*)&hash2); return filter | hash1 | hash2; }
void checkInterface(struct MergedBloomFilter *mbf, unsigned char *key, int *MatchVector, int *default_router, uint32_t *interface_num) { char tmp[NAME_PREF_BUF]=""; int key_len, slash_count = 0; uint32_t hash1, hash2, hash3;//, Flug = 0, num = 0; int Flug = 0, num = 0; memset(tmp,0,NAME_PREF_BUF); /* printf("MatchVector : "); for(int i=NAME_PREF_LEN-1; i>=0; i--){ printf("%d",MatchVector[i]); if((i==24)||(i==16)||(i==8)) printf(" "); } printf("\n"); */ printf("---%s---\n",key); for(int i=NAME_PREF_LEN; i>=1; i--){ if(MatchVector[i-1]){ for(int j = 1; j <= strlen(key); j++) { //printf("%c\n",*(key+j)); if((*(key+j)=='/')||(*(key+j)=='\0')){ slash_count++; if(slash_count == i){ strncpy(tmp,key,j); tmp[j] = '\0'; printf("%s : ",tmp); key_len = strlen(tmp); hash1 = MurmurHash3_x86_32 (tmp, key_len, 1); hash2 = MurmurHash3_x86_32 (tmp, key_len, 2); hash3 = MurmurHash3_x86_32 (tmp, key_len, 3); //Flug = 0; checkMergedBloomFilter(mbf, hash1, hash2, hash3, &Flug, &num); //printf("tmp = %s\n",tmp); //printf("num = %u\n",num); //printf("Flug = %u\n",Flug); *interface_num = num; //if(Flug==1) break; //if((Flug==1)||(Flug==2)) break; if(Flug!=0) break; } } } //slash_count=0; if(Flug==1){ *default_router = 1; break; } } } if(Flug==2) *default_router = 2; printf("\n"); }
void makeHash(struct Name *list){ uint32_t len; char *tmp; for(int i=0; i<=NAME_PREF_LEN; i++){ struct List *node = list[i].next; for(; node != NULL; node = node->next){ len = strlen(node->NamePrefix); tmp = node->NamePrefix; node->hash1 = MurmurHash3_x86_32 (tmp, len, 1); node->hash2 = MurmurHash3_x86_32 (tmp, len, 2); node->hash3 = MurmurHash3_x86_32 (tmp, len, 3); } } }
//32bits template<> MurmurHash<32>::result_type MurmurHash<32>::salt(bool fixed) { if (fixed) { return result_type(0x58132134); } result_type h = 0; std::vector<zks::u8string> mac_addrs = get_mac_address(); for (size_t i = 0; i < mac_addrs.size(); ++i) { MurmurHash3_x86_32((void*) mac_addrs[i].data(), (int)mac_addrs[i].size(), h, (void*) &h); } std::time_t now = std::time(nullptr); char* nowstr = std::ctime(&now); MurmurHash3_x86_32((void*) nowstr, (int)std::strlen(nowstr), h, (void*) &h); return h; }
uint32_t flow_src_hash_bin(flow_src_t* p_flow_src, uint32_t map_size) { #ifdef FLOW_SRC uint32_t hash; MurmurHash3_x86_32((void*)(&(p_flow_src->srcip)), sizeof(p_flow_src->srcip), 42, &hash); hash = hash - map_size * (hash / map_size); // A % B <=> A – B * (A / B) //printf("srcip:%u, hash_bin:%u, map_size:%u\n", p_flow_src->srcip, hash, map_size); return hash; #endif #ifdef FLOW_SRC_DST uint32_t hash = 0; MurmurHash3_x86_32((void*)p_flow_src, sizeof(flow_src_t), 42, &hash); hash = hash - map_size * (hash / map_size); #endif }
ol_bucket *ol_get_bucket(const ol_database *db, const char *key, const size_t klen, char (*_key)[KEY_SIZE], size_t *_klen) { if (db == NULL) return NULL; uint32_t hash; _ol_trunc(key, klen, *_key); *_klen = strnlen(*_key, KEY_SIZE); if (*_klen == 0) return NULL; MurmurHash3_x86_32(*_key, *_klen, DEVILS_SEED, &hash); unsigned int index = _ol_calc_idx(db->cur_ht_size, hash); if (db->hashes[index] != NULL) { size_t larger_key = 0; ol_bucket *tmp_bucket; tmp_bucket = db->hashes[index]; larger_key = tmp_bucket->klen > klen ? tmp_bucket->klen : klen; if (strncmp(tmp_bucket->key, key, larger_key) == 0) { return tmp_bucket; } else if (tmp_bucket->next != NULL) { /* Keys were not the same, traverse the linked list to see if it's * farther down. */ do { tmp_bucket = tmp_bucket->next; larger_key = tmp_bucket->klen > klen ? tmp_bucket->klen : klen; if (strncmp(tmp_bucket->key, key, larger_key) == 0) return tmp_bucket; } while (tmp_bucket->next != NULL); } } return NULL; }
size_t BlockHashIndex::GetFprint(const char* key) const { size_t hash; MurmurHash3_x86_32(key, std::strlen(key), 100000, &hash); hash &= (1ul << m_fingerPrintBits) - 1; return hash; }
uint64_t Database::next_type_id() { Engine& engine = Engine::get_instance(); uint32_t shard; string id = SEQ_DATATYPE; MurmurHash3_x86_32(id.c_str(), id.size(), DataType::SEQUENCE, &shard); int size = id.size() + 32; uint64_t msg_id = engine.next_message_id(); _enc_declare_(req, size); _enc_put_msg_header_(req, MessageType::SEQ_TYPE, msg_id, shard); _enc_put_string_(req, id); _enc_update_msg_size_(req); servernode_ptr node = ring->get_node(shard); boost::scoped_ptr<ReplyContext> context(new ReplyContext(msg_id)); engine.save_context(context.get()); node->connection->send(_enc_data_(req), _enc_size_(req)); context->wait(); engine.release_context(context.get()); if (!context->done) return 0; int code; _dec_declare2_(rep, context->get_reply()->get_content_data(), context->get_reply()->get_content_size()); _dec_get_var32_(rep, code); uint64_t val; if (code == ErrorCode::OK) { _dec_get_var64_(rep, val); } if (!_dec_valid_(rep)) return 0; if (code != ErrorCode::OK) return 0; return val; }
/*U32 SGL_DataSaveShader(const char * filePath, const char* name) { U32 loc; U32 hash; SDL_RWops* rw; U32 size; U8* shaderData; { rw = SDL_RWFromFile(filePath, "rb"); if (rw == NULL) { SDL_Log("SGL_DataSaveShader couldn't open file in path: %s, SDL_Error:%s", filePath, SDL_GetError()); return SGL_FALSE; } size = SDL_RWseek(rw, 0, RW_SEEK_END); shaderData = SDL_malloc(size); SDL_RWseek(rw, 0, RW_SEEK_SET); if (SDL_RWread(rw, shaderData, size, 1) != 1) { SDL_RWclose(rw); SDL_Log("SGL_DataSaveShader couldn't read data from file in path: %s", filePath); return SGL_FALSE; } SDL_RWclose(rw); } targetData.block.shaderCount++; { rw = SDL_RWFromFile(targetData.path, "rb+"); if (rw == NULL) { SDL_Log("SGL_DataSaveShader couldn't open file in path: %s, SDL_Error:%s", targetData.path, SDL_GetError()); return SGL_FALSE; } loc = (U32)SDL_RWseek(rw, 0, RW_SEEK_END); if (SDL_RWwrite(rw, &size, sizeof(U32), 1) != 1) { SDL_RWclose(rw); SDL_Log("SGL_DataSaveShader couldn't write to data file in path: %s", targetData.path); return SGL_FALSE; } if (SDL_RWwrite(rw, shaderData, size, 1) != 1) { SDL_RWclose(rw); SDL_Log("SGL_DataSaveShader couldn't write to data file in path: %s", targetData.path); return SGL_FALSE; } SDL_RWseek(rw, 0, RW_SEEK_SET); if (SDL_RWwrite(rw, &targetData.block, sizeof(SGL_DataBlock), 1) != 1) { SDL_RWclose(rw); SDL_Log("SGL_DataSaveShader couldn't write to data file in path: %s, SDL_Error: %s", targetData.path, SDL_GetError()); return SGL_FALSE; } SDL_RWclose(rw); } MurmurHash3_x86_32(name, (I32)SDL_strlen(name), targetData.block.seed, &hash); return AddNode(hash, loc); return SGL_TRUE; }*/ SDL_Surface * SGL_DataLoadImage(const char * imageName) { U32 hash; MurmurHash3_x86_32(imageName, (I32)SDL_strlen(imageName), targetData.block.seed, &hash); U32 loc = FindNodeLoc(hash); if (loc == SGL_FALSE) { return NULL; } SDL_RWops* rw = SDL_RWFromFile(targetData.path, "rb"); if (rw == NULL) { SDL_Log("SGL_DataLoadImage couldn't open file in path: %s, SDL_Error:%s", targetData.path, SDL_GetError()); return NULL; } SDL_RWseek(rw, loc, RW_SEEK_SET); SGL_FileSurface surfData; if (SDL_RWread(rw, &surfData, sizeof(SGL_FileSurface), 1) != 1) { SDL_RWclose(rw); SDL_Log("SGL_DataSaveImage couldn't read data from file in path: %s", targetData.path); return NULL; } const size_t size = surfData.h * surfData.w * (surfData.depth/8); void* pixels = SDL_malloc(size); if (SDL_RWread(rw, pixels, size, 1) != 1) { SDL_RWclose(rw); SDL_Log("SGL_DataSaveImage couldn't read data from file in path: %s", targetData.path); return NULL; } return SDL_CreateRGBSurfaceFrom(pixels, surfData.w, surfData.h, surfData.depth, surfData.w*(surfData.depth / 8), surfData.Rmask, surfData.Gmask, surfData.Bmask, surfData.Amask); }
/* functions */ u3_noun u3qc_muk(u3_atom seed, u3_atom len, u3_atom key) { c3_w seed_w; c3_w len_w; c3_y *key_y; c3_w out_w; c3_assert(u3r_met(5, seed) <= 1); c3_assert(u3r_met(0, len) <= 31); c3_assert(u3r_met(3, key) <= len); seed_w = u3r_word(0, seed); len_w = u3r_word(0, len); if (len_w > 0) { /* can't u3a_calloc 0 bytes */ key_y = u3a_calloc(sizeof(c3_y), len); } else { key_y = 0; } u3r_bytes(0, len, key_y, key); MurmurHash3_x86_32(key_y, len, seed_w, &out_w); u3a_free(key_y); return u3i_words(1, &out_w); }
/** * Returns true if viewport should be squished for this shader. ***/ bool ShaderModificationRepository::SquishViewportForShader(IDirect3DVertexShader9* pActualVertexShader) { // Hash the shader BYTE *pData = NULL; UINT pSizeOfData; pActualVertexShader->GetFunction(NULL, &pSizeOfData); pData = new BYTE[pSizeOfData]; pActualVertexShader->GetFunction(pData,&pSizeOfData); uint32_t hash; MurmurHash3_x86_32(pData, pSizeOfData, VIREIO_SEED, &hash); delete[] pData; // find hash auto i = std::find(m_shaderViewportSquashIDs.begin(), m_shaderViewportSquashIDs.end(), hash); // found if (i != m_shaderViewportSquashIDs.end()) { return true; } return false; }
int HashMap::_GetHash(std::string read_id) { uint32_t hash_value = 0; MurmurHash3_x86_32(read_id.c_str(), strlen(read_id.c_str()), 0, &hash_value); return hash_value; }
uint32_t MurmurHash3_x86_32_i(const void * key, int len, uint32_t seed) { uint32_t out = 0; MurmurHash3_x86_32(key, len, seed, &out); return out; }
//128bit; template<> MurmurHash<128>::result_type MurmurHash<128>::salt(bool fixed) { if (fixed) { result_type ret; uint32_t* p = (uint32_t*)&ret; (*p++) = 0x58132134; (*p++) = 0x94827513; (*p++) = 0x16574893; (*p) = 0x17932864; return ret; } result_type h; uint32_t* p0 = (uint32_t*)&h; std::time_t now = std::time(nullptr); char* nowstr = std::ctime(&now); MurmurHash3_x86_32((void*)nowstr, (int)std::strlen(nowstr), 0, (void*)p0); std::vector<zks::u8string> mac_addrs = get_mac_address(); for (size_t i = 0; i < mac_addrs.size(); ++i) { #ifdef _ZKS64 MurmurHash3_x64_128((void*)mac_addrs[i].data(), (int)mac_addrs[i].size(), *p0, (void*)&h); #else MurmurHash3_x86_128((void*)mac_addrs[i].data(), (int)mac_addrs[i].size(), *p0, (void*)&h); #endif } return h; }
Cursor::Cursor(const CaptureConfig &config) { id cursor = cursor_currentSystemCursor(); BridgePoint hotSpot = cursor_hotSpot(cursor); BridgePoint mouseLocation = event_mouseLocation(); id cursorImage = cursor_image(cursor); id tiffData = cursorImage != nil ? image_TIFFRepresentation(cursorImage) : nil; if (tiffData == nil) { m_imageID = Cursor::blankCursor(); m_position.rx() = 0; m_position.ry() = 0; return; } MurmurHash3_x86_32( data_bytes(tiffData), data_length(tiffData), 0, &m_imageID); if (m_cachedImages.find(m_imageID) == m_cachedImages.end()) { m_cachedImages.insert(m_imageID); bridgeWriteCursorFile(tiffData, m_imageID); } // The NSCursor Y coordinate's origin is at the bottom of the screen. // Invert it. mouseLocation.y = QApplication::desktop()->screenGeometry().height() - mouseLocation.y; m_position.rx() = mouseLocation.x - hotSpot.x - config.captureX; m_position.ry() = mouseLocation.y - hotSpot.y - config.captureY; }
std::size_t InputLayoutCache::hashInputLayout(const InputLayoutKey &inputLayout) { static const unsigned int seed = 0xDEADBEEF; std::size_t hash = 0; MurmurHash3_x86_32(inputLayout.begin(), inputLayout.end() - inputLayout.begin(), seed, &hash); return hash; }
std::size_t RenderStateCache::hashBlendState(const BlendStateKey &blendState) { static const unsigned int seed = 0xABCDEF98; std::size_t hash = 0; MurmurHash3_x86_32(&blendState, sizeof(gl::BlendState), seed, &hash); return hash; }
std::size_t RenderStateCache::hashSamplerState(const gl::SamplerState &samplerState) { static const unsigned int seed = 0xABCDEF98; std::size_t hash = 0; MurmurHash3_x86_32(&samplerState, sizeof(gl::SamplerState), seed, &hash); return hash; }
std::size_t RenderStateCache::hashRasterizerState(const RasterizerStateKey &rasterState) { static const unsigned int seed = 0xABCDEF98; std::size_t hash = 0; MurmurHash3_x86_32(&rasterState, sizeof(RasterizerStateKey), seed, &hash); return hash; }
std::size_t RenderStateCache::hashDepthStencilState(const gl::DepthStencilState &dsState) { static const unsigned int seed = 0xABCDEF98; std::size_t hash = 0; MurmurHash3_x86_32(&dsState, sizeof(gl::DepthStencilState), seed, &hash); return hash; }
static guint32 rm_fmt_json_generate_id(RmFmtHandlerJSON *self, RmFile *file, const char *file_path, char *cksum) { guint32 hash = 0; hash = file->inode ^ file->dev; hash ^= file->actual_file_size; for(int i = 0; i < 8192; ++i) { hash ^= MurmurHash3_x86_32(file_path, strlen(file_path), i); hash ^= MurmurHash3_x86_32(cksum, strlen(cksum), i); if(!g_hash_table_contains(self->id_set, GUINT_TO_POINTER(hash))) { break; } } g_hash_table_add(self->id_set, GUINT_TO_POINTER(hash)); return hash; }
/** * Hash a paxos_connect identity descriptor, i.e., a string. */ unsigned connect_key_hash(const void *data) { uint32_t r; pax_str_t *str = (pax_str_t *)data; MurmurHash3_x86_32(str->data, str->size, murmurseed, &r); return r; }
uint32_t do_hash(char* key, size_t len) { uint32_t out; MurmurHash3_x86_32(key, len, 0, &out); return out; }
/** Calculate the hash value for a function memoization signature @param[in] functPointer: Pointer to a function @param[in] numArgs: Number of arguments for the function @param[in] sizeOfArgs: A sum of sizeOf for the type of all given arguments @param[in] argumentData: A pointer to a memory block that stores a copy of all argument values passed to the function during this call @return: A 32 bit hash value calculated from the input params */ inline uint32_t calc_hash_memoization_signature(memoization_function_pointer functPointer, unsigned int numArgs, unsigned int sizeOfArgs, void* argumentData){ uint32_t hashInputLen = SIZE_OF_ARGS(functPointer, numArgs, sizeOfArgs) + sizeOfArgs; void* hashInput = malloc(hashInputLen); uint32_t key = 0; uint32_t offset = 0; hashInput = STORE_ARGUMENTS(hashInput, offset, functPointer, sizeOfArgs); memcpy(hashInput+offset, argumentData, sizeOfArgs); MurmurHash3_x86_32(hashInput, hashInputLen, HASH_ALGORITHM_SEED, &key); free(hashInput); return key; }
void makeInterface(struct MergedBloomFilter *mbf, unsigned char *key, unsigned char *interface, uint32_t *port) { uint32_t len, interface_num = 0, hash1, hash2, hash3; len = strlen(key); for(int i = 0; i < strlen(interface); i++) interface_num = interface_num * 10 + *(interface + i) - '0'; if((0 <= interface_num) && (interface_num < FORWARDING_PORT_NUM)){ hash1 = MurmurHash3_x86_32 (key, len, 1); hash2 = MurmurHash3_x86_32 (key, len, 2); hash3 = MurmurHash3_x86_32 (key, len, 3); makeMergedBloomFilter(mbf, key, hash1, hash2, hash3, interface_num); } else{ //printf("Name[%s]'s Interface %d is Out of range.\n",key,interface_num); *port = 1; } }
void LongestPrefixMatching(struct Name *list, struct BloomFilter (*bf)[TEN_BIT], unsigned char *key, int *MatchVector) { int prefix_len = 0, key_len = 0; char tmp[NAME_PREF_LEN]=""; uint32_t hash1, hash2, hash3; memset(MatchVector,0,NAME_PREF_LEN); for(int i = 0; i < strlen(key); i++) if(*(key+i)=='/') prefix_len++; //NamePrefix最大長時の処理 key_len = strlen(key); hash1 = MurmurHash3_x86_32 (key, key_len, 1); hash2 = MurmurHash3_x86_32 (key, key_len, 2); hash3 = MurmurHash3_x86_32 (key, key_len, 3); checkStage1BloomFilter(bf, prefix_len, hash1, hash2, hash3, MatchVector); //Longest Prefix Matching for(int j = strlen(key)-1; j > 0; j--) { if(*(key+j)=='/'){ strncpy(tmp,key,j); tmp[j] = '\0'; key_len = strlen(tmp); hash1 = MurmurHash3_x86_32 (tmp, key_len, 1); hash2 = MurmurHash3_x86_32 (tmp, key_len, 2); hash3 = MurmurHash3_x86_32 (tmp, key_len, 3); prefix_len--; checkStage1BloomFilter(bf, prefix_len, hash1, hash2, hash3, MatchVector); } } }
/* Hash a buffer of length `len` to a 32-bit integer. * MurmurHash3 is used because it's fast, simple, public domain, and provides a 32-bit variant. */ uint32_t hash(const void * buf, size_t len) { uint32_t hashcode; if (len > (size_t) INT_MAX) { fprintf(stderr, "Maximum line length (%d) exceeded: %zu.\n", INT_MAX, len); exit(1); } MurmurHash3_x86_32(buf, (int) len, HASH_SEED, &hashcode); return hashcode; }
ERL_NIF_TERM erlang_murmurhash3_x86_32_1_impl(ErlNifEnv* env, int, const ERL_NIF_TERM argv[]) { ErlNifBinary bin; uint32_t h; if (!check_and_unpack_data(env, argv[0], &bin)) { return enif_make_badarg(env); } MurmurHash3_x86_32(bin.data, bin.size, 0, &h); return enif_make_uint(env, h); }