static int lump_hashcode(lts_t lts,int *map,int i){ long j; uint32_t temp[2]; uint32_t contrib[3]; int last=lts->begin[i+1]-1; int hc=map[i]; //int sigptr=0, *sig=alloca(2*(last-lts->begin[i])); //Warning(1,"signature for %d %x %x",i,sig,map); for(j=lts->begin[i];j<=last;j++){ int block=map[lts->dest[j]]; contrib[2]=block; TreeUnfold(lts->edge_idx,lts->label[j],(int*)contrib); //Warning(1,"collecting"); while(j<last && block==map[lts->dest[j+1]]){ j++; TreeUnfold(lts->edge_idx,lts->label[j],(int*)temp); uint64_t teller=((uint64_t)contrib[0])*((uint64_t)temp[1]); teller+=((uint64_t)temp[0])*((uint64_t)contrib[1]); uint64_t noemer=((uint64_t)contrib[1])*((uint64_t)temp[1]); uint64_t gcd=gcd64(teller,noemer); contrib[0]=teller/gcd; contrib[1]=noemer/gcd; } hc=SuperFastHash(contrib,12,hc); } return hc; }
void SIdeleteC(string_index_t si,const char*str,int len){ uint32_t hash; int bucket; int idx,next,deleted; hash=SuperFastHash(str,len,0); bucket=hash&si->mask; idx=si->table[bucket]; si->table[bucket]=END_OF_LIST; while(idx!=END_OF_LIST){ if (0==strcmp(str,si->data[idx])) { deleted=idx; RTfree(si->data[idx]); si->count--; idx=si->next[idx]; while(idx!=END_OF_LIST){ next=si->next[idx]; si->next[idx]=si->table[bucket]; si->table[bucket]=idx; idx=next; } add_to_free_list(si,deleted); return; } else { next=si->next[idx]; si->next[idx]=si->table[bucket]; si->table[bucket]=idx; idx=next; } } }
TCHAR * CHashedStringList::Find(TCHAR * String) { TCHAR * buff; if (!m_bCaseSense) { buff = _wcsdup(String); _wcslwr(buff); } else buff = String; UINT32 hash = SuperFastHash(buff, wcslen(buff))%m_Size; //获得模数 CMHashItem * hashitem = m_hashitem[hash].next; while (hashitem && _wcsicmp(hashitem->String, buff)) hashitem = hashitem->next; if (hashitem) //找到了这一项 { if (!m_bCaseSense) free(buff); return hashitem->Value; } else { if (!m_bCaseSense) free(buff); return NULL; //找不到 } }
void RSManagerDX9::registerD3DXCreateTextureFromFileInMemory(LPCVOID pSrcData, UINT SrcDataSize, LPDIRECT3DTEXTURE9 pTexture) { SDLOG(1, "RenderstateManager: registerD3DXCreateTextureFromFileInMemory %p | %p (size %d)\n", pTexture, pSrcData, SrcDataSize); if(Settings::get().getEnableTextureDumping()) { UINT32 hash = SuperFastHash((char*)const_cast<void*>(pSrcData), SrcDataSize); SDLOG(1, " - size: %8u, hash: %8x\n", SrcDataSize, hash); IDirect3DSurface9* surf = NULL; ((IDirect3DTexture9*)pTexture)->GetSurfaceLevel(0, &surf); if(surf != NULL) { string directory = getInstalledFileName(format("textures\\%s\\dump\\", getExeFileName().c_str())); SDLOG(1, "%s\n", boost::filesystem::path(directory).string().c_str()) try { boost::filesystem::create_directories(boost::filesystem::path(directory)); string fn = format("%s%08x.tga", directory.c_str(), hash); SDLOG(1, " - dumping texture to %s\n", fn); if(SUCCEEDED(D3DXSaveSurfaceToFile(fn.c_str(), D3DXIFF_TGA, surf, NULL, NULL))) { SDLOG(1, " - texture dumped\n"); } else { SDLOG(-1, "ERROR while texture dumping (D3DX)\n"); } } catch(boost::filesystem::filesystem_error e) { SDLOG(-1, "ERROR - Filesystem error while trying to create directory:\n%s\n", e.what()); } surf->Release(); }
banlist_client_entry_t *banlist_client_add (banlist_client_t * list, unsigned char *client, double minVersion, double maxVersion, buffer_t * reason) { banlist_client_entry_t *b; /* delete any prior ban of this client */ banlist_client_del_byclient (list, client, minVersion, maxVersion); /* alloc and clear new element */ b = malloc (sizeof (banlist_client_entry_t)); /* init */ dllist_init (&b->dllist); strncpy (b->client, client, NICKLENGTH); b->client[NICKLENGTH - 1] = 0; b->minVersion = minVersion; b->maxVersion = maxVersion; if (reason) { b->message = bf_copy (reason, 1); } else b->message = bf_alloc (1); *b->message->e = 0; /* put in hashlist */ dlhashlist_prepend (list, SuperFastHash (client, strlen (client)) & BANLIST_NICK_HASHMASK, b); return b; }
static void len_resize(void*arg,void*old_array,int old_size,void*new_array,int new_size){ DEBUG("extend during len resize from %d to %d",old_size,new_size); (void)old_array; (void)new_array; string_index_t si=(string_index_t)arg; expand_free_list(si,old_size,new_size); if ((si->mask*FILL_OUTOF)<(si->count*FILL_MAX)){ int i,current,next,N; uint32_t hash; uint32_t len; int bucket; N=si->mask+1; DEBUG("resizing table from %d to %d",N,N+N); si->mask=(si->mask<<1)+1; si->table=(int*)RTrealloc(si->table,(si->mask+1)*sizeof(int)); for(i=0;i<N;i++){ current=si->table[i]; si->table[i]=END_OF_LIST; si->table[N+i]=END_OF_LIST; while(current!=END_OF_LIST){ next=si->next[current]; len=si->len[current]; hash=SuperFastHash(si->data[current],len,0); bucket=hash&si->mask; HREassert(bucket==i||bucket==N+i,"error"); si->next[current]=si->table[bucket]; si->table[bucket]=current; DEBUG("moving %s from %d to %d",si->data[current],i,bucket); current=next; } } } }
void CHashedStringList::Add(TCHAR * String, TCHAR * Value) { TCHAR * buff; if (!m_bCaseSense) { buff = _wcsdup(String); _wcslwr(buff); } else buff = String; UINT32 hash = SuperFastHash(buff, wcslen(buff))%m_Size; //获得模数 CMHashItem * hashitem = m_hashitem[hash].next; CMHashItem * parent = &m_hashitem[hash]; while (hashitem && _wcsicmp(hashitem->String, buff)) { parent = hashitem; hashitem = hashitem->next; } if (!hashitem) { parent->next = (CMHashItem*)malloc(sizeof(CMHashItem)); //还不存在这一项 hashitem = parent->next; if (!m_bCaseSense) hashitem->String = buff; else hashitem->String = _wcsdup(buff); hashitem->Value = _wcsdup(Value); hashitem->next = NULL; } else if (!m_bCaseSense) free(buff); //已经存在这一项了 }
void CHashedStringList::Delete(TCHAR * String) { TCHAR * buff; if (!m_bCaseSense) { buff = _wcsdup(String); _wcslwr(buff); } else buff = String; UINT32 hash = SuperFastHash(buff, wcslen(buff))%m_Size; //获得模数 CMHashItem * hashitem = m_hashitem[hash].next; CMHashItem * parent = &m_hashitem[hash]; while (hashitem && _wcsicmp(hashitem->String, buff)) { parent = hashitem; hashitem = hashitem->next; } if (hashitem) //找到了这一项 { parent->next=hashitem->next; free(hashitem->String); free(hashitem->Value); free(hashitem); } if (!m_bCaseSense) free(buff); }
HRESULT RSManager::redirectD3DXCreateTextureFromFileInMemoryEx(LPDIRECT3DDEVICE9 pDevice, LPCVOID pSrcData, UINT SrcDataSize, UINT Width, UINT Height, UINT MipLevels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, DWORD Filter, DWORD MipFilter, D3DCOLOR ColorKey, D3DXIMAGE_INFO* pSrcInfo, PALETTEENTRY* pPalette, LPDIRECT3DTEXTURE9* ppTexture) { if(Settings::get().getEnableTextureOverride()) { UINT32 hash = SuperFastHash((char*)const_cast<void*>(pSrcData), SrcDataSize); SDLOG(4, "Trying texture override size: %8u, hash: %8x\n", SrcDataSize, hash); if (Settings::get().getEnableTexturePrefetch() && cachedTexFiles.find(hash) != cachedTexFiles.end()) { SDLOG(4, "Cached texture file found! size: %ld, hash: %8x \n", cachedTexFiles[hash].size, hash); return TrueD3DXCreateTextureFromFileInMemoryEx(pDevice, cachedTexFiles[hash].buffer, cachedTexFiles[hash].size, D3DX_DEFAULT, D3DX_DEFAULT, MipLevels, Usage, D3DFMT_FROM_FILE, Pool, Filter, MipFilter, ColorKey, pSrcInfo, pPalette, ppTexture); } else { char buffer[128]; sprintf_s(buffer, "dsfix/tex_override/%08x.png", hash); if (fileExists(buffer)) { SDLOG(4, "Texture override (png)! hash: %08x\n", hash); return D3DXCreateTextureFromFileEx(pDevice, buffer, D3DX_DEFAULT, D3DX_DEFAULT, MipLevels, Usage, D3DFMT_FROM_FILE, Pool, Filter, MipFilter, ColorKey, pSrcInfo, pPalette, ppTexture); } sprintf_s(buffer, "dsfix/tex_override/%08x.dds", hash); if (fileExists(buffer)) { SDLOG(4, "Texture override (dds)! hash: %08x\n", hash); return D3DXCreateTextureFromFileEx(pDevice, buffer, D3DX_DEFAULT, D3DX_DEFAULT, MipLevels, Usage, D3DFMT_FROM_FILE, Pool, Filter, MipFilter, ColorKey, pSrcInfo, pPalette, ppTexture); } } } return TrueD3DXCreateTextureFromFileInMemoryEx(pDevice, pSrcData, SrcDataSize, Width, Height, MipLevels, Usage, Format, Pool, Filter, MipFilter, ColorKey, pSrcInfo, pPalette, ppTexture); }
/** * _exp_file_insert -- Insert the exports directory into the file structure * using the directory as a dict. Also hashes the dirname, * stores it in a uuid type, converts the uuid type to a * string and uses that as the key to the exports map. * The exports map maps an export "uuid" to an export * directory struct. * * @file : Exports file struct to insert into * @dir : Export directory to insert * * Not for external use. */ static void _exp_file_insert(struct exports_file *file, struct export_dir *dir) { data_t *dirdata = NULL; uint32_t hashedval = 0; uuid_t export_uuid = { 0, }; char export_uuid_str[512] = { 0, }; char *dirdup = NULL; GF_VALIDATE_OR_GOTO(GF_EXP, file, out); GF_VALIDATE_OR_GOTO(GF_EXP, dir, out); dirdata = bin_to_data(dir, sizeof(*dir)); dict_set(file->exports_dict, dir->dir_name, dirdata); dirdup = strdupa(dir->dir_name); while (strlen(dirdup) > 0 && dirdup[0] == '/') dirdup++; hashedval = SuperFastHash(dirdup, strlen(dirdup)); memset(export_uuid, 0, sizeof(export_uuid)); memcpy(export_uuid, &hashedval, sizeof(hashedval)); gf_uuid_unparse(export_uuid, export_uuid_str); dict_set(file->exports_map, export_uuid_str, dirdata); out: return; }
SEXP R_hash_charvec(SEXP X, SEXP NTHRD){ PROTECT(X); PROTECT(NTHRD); int n = length(X) , nthrd = INTEGER(NTHRD)[0]; SEXP H; PROTECT(H = allocVector(INTSXP,length(X))); #ifdef _OPENMP #pragma omp parallel num_threads(nthrd) #endif { int *h = INTEGER(H) , ID = 0 , nthreads = 1L; #ifdef _OPENMP ID = omp_get_thread_num(); nthreads = omp_get_num_threads(); #endif for (int i = ID; i < n; i += nthreads ) { h[i] = (int) SuperFastHash( CHAR(STRING_ELT(X,i)), length(STRING_ELT(X,i))); } }// end of parallel region UNPROTECT(3); return H; }
std::string cli::url_to_id(const std::string &url) { std::string url_lc = url; miscutil::to_lower(url_lc); url_lc = cli::strip_url(url_lc); uint32_t id = SuperFastHash(url_lc.c_str(),url_lc.size()); return miscutil::to_string(id); }
static inline FlowTableRecord_t *hash_lookup_FlowTable(uint32_t *index_cache, void *flowkey, master_record_t *flow_record) { uint32_t index; int bsize; FlowTableRecord_t *record; *index_cache = SuperFastHash((char *)flowkey, FlowTable.keysize); index = *index_cache & FlowTable.IndexMask; if ( FlowTable.bucket[index] == NULL ) { hash_hit++; return NULL; } record = FlowTable.bucket[index]; // skip records with different hash value ( full 32bit ) while ( record ) if ( record->hash != *index_cache ) { hash_skip++; record = record->next; } else break; bsize = 0; while ( record ) { uint64_t *k1 = (uint64_t *)flowkey; uint64_t *k2 = (uint64_t *)record->hash_key; int i; // compare key and break as soon as keys do not match i = 0; while ( i < FlowTable.keylen ) { if ( k1[i] == k2[i] ) i++; else break; } loopcnt += i; if ( i == FlowTable.keylen ) { // hit - record found // some stats for debugging if ( bsize == 0 ) hash_hit++; else hash_miss++; return record; } record = record->next; bsize++; } return NULL; } // End of hash_lookup_FlowTable
// Return associated index of the value, or -1 if not found. // In case of collision, apply quadratic probing. NgramIndex NgramVector::Find(NgramIndex hist, VocabIndex word) const { size_t skip = 0; NgramIndex pos = SuperFastHash(hist, word) & _hashMask; NgramIndex index; while ((index = _indices[pos]) != Invalid && !(_words[index] == word && _hists[index] == hist)) pos = (pos + ++skip) & _hashMask; return index; }
unsigned long HashFunction(const char* key) { /* unsigned long hash = 5381; int c; while ((c = *key++)) hash = ((hash << 5) + hash) + c; /* hash * 33 + c */ return SuperFastHash(key, strlen(key)); }
uint32_t lookup(uint8_t *k, uint32_t length, uint32_t initval) { #ifdef HAVE_SFHASH return SuperFastHash((const char*)k, length, initval); #elif HAVE_LOOKUP3 #if LITTLE_ENDIAN return hashlittle(k, length, initval); #elif BIG_ENDIAN return hashbig(k, length, initval); #endif #endif }
SEXP R_hash_raw(SEXP X){ PROTECT(X); SEXP h; PROTECT(h = allocVector(INTSXP,1L)); INTEGER(h)[0] = (int) SuperFastHash((char *) RAW(X),length(X)); UNPROTECT(2); return h; }
int SIlookupC(string_index_t si,const char*str,int len){ uint32_t hash; int bucket; int idx; hash=SuperFastHash(str,len,0); bucket=hash&si->mask; for(idx=si->table[bucket];idx!=END_OF_LIST;idx=si->next[idx]){ if (si->len[idx]!=len) continue; if (0==memcmp(str,si->data[idx],len)) return idx; } return SI_INDEX_FAILED; }
// Resize index table to the specified capacity. void NgramVector::_Reindex(size_t indexSize) { assert(indexSize >= size() && isPowerOf2(indexSize)); _indices.reset(indexSize, Invalid); _hashMask = indexSize - 1; for (NgramIndex i = 0; i < (NgramIndex)size(); i++) { size_t skip = 0; NgramIndex pos = SuperFastHash(_hists[i], _words[i]) & _hashMask; while (_indices[pos] != Invalid) pos = (pos + ++skip) & _hashMask; _indices[pos] = i; } }
FSharedStringArena::Node *FSharedStringArena::FindString(const char *str, size_t strlen, unsigned int &hash) { hash = SuperFastHash(str, strlen); for (Node *node = Buckets[hash % countof(Buckets)]; node != NULL; node = node->Next) { if (node->Hash == hash && node->String.Len() == strlen && memcmp(&node->String[0], str, strlen) == 0) { return node; } } return NULL; }
void write_hash_to_file(int i, unsigned char* data) { uint32_t hashed = SuperFastHash(data, PAGE_SIZE); //file_write(logFile, i*4096, data, 4096); unsigned char charHash[4]; charHash[0] = hashed>>24; charHash[1] = hashed>>16; charHash[2] = hashed>>8; charHash[3] = hashed; /*if(i<10){ printk("i=%d Hash %u", i, hashed); printk(" Character hash %c %c %c %c\n", charHash[0], charHash[1], charHash[2], charHash[3]); }*/ file_write(logFile, i*4, charHash, 4); }
uint32_t HashAlgorithm::run(const char *key) { if (hashAlgorithmInitialized == false) { systemLog->sysLog(ERROR, "HashAlgorithm object is not initialized properly"); return 0; } switch (algorithmType) { case ALGO_PAULHSIEH: return SuperFastHash(key); break; } // Never executed normally return 0; }
EPUB3ManifestItemListItemPtr EPUB3ManifestFindItemWithId(EPUB3ManifestRef manifest, const char * itemId) { assert(manifest != NULL); assert(itemId != NULL); int32_t bucket = SuperFastHash(itemId, (int32_t)strlen(itemId)) % MANIFEST_HASH_SIZE; EPUB3ManifestItemListItemPtr itemPtr = manifest->itemTable[bucket]; while(itemPtr != NULL) { if(strcmp(itemId, itemPtr->item->itemId) == 0) { return itemPtr; } itemPtr = itemPtr->next; } return NULL; }
void RSManager::registerD3DXCreateTextureFromFileInMemory(LPCVOID pSrcData, UINT SrcDataSize, LPDIRECT3DTEXTURE9 pTexture) { SDLOG(1, "RenderstateManager: registerD3DXCreateTextureFromFileInMemory %p\n", pTexture); if(Settings::get().getEnableTextureDumping()) { UINT32 hash = SuperFastHash((char*)const_cast<void*>(pSrcData), SrcDataSize); SDLOG(1, " - size: %8u, hash: %8x\n", SrcDataSize, hash); IDirect3DSurface9* surf; ((IDirect3DTexture9*)pTexture)->GetSurfaceLevel(0, &surf); char buffer[128]; sprintf_s(buffer, "dsfix/tex_dump/%08x.tga", hash); D3DXSaveSurfaceToFile(GetDirectoryFile(buffer), D3DXIFF_TGA, surf, NULL, NULL); surf->Release(); } registerKnowTexture(pSrcData, SrcDataSize, pTexture); }
void RSManager::registerKnowTexture(LPCVOID pSrcData, UINT SrcDataSize, LPDIRECT3DTEXTURE9 pTexture) { if(foundKnownTextures < numKnownTextures) { UINT32 hash = SuperFastHash((char*)const_cast<void*>(pSrcData), SrcDataSize); #define TEXTURE(_name, _hash) \ if(hash == _hash) { \ texture##_name = pTexture; \ ++foundKnownTextures; \ SDLOG(1, "RenderstateManager: recognized known texture %s at %u\n", #_name, pTexture); \ } #include "Textures.def" #undef TEXTURE if(foundKnownTextures == numKnownTextures) { SDLOG(1, "RenderstateManager: all known textures found!\n"); } } }
banlist_client_entry_t *banlist_client_find (banlist_client_t * list, unsigned char *client, double version) { banlist_client_entry_t *e, *l; l = dllist_bucket (list, SuperFastHash (client, strlen (client)) & BANLIST_NICK_HASHMASK); dllist_foreach (l, e) if (!strncmp (e->client, client, NICKLENGTH) && ((version == 0) || ((version >= e->minVersion) && (version <= e->maxVersion)))) break; if (e == dllist_end (l)) return 0; return e; }
unsigned int banlist_client_del_byclient (banlist_client_t * list, unsigned char *client, double min, double max) { banlist_client_entry_t *e, *l; l = dllist_bucket (list, SuperFastHash (client, strlen (client)) & BANLIST_NICK_HASHMASK); dllist_foreach (l, e) if ((!strncmp (e->client, client, NICKLENGTH)) && (e->minVersion == min) && (e->maxVersion == max)) break; if (e == dllist_end (l)) return 0; dllist_del ((dllist_entry_t *) e); return 1; }
banlist_entry_t *banlist_add (banlist_t * list, unsigned char *op, unsigned char *nick, uint32_t ip, uint32_t netmask, buffer_t * reason, unsigned long expire) { banlist_entry_t *b; uint32_t i; unsigned char n[NICKLENGTH]; unsigned int l; /* bad netmask */ i = netmask_to_numbits (netmask); if (i > 32) return NULL; l = nicktolower (n, nick); /* delete any earlier bans of this ip. */ if ((b = banlist_find_exact (list, nick, ip, netmask))) banlist_del (list, b); /* alloc and clear new element */ b = malloc (sizeof (banlist_entry_t)); /* init */ dllist_init (&b->list_ip); dllist_init (&b->list_name); strncpy (b->nick, nick, NICKLENGTH); b->nick[NICKLENGTH - 1] = 0; strncpy (b->op, op, NICKLENGTH); b->op[NICKLENGTH - 1] = 0; b->ip = ip & netmask; b->netmask = netmask; b->message = bf_copy (reason, 1); *b->message->e = 0; b->expire = expire; /* mask netmask as used */ list->netmask_inuse[i]++; /* put in hashlist */ dlhashlist_prepend (&list->list_ip, one_at_a_time (ip & netmask) & BANLIST_HASHMASK, (&b->list_ip)); dlhashlist_prepend (&list->list_name, SuperFastHash (n, l) & BANLIST_NICK_HASHMASK, (&b->list_name)); return b; }
banlist_entry_t *banlist_find_bynick (banlist_t * list, unsigned char *nick) { dllist_entry_t *p, *l; banlist_entry_t *e; unsigned char n[NICKLENGTH]; unsigned int i; ASSERT (*nick); i = nicktolower (n, nick); repeat: l = dllist_bucket (&list->list_name, SuperFastHash (n, i) & BANLIST_NICK_HASHMASK); dllist_foreach (l, p) { e = (banlist_entry_t *) ((char *) p - sizeof (dllist_t)); if (!strncasecmp (e->nick, nick, NICKLENGTH)) break; }
static void PutEntry(string_index_t si,const char*str,int s_len,int index){ uint32_t hash; int bucket; ensure_access(si->man,index); HREassert (si->next[index] < 0, "Cannot put %s at %d: position occupied by %s", str,index,si->data[index]); cut_from_free_list(si,index); si->len[index]=s_len; si->data[index]=RTmalloc(s_len+1); memcpy(si->data[index],str,s_len); (si->data[index])[s_len]=0; hash=SuperFastHash(str,s_len,0); bucket=hash&si->mask; si->next[index]=si->table[bucket]; si->table[bucket]=index; si->count++; }