// Adds key and move into the hashtable. This function assumes that the key has
// been checked with get and is not in the table.
void Hash::add(Board &b, uint64_t data, int depth, uint8_t age) {
uint64_t h = b.getZobristKey();
uint64_t index = h & (size-1);
HashNode *node = table + index;
// Decide whether to replace the entry
// A more recent update to the same position should always be chosen
if ((node->slot1.zobristKey ^ node->slot1.data) == b.getZobristKey())
node->slot1.setEntry(b, data);
else if ((node->slot2.zobristKey ^ node->slot2.data) == b.getZobristKey())
node->slot2.setEntry(b, data);
// Replace an entry from a previous search space, or the lowest
// depth entry with the new entry if the new entry's depth is higher
else {
HashEntry *toReplace = NULL;
int score1 = 128*((int) (age - getHashAge(node->slot1.data)))
+ depth - getHashDepth(node->slot1.data);
int score2 = 128*((int) (age - getHashAge(node->slot2.data)))
+ depth - getHashDepth(node->slot2.data);
if (score1 >= score2)
toReplace = &(node->slot1);
else
toReplace = &(node->slot2);
// The node must be from a newer search space or be a
// higher depth if from the same search space.
if (score1 < -2 && score2 < -2)
toReplace = NULL;
if (toReplace != NULL)
toReplace->setEntry(b, data);
}
}
unsigned int HashMap::setValue(string key)
{
unsigned long hash = this->hashFunction(key, this->lengthM);
if (this->hashNodes[hash] == NULL)
{
this->hashNodes[hash] = new HashEntry(key);
return 1; // first occurance
}
else
{
HashEntry* nextNode = this->hashNodes[hash];
while (nextNode != NULL)
{
if (nextNode->getKey().compare(key) == 0)
{
nextNode->incrementCounter();
return nextNode->getValue();
}
if (nextNode->nextM == NULL)
{
nextNode->nextM = new HashEntry(key);
return 1; // first occurance
}
else nextNode = nextNode->nextM;
}
}
}
void UploadXML::Found(const char *name,double lat,double lon)
{
WPVERIFY_DEF *f;
HashEntry *he;
int h,hh;
#if 0
f=(WPVERIFY_DEF *)m_names.Find(name);
if(f)
{
if(fabs(f->lat-lat)<0.0001f && fabs(f->lon-lon)<0.0001f)
{
f->found=true;
return;
}
}
#endif
/* no direct name match, so scan through and find */
he=m_names.GetFirst();
hh=m_names.GetNum();
for(h=0;h<hh;++h)
{
f=(WPVERIFY_DEF *)he->m_data;
if(fabs(f->lat-lat)<0.0001f && fabs(f->lon-lon)<0.0001f)
{
f->found=true;
// return;
}
he=he->GetNext();
}
/* this point is not one we downloaded */
}
void HashMap::Add(ReadSequence *rs)
{
uint32_t rid_hash = _GetHash((*rs).readID) % this->size;
HashEntry *h = new HashEntry(rid_hash);
h->SetValue(rs);
if(this->Get(rs) == NULL)
{
this->_map[rid_hash]->push_back(h);
this->item_count++;
}
}
// stringer
string Hashmap::toString() {
int i = 0;
stringstream ss;
HashEntry * entry;
for (i = 0; i < size; i += 1) {
if (entries[i]) {
for (entry = entries[i]; entry; entry = entry->next) {
ss << "[" << i << "] - " << entry->toString() << "\n";
}
}
}
return ss.str();
}
unsigned int HashMap::getValue(string key)
{
unsigned long hash = this->hashFunction(key, this->lengthM);
HashEntry* nextNode = this->hashNodes[hash];
while (nextNode != NULL)
{
if (nextNode->getKey().compare(key) == 0)
{
return nextNode->getValue();
}
else nextNode = nextNode->nextM;
}
return 0;
}
void HashTable::createTable(VM* vm) const
{
ASSERT(!table);
int linkIndex = compactHashSizeMask + 1;
HashEntry* entries = new HashEntry[compactSize];
for (int i = 0; i < compactSize; ++i)
entries[i].setKey(0);
for (int i = 0; values[i].key; ++i) {
StringImpl* identifier = Identifier::add(vm, values[i].key).leakRef();
int hashIndex = identifier->existingHash() & compactHashSizeMask;
HashEntry* entry = &entries[hashIndex];
if (entry->key()) {
while (entry->next()) {
entry = entry->next();
}
ASSERT(linkIndex < compactSize);
entry->setNext(&entries[linkIndex++]);
entry = entry->next();
}
entry->initialize(identifier, values[i].attributes, values[i].value1, values[i].value2, values[i].intrinsic);
}
table = entries;
}
void HashTable::createTable(JSGlobalData* globalData) const
{
ASSERT(!table);
int linkIndex = compactHashSizeMask + 1;
HashEntry* entries = new HashEntry[compactSize];
for (int i = 0; i < compactSize; ++i)
entries[i].setKey(0);
for (int i = 0; values[i].key; ++i) {
StringImpl* identifier = Identifier::add(globalData, values[i].key).leakRef();
int hashIndex = identifier->existingHash() & compactHashSizeMask;
HashEntry* entry = &entries[hashIndex];
if (entry->key()) {
while (entry->next()) {
entry = entry->next();
}
ASSERT(linkIndex < compactSize);
entry->setNext(&entries[linkIndex++]);
entry = entry->next();
}
entry->initialize(identifier, values[i].attributes, values[i].value1, values[i].value2
#if ENABLE(JIT)
, values[i].generator
#if ENABLE(DFG_JIT)
, values[i].intrinsic
#endif
#endif
);
}
table = entries;
}
nsresult
nsCommandParams::GetOrMakeEntry(const char * name, PRUint8 entryType, HashEntry*& outEntry)
{
HashEntry *foundEntry = (HashEntry *)PL_DHashTableOperate(&mValuesHash, (void *)name, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_BUSY(foundEntry)) // reuse existing entry
{
foundEntry->Reset(entryType);
foundEntry->mEntryName.Assign(name);
outEntry = foundEntry;
return NS_OK;
}
foundEntry = (HashEntry *)PL_DHashTableOperate(&mValuesHash, (void *)name, PL_DHASH_ADD);
if (!foundEntry) return NS_ERROR_OUT_OF_MEMORY;
// placement new that sucker. Our ctor does not clobber keyHash, which is important.
outEntry = new (foundEntry) HashEntry(entryType, name);
return NS_OK;
}
nsCommandParams::HashEntry*
nsCommandParams::GetOrMakeEntry(const char* aName, uint8_t entryType)
{
HashEntry *foundEntry =
(HashEntry *)PL_DHashTableSearch(&mValuesHash, (void *)aName);
if (foundEntry) { // reuse existing entry
foundEntry->Reset(entryType);
return foundEntry;
}
foundEntry = static_cast<HashEntry*>
(PL_DHashTableAdd(&mValuesHash, (void *)aName, fallible));
if (!foundEntry) {
return nullptr;
}
// Use placement new. Our ctor does not clobber keyHash, which is important.
new (foundEntry) HashEntry(entryType, aName);
return foundEntry;
}
void kGUIDb::UpdateLocks(void)
{
int i,numtables;
HashEntry *he;
int *lcount;
kGUIString ls;
int numlocked;
kGUIDbCommand *c;
if(m_lockschanged==false)
return;
c=new kGUIDbCommand(this,"UNLOCK TABLES;");
delete c;
numlocked=0;
numtables=m_lockedtables.GetNum();
he=m_lockedtables.GetFirst();
ls.SetString("LOCK TABLES ");
for(i=0; i<numtables; ++i)
{
lcount=(int *)(he->m_data); /* get data pointer */
if(lcount[0])
{
if(numlocked)
ls.Append(", ");
ls.ASprintf("%s WRITE",he->m_string);
++numlocked;
}
he=he->GetNext();
}
if(numlocked)
{
ls.Append(";");
c=new kGUIDbCommand(this,ls.GetString());
delete c;
}
m_lockschanged=false;
}
int UploadXML::GetNotFound(kGUIString *s)
{
WPVERIFY_DEF *f;
HashEntry *he;
int h,hh;
int notfound;
notfound=0;
he=m_names.GetFirst();
hh=m_names.GetNum();
for(h=0;h<hh;++h)
{
f=(WPVERIFY_DEF *)he->m_data;
if(f->found==false)
{
s->ASprintf("%s\n",he->m_string);
++notfound;
}
he=he->GetNext();
}
return(notfound);
}
void HashMap::sortHash(unsigned int size, MostRepeatedWord* words)
{
for (int i = 0; i < size; i++)
{
words[i].occurance = 0;
words[i].word = "";
}
// every hash root
for (int i = 0; i < this->lengthM; i++)
{
HashEntry* node = this->hashNodes[i];
// every 'collided' node
while(node != NULL)
{
for (int j = 0; j < size; j++)
{
if (node->getValue() > words[j].occurance)
{
// this loop offsets the remaining most frequent words to the right
for (int k = size - 1; k > j; k--)
{
words[k].occurance = words[k - 1].occurance;
words[k].word = words[k - 1].word;
}
// afterwards, add the frequent word in place
words[j].occurance = node->getValue();
words[j].word = node->getKey();
break;
}
}
if (node->nextM != NULL) node = node->nextM;
else break;
}
}
}
void HashTable::createTable(JSGlobalData* globalData) const
{
#if ENABLE(PERFECT_HASH_SIZE)
ASSERT(!table);
HashEntry* entries = new HashEntry[hashSizeMask + 1];
for (int i = 0; i <= hashSizeMask; ++i)
entries[i].setKey(0);
for (int i = 0; values[i].key; ++i) {
UString::Rep* identifier = Identifier::add(globalData, values[i].key).releaseRef();
int hashIndex = identifier->computedHash() & hashSizeMask;
ASSERT(!entries[hashIndex].key());
entries[hashIndex].initialize(identifier, values[i].attributes, values[i].value1, values[i].value2);
}
table = entries;
#else
ASSERT(!table);
int linkIndex = compactHashSizeMask + 1;
HashEntry* entries = new HashEntry[compactSize];
for (int i = 0; i < compactSize; ++i)
entries[i].setKey(0);
for (int i = 0; values[i].key; ++i) {
UString::Rep* identifier = Identifier::add(globalData, values[i].key).releaseRef();
int hashIndex = identifier->computedHash() & compactHashSizeMask;
HashEntry* entry = &entries[hashIndex];
if (entry->key()) {
while (entry->next()) {
entry = entry->next();
}
ASSERT(linkIndex < compactSize);
entry->setNext(&entries[linkIndex++]);
entry = entry->next();
}
entry->initialize(identifier, values[i].attributes, values[i].value1, values[i].value2);
}
table = entries;
#endif
}
