int hash_swap(hash_t *hash, unsigned long key1, unsigned long key2)
{
	int bucket;
	unsigned long tmp;
	hash_entry_t *entry1, *entry2;

	rc = pthread_mutex_lock(&lock);
	
	/* find first value */
	bucket = hash_fn(hash,key1);
	entry1 = hash->table[bucket];
	for (;;){
		/* first entry not found */
		if (entry1 == NULL) {
		  rc = pthread_mutex_unlock(&lock);
		  return -1;
		}
		/* first entry found */
		if (entry1->key == key1)
			break;

		entry1 = entry1->next;
	}

	/* find second value */
	bucket = hash_fn(hash,key2);
	entry2 = hash->table[bucket];
	for (;;){
		/* first entry not found */
		if (entry2 == NULL) {
		  rc = pthread_mutex_unlock(&lock);
		  return -1;
		}
		/* first entry found */
		if (entry2->key == key2)
			break;

		entry2 = entry2->next;
	}

	/* do the swap */
	tmp = entry1->val;
	entry1->val = entry2->val;
	entry2->val = tmp;
	rc = pthread_mutex_unlock(&lock);
	
	return 0;
}
Пример #2
0
unsigned long hash_delete(hash_t *hash, unsigned long key)
{
	unsigned int bucket;
	hash_entry_t *curr, *prev;
	unsigned long ret;

	bucket = hash_fn(hash,key);
	curr = hash->table[bucket];
	prev = curr;
	for (;;){
		/* entry does not exist */
		if (curr == NULL)
			return HASH_ENTRY_NOTFOUND;

		/* found entry */
		if (curr->key == key)
			break;

		prev = curr;
		curr = curr->next;
	}

	/* delete entry */
	ret = curr->val;
	if (curr == hash->table[bucket])
		hash->table[bucket] = curr->next;
	else
		prev->next = curr->next;
	free(curr);
	return ret;
}
Пример #3
0
vector<string> findRepeatedDnaSequences(string s) {
    unordered_map<int, int> map;
    hash<string> hash_fn;
    vector<string> v;

    for(int i = 0 ; i + 9 < s.size(); i++)
    {
       string t = s.substr(i, 10);
       int h = hash_fn(t);

       if(map.find(h) == map.end())
       {
          map[h] = 1;
       }
       else
       {
           if (map[h] == 1)
           {
               v.insert (v.end(), t);
           }

            map[h]++;
       }
    }

    return v;
}
Пример #4
0
void hash_insert(hash_t *hash, unsigned long key, unsigned long val)
{
	hash_entry_t *new_entry, *curr;
	unsigned int bucket;

	bucket = hash_fn(hash, key);
	//Lookup
	curr = hash->table[bucket];
	while (curr) {
		/* found key */
		if (curr->key == key){
			curr->val = val;
			return;
		}
		curr = curr->next;
	}

	/* key does not exist, allocate a new entry  */
	new_entry = malloc(sizeof(hash_entry_t));
	new_entry->key = key;
	new_entry->val = val;

	/* put new entry, at the beggining of the bucket */
	new_entry->next = hash->table[bucket];
	hash->table[bucket] = new_entry;
}
Пример #5
0
 inline size_t calculateHash(const T& msg)
 {
   std::stringstream ss;
   ss << msg;
   std::hash<std::string> hash_fn;
   return hash_fn(ss.str());
 }
