C++ HashNode类代码示例

void HashGraph::RefreshVertices(unsigned minCount)
{
#pragma omp parallel for
    for (int64 i = 0; i < (int64)table_size; ++i)
    {
        HashNode *node = table[i];
        HashNode *prev = NULL;
        while (node != NULL)
        {
            if (node->IsDead() || node->Count() < minCount)
            {
#pragma omp atomic
                --num_nodes;
                if (prev == NULL)
                {
                    table[i] = node->next;
                    FreeNode(node, omp_get_thread_num());
                    node = table[i];
                }
                else
                {
                    prev->next = node->next;
                    FreeNode(node, omp_get_thread_num());
                    node = prev->next;
                }
            }
            else
            {
                node->ClearStatus();
                prev = node;
                node = prev->next;
            }
        }
    }
}

	void resize() {
		int new_length = 4;
		while(new_length < elems_) {
			new_length <<= 1;
		}
		HashNode** new_list = new HashNode*[new_length];
		memset(new_list, 0, sizeof(new_list[0]) * new_length);
		int count = 0;

		for(int i=0; i<length_; ++i) {
			HashNode* now = list_[i];
			while(now != NULL) {
				HashNode* next = now->next_hash;
				Slice key = now->key();
				int hash = now->hash;
				HashNode** ptr = &new_list[hash & (new_length - 1)];

				now->next_hash = *ptr;
				*ptr = now;
				now = next;
				count++;
			}
		}
		assert(elems_ == count);
		delete[] list_;
		list_ = new_list;
		length_ = new_length;
	}

void HashGraph::ClearGraph()
{
    for (unsigned i = 0; i < table_size; ++i)
    {
        for (HashNode *node = table[i]; node != NULL; node = node->next)
        {
            node->Clear();
            node->SetCount(1);
        }
    }
    num_edges = 0;
}

void HashGraph::AddAllEdges()
{
    num_edges = 0;
#pragma omp parallel for
    for (int64 i = 0; i < (int64)table_size; ++i)
    {
        for (HashNode *node = table[i]; node; node = node->next)
        {
            node->SetInEdges(15);
            node->SetOutEdges(15);
        }
    }
}

void GrCCPathCache::evict(const GrCCPathCache::Key& key, GrCCPathCacheEntry* entry) {
    if (!entry) {
        HashNode* node = fHashTable.find(key);
        SkASSERT(node);
        entry = node->entry();
    }
    SkASSERT(*entry->fCacheKey == key);
    SkASSERT(!entry->hasBeenEvicted());
    entry->fCacheKey->markShouldUnregisterFromPath();  // Unregister the path listener.
    entry->releaseCachedAtlas(this);
    fLRU.remove(entry);
    fHashTable.remove(key);
}

double HashGraph::AverageCoverage()
{
    long long sum = 0;
    uint64 valid = 0;
    for (int64 i = 0; i < table_size; ++i)
    {
        for (HashNode *node = table[i]; node; node = node->next)
        {
            sum += node->Count();
            ++valid;
        }
    }

    return 1.0 * sum / valid;
}

int CTECHashTable<Type>:: findPosition(HashNode<Type> currentNode){
	int position = 0;

	position = currentNode.getKey()%capacity;

	return position;
}

