Alloc cache per thread gets used for deleted items.

git-svn-id: file:///svn/unbound/trunk@280 be551aaa-1e26-0410-a405-d3ace91eadb9

diff --git a/daemon/worker.c b/daemon/worker.c
index 8a25742f8194cf5f4f3333f0200de7e44396c285..8c770be9730b2e9e5795bdf39d0372e12e61f4fd 100644 (file)
--- a/daemon/worker.c
+++ b/daemon/worker.c
@@ -138,7 +138,7 @@ worker_store_rrsets(struct worker* worker, struct reply_info* rep)
                /* TODO: check if update really needed */
                slabhash_insert(worker->daemon->rrset_cache, 
                        rep->rrsets[i]->entry.hash, &rep->rrsets[i]->entry,
-                       rep->rrsets[i]->entry.data);
+                       rep->rrsets[i]->entry.data, &worker->alloc);
        }
 }
 
@@ -200,7 +200,7 @@ worker_handle_reply(struct comm_point* c, void* arg, int error,
                return 0;
        }
        slabhash_insert(w->worker->daemon->msg_cache, w->query_hash, 
-               &e->entry, rep);
+               &e->entry, rep, &w->worker->alloc);
        return 0;
 }
 

diff --git a/doc/Changelog b/doc/Changelog
index 501d65ba536d58beffa8942e3cdc3a042801d327..a54c1c303940d604d52345acfbbd075ee220c69b 100644 (file)
--- a/doc/Changelog
+++ b/doc/Changelog
@@ -1,6 +1,8 @@
 4 May 2007: Wouter
        - msgreply sizefunc is more accurate.
        - config settings for rrset cache size and slabs.
+       - hashtable insert takes argument so that a thread can use its own
+         alloc cache to store released keys.
 
 3 May 2007: Wouter
        - fill refs. Use new parse and encode to answer queries.

diff --git a/testcode/unitlruhash.c b/testcode/unitlruhash.c
index a729cb2dcd83df66f840aafc7a7efa1bcb15d2db..09275564f95a57aa354a360b350bdc7a1866a186 100644 (file)
--- a/testcode/unitlruhash.c
+++ b/testcode/unitlruhash.c
@@ -233,8 +233,8 @@ test_short_table(struct lruhash* table)
        k->entry.data = d;
        k2->entry.data = d2;
 
-       lruhash_insert(table, myhash(12), &k->entry, d);
-       lruhash_insert(table, myhash(14), &k2->entry, d2);
+       lruhash_insert(table, myhash(12), &k->entry, d, NULL);
+       lruhash_insert(table, myhash(14), &k2->entry, d2, NULL);
        
        unit_assert( lruhash_lookup(table, myhash(12), k, 0) == &k->entry);
        lock_rw_unlock( &k->entry.lock );
@@ -255,7 +255,7 @@ testadd(struct lruhash* table, struct testdata* ref[])
        struct testdata* data = newdata(numtoadd);
        struct testkey* key = newkey(numtoadd);
        key->entry.data = data;
-       lruhash_insert(table, myhash(numtoadd), &key->entry, data);
+       lruhash_insert(table, myhash(numtoadd), &key->entry, data, NULL);
        ref[numtoadd] = data;
 }
 
@@ -333,7 +333,7 @@ testadd_unlim(struct lruhash* table, struct testdata** ref)
        struct testdata* data = newdata(numtoadd);
        struct testkey* key = newkey(numtoadd);
        key->entry.data = data;
-       lruhash_insert(table, myhash(numtoadd), &key->entry, data);
+       lruhash_insert(table, myhash(numtoadd), &key->entry, data, NULL);
        if(ref)
                ref[numtoadd] = data;
 }

diff --git a/testcode/unitslabhash.c b/testcode/unitslabhash.c
index c407b95c012c7eded07bf6719f9e78f2969d3606..1db0ed20c4c80d07aca80b54f8c1ad8fa7827109 100644 (file)
--- a/testcode/unitslabhash.c
+++ b/testcode/unitslabhash.c
@@ -110,8 +110,8 @@ test_short_table(struct slabhash* table)
        k->entry.data = d;
        k2->entry.data = d2;
 