Пример #6
0
static void
output_previous_word(void)
{
  char *p;
  int i, j;

  word[wordpos++] = 0;          /* word's trailing null */

  /* Don't bother putting single or double letter words in the table */

  if (wordpos <= 3) {
    p = word;
    while (*p)
      *b++ = *p++;
    return;
  }
  /* search table to see if word is already in it; */

  for (i = hash_fn(word, COMPRESS_HASH_MASK), j = 0;
       i < MAXTABLE &&
       (words[i] || (i & 0xFF) == 0) && j < COLLISION_LIMIT; i++, j++)
    if (words[i])
      if (strcmp(word, words[i]) == 0) {
        *b++ = (i >> 8) | TABLE_FLAG;
        *b++ = i & 0xFF;
        return;
      }
unsigned long hash_lookup(hash_t *hash, unsigned long key)
{
	unsigned int bucket;
	hash_entry_t *curr;
	unsigned long return_val;
	rc = pthread_mutex_lock(&lock);
	
	bucket = hash_fn(hash,key);
	
	curr = hash->table[bucket];
	for (;;){
		/* entry not found */
		if (curr == NULL) {
		  rc = pthread_mutex_unlock(&lock);
		  return HASH_ENTRY_NOTFOUND;
		}
		/* entry found */
		if (curr->key == key) 
		  break;
		curr = curr->next;
	}
	return_val = curr->val;
	
	rc = pthread_mutex_unlock(&lock);
	
	return return_val;
	
}
Пример #8
0
/* Find irq by its id. */
irq_t find_by_irqid(int id)
{
	irqhashtable_t bucket;
	irq_t p, link;

	spin_lock(&irqhashlock);
	bucket = &irqhash[hash_fn(id)];
	p = bucket->irq;

	/* optimize for average case. */
	if(p->id == id)
	{
		link = p;
		goto end;
	}
	else
	{

		for(link=p->next; (link->id!=id); link=link->next)
			if(link->next == NULL)
			{
				link = NULL;
				goto end;
			}
	}
end:
	spin_unlock(&irqhashlock);
	return link;
}
Пример #9
0
TileLoader::TileLoader(const std::string &service, double latitude,
                       double longitude, unsigned int zoom, unsigned int blocks,
                       QObject *parent)
    : QObject(parent), latitude_(latitude), longitude_(longitude), zoom_(zoom),
      blocks_(blocks), object_uri_(service) {
  assert(blocks_ >= 0);

  const std::string package_path = ros::package::getPath("rviz_satellite");
  if (package_path.empty()) {
    throw std::runtime_error("package 'rviz_satellite' not found");
  }

  std::hash<std::string> hash_fn;
  cache_path_ =
      QDir::cleanPath(QString::fromStdString(package_path) + QDir::separator() +
                      QString("mapscache") + QDir::separator() +
                      QString::number(hash_fn(object_uri_)));

  QDir dir(cache_path_);
  if (!dir.exists() && !dir.mkpath(".")) {
    throw std::runtime_error("Failed to create cache folder: " +
                             cache_path_.toStdString());
  }

  /// @todo: some kind of error checking of the URL

  //  calculate center tile coordinates
  double x, y;
  latLonToTileCoords(latitude_, longitude_, zoom_, x, y);
  center_tile_x_ = std::floor(x);
  center_tile_y_ = std::floor(y);
  //  fractional component
  origin_offset_x_ = x - center_tile_x_;
  origin_offset_y_ = y - center_tile_y_;
}
Пример #10
0
static bool 
node_hash_remove(fatfs_hash_table_t *tbl, fatfs_node_t *node)
{
    unsigned int hval;
    fatfs_node_t *lnode, *pnode;
   
    // Calculate hash of name and get the first node in slot
    hval = hash_fn(node->dentry.filename, 
                   strlen(node->dentry.filename)) % tbl->size;
    lnode = tbl->nodes[hval];

    // Now find the node in list and remove it
    pnode = NULL;
    while (lnode != NULL)
    {
        if (lnode == node)
        {
            if (pnode == NULL)
                tbl->nodes[hval] = lnode->hash_next;
            else
                pnode->hash_next = lnode->hash_next;
            node->hash_next = NULL;
            tbl->n--;
            
            // All done
            return true;
        }
        pnode = lnode;
        lnode = lnode->hash_next;
    } 

    // Node not in list 
    return false;
}
Пример #11
0
/* Find a process by its pid. */
process_t find_by_pid(pid_t pid)
{
	phashtable_t bucket;
	process_t p, link;

	spin_lock(&phashlock);
	bucket = &phash[hash_fn(pid)];
	p = bucket->proc;

	/* optimize for average case. */
	if(p->pid == pid)
	{
		link = p;
		goto ok;
	}
	else
	{

		for(link=p->next; (link->pid!=pid); link=link->next)
			if(link->next == NULL)
				goto errp;
	}

ok:
	spin_unlock(&phashlock);
	return link;
errp:
	spin_unlock(&phashlock);
	return NULL;
}
Пример #12
0
uint64_t TestingHarness::GetThreadId() {
  std::hash<std::thread::id> hash_fn;

  uint64_t id = hash_fn(std::this_thread::get_id());
  id = id % MAX_THREADS;

  return id;
}
Пример #13
0
int main()
{
    std::string str = "Meet the new boss...";
    std::hash<std::string> hash_fn;
    std::size_t str_hash = hash_fn(str);
 
    std::cout << str_hash << '\n';
}
Пример #14
0
int wal_engine::insert(const statement& st) {
  LOG_INFO("Insert");
  record* after_rec = st.rec_ptr;
  table* tab = db->tables->at(st.table_id);
  plist<table_index*>* indices = tab->indices;

  unsigned int num_indices = tab->num_indices;
  unsigned int index_itr;

  std::string key_str = sr.serialize(after_rec, indices->at(0)->sptr);
  LOG_INFO("key_str :: %s", key_str.c_str());
  unsigned long key = hash_fn(key_str);

  // Check if key present
  if (indices->at(0)->pm_map->exists(key) != 0) {
    after_rec->clear_data();
    delete after_rec;
    return EXIT_SUCCESS;
  }

  // Add log entry
  std::string after_tuple = sr.serialize(after_rec, after_rec->sptr);
  entry_stream.str("");
  entry_stream << st.transaction_id << " " << st.op_type << " " << st.table_id
               << " " << after_tuple << "\n";
  entry_str = entry_stream.str();
  fs_log.push_back(entry_str);

  // Add to table
  tab->pm_data->push_back(after_rec);

  off_t storage_offset;
  storage_offset = tab->fs_data.push_back(after_tuple);

  // Add entry in indices
  for (index_itr = 0; index_itr < num_indices; index_itr++) {
    key_str = sr.serialize(after_rec, indices->at(index_itr)->sptr);
    key = hash_fn(key_str);

    indices->at(index_itr)->pm_map->insert(key, after_rec);
    indices->at(index_itr)->off_map->insert(key, storage_offset);
  }

  return EXIT_SUCCESS;
}
Пример #15
0
int main()
{
    S s;
    s.first_name = "Bender";
    s.last_name =  "Rodriguez";
    std::hash<S> hash_fn;
 
    std::cout << "hash(s) = " << hash_fn(s) << "\n";
}
Пример #16
0
int wal_engine::remove(const statement& st) {
  LOG_INFO("Remove");
  record* rec_ptr = st.rec_ptr;
  table* tab = db->tables->at(st.table_id);
  plist<table_index*>* indices = tab->indices;

  unsigned int num_indices = tab->num_indices;
  unsigned int index_itr;
  record* before_rec = NULL;

  std::string key_str = sr.serialize(rec_ptr, indices->at(0)->sptr);
  unsigned long key = hash_fn(key_str);

  // Check if key does not exist
  if (indices->at(0)->pm_map->at(key, &before_rec) == false) {
	delete rec_ptr;
    return EXIT_SUCCESS;
  }

  // Add log entry
  entry_stream.str("");
  entry_stream << st.transaction_id << " " << st.op_type << " " << st.table_id
               << " " << sr.serialize(before_rec, before_rec->sptr) << "\n";

  entry_str = entry_stream.str();
  fs_log.push_back(entry_str);

  tab->pm_data->erase(before_rec);

  // Remove entry in indices
  for (index_itr = 0; index_itr < num_indices; index_itr++) {
    key_str = sr.serialize(rec_ptr, indices->at(index_itr)->sptr);
    key = hash_fn(key_str);

    indices->at(index_itr)->pm_map->erase(key);
    indices->at(index_itr)->off_map->erase(key);
  }

  before_rec->clear_data();
  delete before_rec;

  delete rec_ptr;
  return EXIT_SUCCESS;
}
Пример #17
0
/* Insert the process in the global hash table. */
static inline void phash_insert(process_t process)
{
	phashtable_t p;

	spin_lock(&phashlock);
	p = &phash[hash_fn(process->pid)];
	process->next = p->proc;
	p->proc = process;
	spin_unlock(&phashlock);
}
Пример #18
0
/* Insert the irq in the global hash table. */
static inline void irqhash_insert(irq_t irq)
{
	irqhashtable_t p;

	spin_lock(&irqhashlock);
	p = &irqhash[hash_fn(irq->id)];
	irq->next = p->irq;
	p->irq = irq;
	spin_unlock(&irqhashlock);
}
Пример #19
0
static inline void thash_insert(struct thread *thread)
{
	thashtable_t t;

	spin_lock(&hashlock);
	t = &thash[hash_fn(thread->tid)];
	thread->next = t->thr;
	t->thr = thread;
	spin_unlock(&hashlock);
}
Пример #20
0
static bool
node_hash_add(fatfs_hash_table_t *tbl, fatfs_node_t *node)
{
    unsigned int hval;
   
    // Calculate hash of given node filename
    hval = hash_fn(node->dentry.filename, 
                   strlen(node->dentry.filename)) % tbl->size;

    CYG_TRACE2(TNC, "name='%s' hval=%d", node->dentry.filename, hval);

    if (tbl->nodes[hval] == NULL)
    {
        // First node in this slot
        node->hash_next  = NULL;
        tbl->nodes[hval] = node;
        tbl->n++; 
        return true;
    }
    else
    { 
        // More nodes in this slot
        fatfs_node_t *lnode, *pnode;
       
        pnode = NULL;
        lnode = tbl->nodes[hval];

        // Insert node into list so that it is sorted by filename        
        while (lnode != NULL)
        {
            if (lnode == node)
                return false;
            
            if (strcasecmp(lnode->dentry.filename, node->dentry.filename) > 0)
            {
                if (pnode != NULL)
                    pnode->hash_next = node; // Insert in the middle
                else
                    tbl->nodes[hval] = node; // Insert at the beginning
                node->hash_next = lnode;
                tbl->n++; 
                return true;
            }    
            
            pnode = lnode;    
            lnode = lnode->hash_next;
        }
        // Insert at the end
        pnode->hash_next = node;
        node->hash_next  = NULL;
        tbl->n++; 
        return true;
    }
}
Пример #21
0
void Set::update_hash()
{
	std::hash<ParamsMap::value_type::first_type> hash_fn;

	hash = 0;
	/** Because xor is associative there is no need to care about order */
	for( auto in=params.begin() ; in!=params.end() ; ++in )
		hash ^= hash_fn(in->first);

	set_desc.put( "@hash" , hash );
}
Пример #22
0
vector<string> findRepeatedDnaSequences(string s) {

        unordered_map<size_t,int> MP;
        hash<string> hash_fn;
        vector<string> ret;

        for(int i = 0; i < int(s.size()) - 9; ++i)
            if(MP[hash_fn(s.substr(i,10))]++ == 1 )
               ret.push_back(s.substr(i,10));

      return ret;
    }
Пример #23
0
void wal_engine::load(const statement& st) {
  //LOG_INFO("Load");
  record* after_rec = st.rec_ptr;
  table* tab = db->tables->at(st.table_id);
  plist<table_index*>* indices = tab->indices;

  unsigned int num_indices = tab->num_indices;
  unsigned int index_itr;

  std::string key_str = sr.serialize(after_rec, indices->at(0)->sptr);
  unsigned long key = hash_fn(key_str);

  std::string after_tuple = sr.serialize(after_rec, after_rec->sptr);

  // Add log entry
  if (!conf.recovery) {
    entry_stream.str("");
    entry_stream << st.transaction_id << " " << st.op_type << " " << st.table_id
                 << " " << after_tuple << "\n";
    entry_str = entry_stream.str();
    fs_log.push_back(entry_str);
  }

  tab->pm_data->push_back(after_rec);

  off_t storage_offset;
  storage_offset = tab->fs_data.push_back(after_tuple);

  // Add entry in indices
  for (index_itr = 0; index_itr < num_indices; index_itr++) {
    key_str = sr.serialize(after_rec, indices->at(index_itr)->sptr);
    key = hash_fn(key_str);

    indices->at(index_itr)->pm_map->insert(key, after_rec);
    indices->at(index_itr)->off_map->insert(key, storage_offset);
  }

}
Пример #24
0
int dcache_lookup(struct inode * dir, const char * name, int len, unsigned long * ino)
{
	struct hash_list * hash;
	struct dir_cache_entry *de;

	if (len > DCACHE_NAME_LEN)
		return 0;
	hash = hash_table + hash_fn(dir->i_dev, dir->i_ino, namehash(name,len));
	de = find_entry(dir, name, len, hash);
	if (!de)
		return 0;
	*ino = de->ino;
	move_to_level2(de, hash);
	return 1;
}
Пример #25
0
int wal_engine::update(const statement& st) {
  LOG_INFO("Update");
  record* rec_ptr = st.rec_ptr;
  table* tab = db->tables->at(st.table_id);
  plist<table_index*>* indices = db->tables->at(st.table_id)->indices;

  std::string key_str = sr.serialize(rec_ptr, indices->at(0)->sptr);
  unsigned long key = hash_fn(key_str);
  record* before_rec;

  // Check if key does not exist
  if (indices->at(0)->pm_map->at(key, &before_rec) == false) {
	rec_ptr->clear_data();
    delete rec_ptr;
    return EXIT_SUCCESS;
  }

  entry_stream.str("");
  entry_stream << st.transaction_id << " " << st.op_type << " " << st.table_id
               << " ";
  entry_stream << sr.serialize(before_rec, tab->sptr) << " ";

  // Update existing record
  for (int field_itr : st.field_ids) {
    if (rec_ptr->sptr->columns[field_itr].inlined == 0) {
      void* before_field = before_rec->get_pointer(field_itr);
      delete (char*) before_field;
    }

    before_rec->set_data(field_itr, rec_ptr);
  }

  std::string before_tuple;
  before_tuple = sr.serialize(before_rec, tab->sptr);
  entry_stream << before_tuple  << "\n";

  // Add log entry
  entry_str = entry_stream.str();
  fs_log.push_back(entry_str);

  off_t storage_offset = 0;
  indices->at(0)->off_map->at(key, &storage_offset);
  tab->fs_data.update(storage_offset, before_tuple);

  delete rec_ptr;
  return EXIT_SUCCESS;
}
Пример #26
0
static void
log_call(unsigned long src, unsigned long is_call, unsigned long dest)
{
	unsigned h = hash_fn(src);
	struct hash_entry *he;
	unsigned i;

	if (is_call) {
		src |= HE_IS_CALL;
	}
	tl_assert(h < NR_HASH_HEADS);
	for (he = hash_heads[h]; he && src != he->src; he = he->next) {
		;
	}
	if (!he) {
		he = VG_(malloc)("hash_entry", sizeof(*he));
		he->next = hash_heads[h];
		he->src = src;
		he->nr_entries = 0;
		he->nr_entries_allocated = 7;
		he->dest = VG_(malloc)("hash_entry->entries",
				       sizeof(he->dest[0]) * he->nr_entries_allocated);
		hash_heads[h] = he;
	} else {
		for (i = 0; i < he->nr_entries; i++) {
			if (he->dest[i] == dest) {
				return;
			}
		}
		if (he->nr_entries == he->nr_entries_allocated) {
			unsigned long *t;
			he->nr_entries_allocated += 16;
			t = VG_(malloc)("hash_entry->entries2",
					sizeof(he->dest[0]) * he->nr_entries_allocated);
			VG_(memcpy)(t, he->dest, sizeof(he->dest[0]) * he->nr_entries);
			VG_(free)(he->dest);
			he->dest = t;
		}
	}
	he->dest[he->nr_entries] = dest;
	he->nr_entries++;
}
Пример #27
0
static fatfs_node_t*
node_hash_find(fatfs_hash_table_t *tbl, 
               const char         *name,
               unsigned int        namelen,
               unsigned int        parent_cluster)
{   
    unsigned int  hval; 
    fatfs_node_t *node;

    // Calculate hash of name and get the first node in slot
    hval = hash_fn(name, namelen) % tbl->size;
    node = tbl->nodes[hval];

    CYG_TRACE2(TNC, "name='%s' hval=%d\n", name, hval);
 
    // Find the node in list wich matches the 
    // given name and parent_cluster
    while (node != NULL)
    {
        // First compare the parent cluster number and 
        // check filename length since it is faster than 
        // comparing filenames
        if (parent_cluster == node->dentry.parent_cluster &&
            '\0' == node->dentry.filename[namelen])
        {
            int i = strncasecmp(node->dentry.filename, name, namelen);

            if (i == 0)
                return node;
            else if (i > 0)
                return NULL; // Stop searching - we have a 
                             // sorted list so there can't be
                             // any matching filename further on
                             // if i > 0 - look at node_hash_add
        }
        node = node->hash_next;
    }
    
    // No such node found
    return NULL; 
}
Пример #28
0
BigInt compute_x(const std::string& hash_id,
                 const std::string& identifier,
                 const std::string& password,
                 const MemoryRegion<byte>& salt)
   {
   std::auto_ptr<HashFunction> hash_fn(
      global_state().algorithm_factory().make_hash_function(hash_id));

   hash_fn->update(identifier);
   hash_fn->update(":");
   hash_fn->update(password);

   SecureVector<byte> inner_h = hash_fn->final();

   hash_fn->update(salt);
   hash_fn->update(inner_h);

   SecureVector<byte> outer_h = hash_fn->final();

   return BigInt::decode(outer_h);
   }
Пример #29
0
/* Remove the process from the global hash table. */
static inline void phash_remove(process_t process)
{
	phashtable_t bucket;
	process_t p, link;

	spin_lock(&phashlock);
	bucket = &phash[hash_fn(process->pid)];
	p = bucket->proc;

	if(p == process)
	{
		p = process->next;
	}
	else
	{
		for(link=p; (link->next!=process) || (link->next != NULL); link = link->next)
		;
		link->next = process->next;
	}
	spin_unlock(&phashlock);
}
Пример #30
0
unsigned long hash_lookup(hash_t *hash, unsigned long key)
{
	unsigned int bucket;
	hash_entry_t *curr;

	bucket = hash_fn(hash,key);
	curr = hash->table[bucket];
	for (;;){
		/* entry not found */
		if (curr == NULL)
			return HASH_ENTRY_NOTFOUND;

		/* entry found */
		if (curr->key == key)
			break;

		curr = curr->next;
	}
	return curr->val;

}