double HashGraph::MedianCoverage()
{
    vector<int> v;
    v.reserve(num_nodes);
    for (int64 i = 0; i < table_size; ++i)
    {
        for (HashNode *node = table[i]; node; node = node->next)
        {
            v.push_back(node->Count());
        }
    }

    nth_element(v.begin(), v.begin() + v.size()/2, v.end());

    return *(v.begin() + v.size()/2);
}

	HashNode* insert(const Slice& key, int& hit_id, int& rep_id) {
		HashNode* e = reinterpret_cast<HashNode*>(malloc(sizeof(HashNode) - 1 + key.size()));
		e->key_length = key.size();
		e->hash = hash_slice(key);
		memcpy(e->key_data, key.data(), key.size());

		lru_append(e);
		HashNode* old = table_.insert(e);

		if(old != NULL) {
			//命中缓存
			e->cache_id = old->cache_id;

			hit_id = e->cache_id;
			rep_id = -1;

			lru_remove(old);
			lru_release(old);

			//update hit ratio
			hit_cnt++;
		}
		else {
			//没有命中缓存
			hit_id = -1;

			//如果当前的缓存数量超过capacity，把lru_后面的那个缓存单元淘汰掉
			if(table_.size() > capacity_) {
				HashNode* cursor = lru_.next;
				lru_remove(cursor);
				table_.remove(cursor->key(), cursor->hash);

				e->cache_id = cursor->cache_id;
				lru_release(cursor);
			}
			else {
				e->cache_id = last_id++;  //TODO 会无限增长?
			}

			rep_id = e->cache_id;

			//update hit ratio
			set_cnt++;
		}

		return e;
	}

long HashTable<Type> :: findPosition(Type data)
{
    long insertedPosition;
    unsigned long address =(long)&data;
    insertedPosition = address % capacity;
    HashNode<Type>* indexPointer = front;
    for (long index = 0; index < insertedPosition; index++)
    {
        indexPointer = indexPointer->getNode();
    }
if (indexPointer->hasStuffed())
{
    insertedPosition = handleCollision(data, insertedPosition);
}
    
    return insertedPosition;
}

int HashTable<Type> :: findPosition(HashNode<Type> currentNode)
{
    //We are going "hash" the key of the HashNode to find its value.
    int position = 0;
    
    position = currentNode.getKey() % capacity;
    return position;
}

int CTECHashTable<Type>::findTablePosition(HashNode<Type> currentNode)
{
	//We are going to "hash" the key of the hashnode to find its storage spot.
	int position = 0;

	position = currentNode.getKey() % tableCapacity;

	return position;
}

void HashGraph::RefreshEdges()
{
    num_edges = 0;
#pragma omp parallel for
    for (int64 i = 0; i < (int64)table_size; ++i)
    {
        for (HashNode *node = table[i]; node; node = node->next)
        {
            KmerNodeAdapter curr(node);
            for (int strand = 0; strand < 2; ++strand)
            {
                Kmer kmer;
                curr.GetKmer(kmer);
                unsigned edges = curr.OutEdges();
                for (int x = 0; x < 4; ++x)
                {
                    if (edges & (1 << x))
                    {
                        Kmer next = kmer;
                        next.AddRight(x);
                        if (GetNode(next) == NULL)
                            curr.RemoveOutEdge(x);
                        else
                        {
#pragma omp atomic
                            ++num_edges;
                        }
                    }
                }

                curr.ReverseComplement();
            }

            if (node->kmer.IsPalindrome())
            {
                unsigned edges = node->InEdges() | node->OutEdges();
                node->SetInEdges(edges);
                node->SetOutEdges(edges);
            }
        }
    }

    num_edges >>= 1;
}

bool CTECHashTable<Type>:: contains(HashNode<Type> currentNode){
	bool isInTable = false;

	int possibleLocation = findPosition(currentNode);

	while(internalStorage[possibleLocation] != nullptr && !isInTable){
		if(internalStorage[possibleLocation] == currentNode.getValue()){
			isInTable = true;
		}
		possibleLocation = (possibleLocation + 1) % capacity;
	}

	return isInTable;
}

bool CTECHashTable<Type>:: remove(HashNode<Type> currentNode){
	bool hasBeenRemoved = false;
	int possibleLocation = findPosition(currentNode);

	if(contains(currentNode)){
		while(internalStorage[possibleLocation] != nullptr && !hasBeenRemoved){
			if(internalStorage[possibleLocation] == currentNode.getValue()){
				hasBeenRemoved = true;
				internalStorage[possibleLocation] = nullptr;
			}
			possibleLocation = (possibleLocation + 1) % capacity;
		}
	}
	return hasBeenRemoved;
}