-       slabhash_insert(table, myhash(12), &k->entry, d);
-       slabhash_insert(table, myhash(14), &k2->entry, d2);
+       slabhash_insert(table, myhash(12), &k->entry, d, NULL);
+       slabhash_insert(table, myhash(14), &k2->entry, d2, NULL);
        
        unit_assert( slabhash_lookup(table, myhash(12), k, 0) == &k->entry);
        lock_rw_unlock( &k->entry.lock );
@@ -132,7 +132,7 @@ testadd(struct slabhash* table, struct slabtestdata* ref[])
        struct slabtestdata* data = newdata(numtoadd);
        struct slabtestkey* key = newkey(numtoadd);
        key->entry.data = data;
-       slabhash_insert(table, myhash(numtoadd), &key->entry, data);
+       slabhash_insert(table, myhash(numtoadd), &key->entry, data, NULL);
        ref[numtoadd] = data;
 }
 
@@ -219,7 +219,7 @@ testadd_unlim(struct slabhash* table, struct slabtestdata** ref)
        struct slabtestdata* data = newdata(numtoadd);
        struct slabtestkey* key = newkey(numtoadd);
        key->entry.data = data;
-       slabhash_insert(table, myhash(numtoadd), &key->entry, data);
+       slabhash_insert(table, myhash(numtoadd), &key->entry, data, NULL);
        if(ref)
                ref[numtoadd] = data;
 }

diff --git a/util/alloc.c b/util/alloc.c
index a1231e1a3eeeb52f48195dc1095119dbeed10d55..5ba9a725c1280d842a48a1b6062c23fdd0face60 100644 (file)
--- a/util/alloc.c
+++ b/util/alloc.c
@@ -208,6 +208,9 @@ alloc_special_release(struct alloc_cache* alloc, alloc_special_t* mem)
        log_assert(alloc);
        if(!mem)
                return;
+       if(!alloc->super) /* superalloc needs locking */
+               lock_quick_lock(&alloc->lock);
+
        alloc_special_clean(mem);
        if(alloc->super && alloc->num_quar >= ALLOC_SPECIAL_MAX) {
                /* push it to the super structure */
@@ -218,6 +221,8 @@ alloc_special_release(struct alloc_cache* alloc, alloc_special_t* mem)
        alloc_set_special_next(mem, alloc->quar);
        alloc->quar = mem;
        alloc->num_quar++;
+       if(!alloc->super)
+               lock_quick_unlock(&alloc->lock);
 }
 
 void 

diff --git a/util/data/packed_rrset.c b/util/data/packed_rrset.c
index 41599bec5db8bd2abef3010f2e264cdc9d0d7e23..7c7a8c12fae2955d06c0cec39fd09e082f3f66f1 100644 (file)
--- a/util/data/packed_rrset.c
+++ b/util/data/packed_rrset.c
@@ -108,9 +108,7 @@ ub_rrset_key_delete(void* key, void* userdata)
        k->id = 0;
        free(k->rk.dname);
        k->rk.dname = NULL;
-       lock_quick_lock(&a->lock);
        alloc_special_release(a, k);
-       lock_quick_unlock(&a->lock);
 }
 
 void 

