Exemplo n.º 1
0
static void free_bucket(bucket* buck) {
	if (buck == NULL) {
		return;
	}
	free_bucket(buck->next);
	munmap((void *) buck,sizeof(bucket)+buck->len);
}
Exemplo n.º 2
0
void free(void * ptr) {
	if (ptr == NULL) {
		return;
	}
	pthread_mutex_lock(&thread_list_mutex);
	localthread* lt = get_localthread(pthread_self());
	pthread_mutex_unlock(&thread_list_mutex);
	if (lt == NULL) {
		return;
	}
	//we get realsize that was calculated
	size_t * size_ptr = ((size_t *) ptr) - sizeof(size_t);
	size_t realsize = *size_ptr;
	if (realsize < MIN_SIZE) {
		//lin
		bucket* buck = (bucket*) (ptr-sizeof(bucket));
		pthread_mutex_lock(&(lt->small_bucket_mutex));
		if (bucket_list_size(lt->small_list) < SML_LIMIT) {
			buck->next = lt->small_list;
			lt->small_list = buck;
			buck = NULL;
		}
		pthread_mutex_unlock(&(lt->small_bucket_mutex));
		if (buck) {
			free_bucket(buck);
		}
	} else if (realsize < MAX_SIZE) {
		//heap thingy free blahblah
	} else {
		//dumbfree
		munmap((void *) size_ptr, *size_ptr);
	}	
}
Exemplo n.º 3
0
void free_bucket(struct bucket * b){
    if(b){
        if(b->next)        
            free_bucket(b->next);
        free(b);
    }
}
Exemplo n.º 4
0
void HashIdx::release_node(VElt *bucket)
{
	if (bucket-> blink != NULL)
		bucket->blink->flink = bucket->flink;
	if (bucket -> flink != NULL)
		bucket -> flink -> blink = bucket -> blink;
	free_bucket (bucket);
}
Exemplo n.º 5
0
static void free_localthread(localthread* lt) {
	if (lt == NULL) {
		return;
	}
	free_bucket(lt->small_list);
	pthread_mutex_destroy(&(lt->small_bucket_mutex));
	free_localthread(lt->next);
	munmap((void *)lt, sizeof(localthread));
}
Exemplo n.º 6
0
static void free_bucket_node(BucketNode * const bucket_node)
{
    if (bucket_node == NULL) {
        return;
    }
    free_bucket(&bucket_node->bucket);
    bucket_node->type = NODE_TYPE_NONE;
    bucket_node->parent = NULL;
    free(bucket_node);
}
Exemplo n.º 7
0
static void
free_bucket(genhash_t* h, struct genhash_entry_t* b)
{
    if(b != NULL) {
        free_bucket(h, b->next);
        h->ops.freeKey(b->key);
        h->ops.freeValue(b->value);
        free(b);
    }
}
Exemplo n.º 8
0
void
chunk_remove_free(struct malloc_infos *list, struct chunk *chunk)
{
  int i;

  i = free_bucket(chunk->size);
  LIST_REMOVE(list->lfree[i], chunk, free);
  list->lfree_cnt[i]--;
  chunk->type = MALLOC_CHUNK_USED;
}
Exemplo n.º 9
0
void
genhash_free(genhash_t* h)
{
    if(h != NULL) {
        size_t i=0;
        for(i=0; i<h->size; i++) {
            free_bucket(h, h->buckets[i]);
        }
        free(h);
    }
}
Exemplo n.º 10
0
void
chunk_append_free(struct malloc_infos *list, struct chunk *chunk)
{
  int i;

  i = free_bucket(chunk->size);
  LIST_APPEND(list->lfree[i], chunk, free);
  list->lfree_cnt[i]++;
  chunk->type = MALLOC_CHUNK_FREE;
  chunk->asked_size = 0;
}
Exemplo n.º 11
0
void Shash_free(T *hash)
{
    assert(hash);
    /* 注意还要释放桶内节点 */
    int i;
    for (i = 0; i < hash->len; ++i) {
        free_bucket(&hash->buckets[i]);
    }
    FREE(hash->buckets);
    FREE(hash);
}
Exemplo n.º 12
0
void map_clear(hashmap_t* map)
{
	for(size_t i = 0; i < map->active_buckets.length; ++i)
	{
		unsigned long pos = *(unsigned long*)vec_get(&map->active_buckets, i);
		hashmap_node_t* node = map->buckets[pos];
		free_bucket(node);
		map->buckets[pos] = NULL;
	}
	
	vec_clear(&map->active_buckets);
}
Exemplo n.º 13
0
void free_hashmap(struct hashmap * map){
    if(map){
        if(map->table){
            for(int i = 0; i < map->index_size; i++){
                if(map->table[i])
                    free_bucket(map->table[i]);
            }
            free(map->table);
        }
        free(map);
    }
}
Exemplo n.º 14
0
static void free_bucket_entries(hash_table *table){
    int i;
    bucket *element_to_delete, *t_item;
    for (i=0; i< table->size; i++){
        t_item = table->table[i];
        while(t_item) {
            element_to_delete = t_item;
            t_item = t_item->next;
            free_bucket(element_to_delete);
        }
        
    }
}
Exemplo n.º 15
0
static void free_buckets(__cilkrts_worker  *w, 
                         bucket           **buckets,
                         size_t             nbuckets)
{
    size_t i;

#if REDPAR_DEBUG >= 1
    verify_current_wkr(w);
    fprintf(stderr, "W=%d, desc=free_buckets, buckets=%p, size=%zd\n",
	    w->self, buckets,
	    nbuckets * sizeof(*buckets));
#endif

    for (i = 0; i < nbuckets; ++i)
        free_bucket(w, buckets + i);

    __cilkrts_frame_free(w, buckets, nbuckets * sizeof(*buckets));
}
Exemplo n.º 16
0
/* grow bucket by one element, reallocating bucket if necessary */
elem *cilkred_map::grow(__cilkrts_worker *w, 
                        bucket          **bp)
{
    size_t i, nmax, nnmax;
    bucket *b, *nb;

    b = *bp;
    if (b) {
        nmax = b->nmax;
        /* find empty element if any */
        for (i = 0; i < nmax; ++i) 
            if (b->el[i].key == 0) 
                return &(b->el[i]);
        /* do not use the last one even if empty */
    } else {
        nmax = 0;
    }

    verify_current_wkr(w);
    /* allocate a new bucket */
    nnmax = roundup(2 * nmax);
    nb = alloc_bucket(w, nnmax);


    /* copy old bucket into new */
    for (i = 0; i < nmax; ++i)
        nb->el[i] = b->el[i];
     
    free_bucket(w, bp); *bp = nb;

    /* zero out extra elements */
    for (; i < nnmax; ++i)
        nb->el[i].key = 0;

    /* zero out the last one */
    nb->el[i].key = 0;
  
    return &(nb->el[nmax]);
}