diff --git a/util/storage/lruhash.c b/util/storage/lruhash.c
index 4574574c264c069856f68dd60f86d2635dfb9ba6..43eec5e61d2afac8e6b4be39578bba86e538addf 100644 (file)
--- a/util/storage/lruhash.c
+++ b/util/storage/lruhash.c
@@ -288,12 +288,13 @@ lru_touch(struct lruhash* table, struct lruhash_entry* entry)
 
 void 
 lruhash_insert(struct lruhash* table, hashvalue_t hash,
-        struct lruhash_entry* entry, void* data)
+        struct lruhash_entry* entry, void* data, void* cb_arg)
 {
        struct lruhash_bin* bin;
        struct lruhash_entry* found, *reclaimlist=NULL;
        size_t need_size;
        need_size = table->sizefunc(entry->key, data);
+       if(cb_arg == NULL) cb_arg = table->cb_arg;
 
        /* find bin */
        lock_quick_lock(&table->lock);
@@ -312,10 +313,10 @@ lruhash_insert(struct lruhash* table, hashvalue_t hash,
                /* if so: update data - needs a writelock */
                table->space_used += need_size -
                        (*table->sizefunc)(found->key, found->data);
-               (*table->delkeyfunc)(entry->key, table->cb_arg);
+               (*table->delkeyfunc)(entry->key, cb_arg);
                lru_touch(table, found);
                lock_rw_wrlock(&found->lock);
-               (*table->deldatafunc)(found->data, table->cb_arg);
+               (*table->deldatafunc)(found->data, cb_arg);
                found->data = data;
                lock_rw_unlock(&found->lock);
        }
@@ -331,8 +332,8 @@ lruhash_insert(struct lruhash* table, hashvalue_t hash,
                struct lruhash_entry* n = reclaimlist->overflow_next;
                void* d = reclaimlist->data;
                lock_rw_unlock(&reclaimlist->lock);
-               (*table->delkeyfunc)(reclaimlist->key, table->cb_arg);
-               (*table->deldatafunc)(d, table->cb_arg);
+               (*table->delkeyfunc)(reclaimlist->key, cb_arg);
+               (*table->deldatafunc)(d, cb_arg);
                reclaimlist = n;
        }
 }

diff --git a/util/storage/lruhash.h b/util/storage/lruhash.h
index 76a939cf2e1dc7358ef392747d91f786fa08f121..6257559b72e3343338b5cef313a35f5047dd96e1 100644 (file)
--- a/util/storage/lruhash.h
+++ b/util/storage/lruhash.h
@@ -246,9 +246,10 @@ void lruhash_delete(struct lruhash* table);
  *     But entry->data is set to NULL before deletion, and put into
  *     the existing entry. The data is then freed.
  * @param data: the data.
+ * @param cb_override: if not null overrides the cb_arg for the deletefunc.
  */
 void lruhash_insert(struct lruhash* table, hashvalue_t hash, 
-       struct lruhash_entry* entry, void* data);
+       struct lruhash_entry* entry, void* data, void* cb_override);
 
 /**
  * Lookup an entry in the hashtable.

diff --git a/util/storage/slabhash.c b/util/storage/slabhash.c
index 39c954ff6ccfb073c5aa6797391f8ef0749032aa..1a31df41d08d266c56135a7c9f171ff12df1182e 100644 (file)
--- a/util/storage/slabhash.c
+++ b/util/storage/slabhash.c
@@ -105,9 +105,9 @@ slab_idx(struct slabhash* sl, hashvalue_t hash)
 }
 
 void slabhash_insert(struct slabhash* sl, hashvalue_t hash, 
-       struct lruhash_entry* entry, void* data)
+       struct lruhash_entry* entry, void* data, void* arg)
 {
-       lruhash_insert(sl->array[slab_idx(sl, hash)], hash, entry, data);
+       lruhash_insert(sl->array[slab_idx(sl, hash)], hash, entry, data, arg);
 }
 
 struct lruhash_entry* slabhash_lookup(struct slabhash* sl, 

diff --git a/util/storage/slabhash.h b/util/storage/slabhash.h
index 553d12d66d5cbb7a5dde619a29f9f2c130579dfe..a644ffe90a451e5c1896cb49ef26221238964d0f 100644 (file)
--- a/util/storage/slabhash.h
+++ b/util/storage/slabhash.h
@@ -101,9 +101,10 @@ void slabhash_delete(struct slabhash* table);
  *     But entry->data is set to NULL before deletion, and put into
  *     the existing entry. The data is then freed.
  * @param data: the data.
+ * @param cb_override: if not NULL overrides the cb_arg for deletfunc.
  */
 void slabhash_insert(struct slabhash* table, hashvalue_t hash, 
-       struct lruhash_entry* entry, void* data);
+       struct lruhash_entry* entry, void* data, void* cb_override);
 
 /**
  * Lookup an entry in the hashtable. Uses lruhash_lookup.