Kick the hash_slinger interface around a bit:

Isolate more stuff in hash_slinger.h.

Remove hash_slinger from cache.h, include in .c's as necessary.

Save a malloc per objhead by putting a few fields into the objhead
for the hash_slingers to use.

Preinitialize the refcount when we precreate the objhead.

Move the hash-string allocation into HSH_Copy(), no point in
duplication of mandatory step.

git-svn-id: svn+ssh://projects.linpro.no/svn/varnish/trunk@3405 d4fa192b-c00b-0410-8231-f00ffab90ce4

diff --git a/varnish-cache/bin/varnishd/cache.h b/varnish-cache/bin/varnishd/cache.h
index 601bdd118b4046006c04ab6748a44f19e5c4e687..0358156671ffb01ecb79195e5cdd1350bc97e8cf 100644 (file)
--- a/varnish-cache/bin/varnishd/cache.h
+++ b/varnish-cache/bin/varnishd/cache.h
@@ -29,6 +29,12 @@
  * $Id$
  */
 
+/*
+ * This macro can be used in .h files to isolate bits that the manager
+ * should not (need to) see, such as pthread mutexes etc.
+ */
+#define VARNISH_CACHE_CHILD    1
+
 #include <sys/time.h>
 #include <sys/uio.h>
 #include <sys/socket.h>
@@ -213,8 +219,6 @@ struct workreq {
        void                    *priv;
 };
 
-#include "hash_slinger.h"
-
 /* Backend Request ---------------------------------------------------*/
 
 struct bereq {
@@ -291,19 +295,6 @@ struct object {
        int                     hits;
 };
 
-struct objhead {
-       unsigned                magic;
-#define OBJHEAD_MAGIC          0x1b96615d
-       void                    *hashpriv;
-
-       struct lock             mtx;
-       unsigned                refcnt;
-       VTAILQ_HEAD(,object)    objects;
-       char                    *hash;
-       unsigned                hashlen;
-       VTAILQ_HEAD(, sess)     waitinglist;
-};
-
 /* -------------------------------------------------------------------*/
 
 struct sess {
@@ -449,18 +440,6 @@ int Fetch(struct sess *sp);
 int FetchReqBody(struct sess *sp);
 void Fetch_Init(void);
 
-/* cache_hash.c */
-void HSH_Prealloc(struct sess *sp);
-void HSH_Freestore(struct object *o);
-int HSH_Compare(const struct sess *sp, const struct objhead *o);
-void HSH_Copy(const struct sess *sp, const struct objhead *o);
-struct object *HSH_Lookup(struct sess *sp);
-void HSH_Unbusy(const struct sess *sp);
-void HSH_Ref(struct object *o);
-void HSH_Deref(struct object *o);
-double HSH_Grace(double g);
-void HSH_Init(void);
-
 /* cache_http.c */
 const char *http_StatusMessage(unsigned);
 void HTTP_Init(void);

diff --git a/varnish-cache/bin/varnishd/cache_center.c b/varnish-cache/bin/varnishd/cache_center.c
index 9d451f4f6b10da77ff2b2fa0b076639e44202a04..f40a78f221951bc56227cc20d5b8823248bb4fa3 100644 (file)
--- a/varnish-cache/bin/varnishd/cache_center.c
+++ b/varnish-cache/bin/varnishd/cache_center.c
@@ -75,6 +75,7 @@ DOT acceptor -> start [style=bold,color=green,weight=4]
 #include "vcl.h"
 #include "cli_priv.h"
 #include "cache.h"
+#include "hash_slinger.h"
 
 static unsigned xids;
 

diff --git a/varnish-cache/bin/varnishd/cache_cli.c b/varnish-cache/bin/varnishd/cache_cli.c
index 5abdbe65358ac63704c61fc4f24db67df4eb2346..2a9481652d38c70c93418fdfcb014b1ae59971e1 100644 (file)
--- a/varnish-cache/bin/varnishd/cache_cli.c
+++ b/varnish-cache/bin/varnishd/cache_cli.c
@@ -52,6 +52,7 @@
 #include "cache.h"
 #include "vlu.h"
 #include "vsb.h"
+#include "hash_slinger.h"
 
 pthread_t              cli_thread;
 static struct lock     cli_mtx;

diff --git a/varnish-cache/bin/varnishd/cache_expire.c b/varnish-cache/bin/varnishd/cache_expire.c
index c97b94a14e12c08406967f3fd3f4a198fc284ee7..4fa9b067d464a145d32662845d7026b4efd4250b 100644 (file)
--- a/varnish-cache/bin/varnishd/cache_expire.c
+++ b/varnish-cache/bin/varnishd/cache_expire.c
@@ -60,6 +60,7 @@
 #include "shmlog.h"
 #include "binary_heap.h"
 #include "cache.h"
+#include "hash_slinger.h"
 
 /*
  * Objects have sideways references in the binary heap and the LRU list

diff --git a/varnish-cache/bin/varnishd/cache_hash.c b/varnish-cache/bin/varnishd/cache_hash.c
index f03d02fa114847eec0c9090d50def60c829a7ef8..8596c61b4bce1082a545798032b9f5a2866d671c 100644 (file)
--- a/varnish-cache/bin/varnishd/cache_hash.c
+++ b/varnish-cache/bin/varnishd/cache_hash.c
@@ -65,6 +65,7 @@
 #include "shmlog.h"
 #include "cache.h"
 #include "stevedore.h"
+#include "hash_slinger.h"
 
 static const struct hash_slinger *hash;
 
@@ -91,12 +92,23 @@ HSH_Prealloc(struct sess *sp)
                w->nobjhead = calloc(sizeof *w->nobjhead, 1);
                XXXAN(w->nobjhead);
                w->nobjhead->magic = OBJHEAD_MAGIC;
+               w->nobjhead->refcnt = 1;
                VTAILQ_INIT(&w->nobjhead->objects);
                VTAILQ_INIT(&w->nobjhead->waitinglist);
                Lck_New(&w->nobjhead->mtx);
                VSL_stats->n_objecthead++;
        } else
                CHECK_OBJ_NOTNULL(w->nobjhead, OBJHEAD_MAGIC);
+
+#if 0
+       /* Make sure there is space enough for the hash-string */
+       if (w->nobjhead->hashlen < sp->lhashptr) {
+               w->objhead->hash = realloc(w->objhead->hash, sp->lhashptr);
+               w->objhead->hashlen = sp->lhashptr;
+               AN(w->objhead->hash);
+       }
+#endif
+
        if (w->nobj == NULL) {
                st = STV_alloc(sp, params->obj_workspace);
                XXXAN(st);
@@ -167,7 +179,7 @@ HSH_Compare(const struct sess *sp, const struct objhead *oh)
 }
 
 void
-HSH_Copy(const struct sess *sp, const struct objhead *oh)
+HSH_Copy(const struct sess *sp, struct objhead *oh)
 {
        unsigned u, v;
        char *b;
@@ -175,7 +187,9 @@ HSH_Copy(const struct sess *sp, const struct objhead *oh)
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
        CHECK_OBJ_NOTNULL(oh, OBJHEAD_MAGIC);
 
-       assert(oh->hashlen >= sp->lhashptr);
+       oh->hash = malloc(sp->lhashptr);
+       XXXAN(oh->hash);
+       oh->hashlen = sp->lhashptr;
        b = oh->hash;
        for (u = 0; u < sp->ihashptr; u += 2) {
                v = pdiff(sp->hashptr[u], sp->hashptr[u + 1]);
@@ -210,6 +224,7 @@ HSH_Lookup(struct sess *sp)
                CHECK_OBJ_NOTNULL(oh, OBJHEAD_MAGIC);
                Lck_Lock(&oh->mtx);
        } else {
+               AN(w->nobjhead);
                oh = hash->lookup(sp, w->nobjhead);
                CHECK_OBJ_NOTNULL(oh, OBJHEAD_MAGIC);
                if (oh == w->nobjhead)

diff --git a/varnish-cache/bin/varnishd/cache_main.c b/varnish-cache/bin/varnishd/cache_main.c
index 52a262824cc0335ef723eb3986883912ff44c371..fef042372b70ba181955cbb315177f715863c283 100644 (file)
--- a/varnish-cache/bin/varnishd/cache_main.c
+++ b/varnish-cache/bin/varnishd/cache_main.c
@@ -39,6 +39,7 @@
 #include "shmlog.h"
 #include "cache.h"
 #include "stevedore.h"
+#include "hash_slinger.h"
 
 /*--------------------------------------------------------------------
  * Per thread storage for the session currently being processed by

diff --git a/varnish-cache/bin/varnishd/cache_pool.c b/varnish-cache/bin/varnishd/cache_pool.c
index 90e9b90fca71414ecf8f037e1af8d706c1c9e13d..59973fd47b0cb5f6486b3b2ecae95331bdcea51f 100644 (file)
--- a/varnish-cache/bin/varnishd/cache_pool.c
+++ b/varnish-cache/bin/varnishd/cache_pool.c
@@ -71,6 +71,7 @@
 #include "cli_priv.h"
 #include "cache.h"
 #include "stevedore.h"
+#include "hash_slinger.h"
 
 VTAILQ_HEAD(workerhead, worker);
 

diff --git a/varnish-cache/bin/varnishd/cache_vrt.c b/varnish-cache/bin/varnishd/cache_vrt.c
index c29d3be8ab23f6bd686b4c9c969a87e6e4d1d029..c99c0e28e599a87511190652b8b2eec99ced708f 100644 (file)
--- a/varnish-cache/bin/varnishd/cache_vrt.c
+++ b/varnish-cache/bin/varnishd/cache_vrt.c
@@ -50,6 +50,7 @@
 #include "vrt_obj.h"
 #include "vcl.h"
 #include "cache.h"
+#include "hash_slinger.h"
 #include "cache_backend.h"
 
 void *vrt_magic_string_end = &vrt_magic_string_end;

diff --git a/varnish-cache/bin/varnishd/hash_classic.c b/varnish-cache/bin/varnishd/hash_classic.c
index 280d50ebdfb2f1485976c6e17a16d0498bb706a7..fb14ddc232aa4ff8283c8cf095ea3c6e89c9870d 100644 (file)
--- a/varnish-cache/bin/varnishd/hash_classic.c
+++ b/varnish-cache/bin/varnishd/hash_classic.c
@@ -40,23 +40,14 @@
 
 #include "shmlog.h"
 #include "cache.h"
+#include "hash_slinger.h"
 
 /*--------------------------------------------------------------------*/
 
-struct hcl_entry {
-       unsigned                magic;
-#define HCL_ENTRY_MAGIC                0x0ba707bf
-       VTAILQ_ENTRY(hcl_entry) list;
-       struct hcl_hd           *head;
-       struct objhead          *oh;
-       unsigned                digest;
-       unsigned                hash;
-};
-
 struct hcl_hd {
        unsigned                magic;
 #define HCL_HEAD_MAGIC         0x0f327016
-       VTAILQ_HEAD(, hcl_entry)        head;
+       VTAILQ_HEAD(, objhead)  head;
        struct lock             mtx;
 };
 
@@ -126,16 +117,13 @@ hcl_start(void)
 static struct objhead *
 hcl_lookup(const struct sess *sp, struct objhead *noh)
 {
-       struct objhead *roh;
-       struct hcl_entry *he, *he2;
+       struct objhead *oh;
        struct hcl_hd *hp;
-       unsigned u1, digest, r;
+       unsigned u1, digest;
        unsigned u, v;
        int i;
 
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-       CHECK_OBJ_NOTNULL(sp->wrk, WORKER_MAGIC);
-       CHECK_OBJ_NOTNULL(sp->http, HTTP_MAGIC);
        CHECK_OBJ_ORNULL(noh, OBJHEAD_MAGIC);
 
        digest = ~0U;
@@ -147,73 +135,39 @@ hcl_lookup(const struct sess *sp, struct objhead *noh)
 
        u1 = digest % hcl_nhash;
        hp = &hcl_head[u1];
-       he2 = NULL;
 
-       for (r = 0; r < 2; r++ ) {
-               Lck_Lock(&hp->mtx);
-               VTAILQ_FOREACH(he, &hp->head, list) {
-                       CHECK_OBJ_NOTNULL(he, HCL_ENTRY_MAGIC);
-                       if (sp->lhashptr < he->oh->hashlen)
-                               continue;
-                       if (sp->lhashptr > he->oh->hashlen)
-                               break;
-                       if (he->digest < digest)
-                               continue;
-                       if (he->digest > digest)
-                               break;
-                       i = HSH_Compare(sp, he->oh);
-                       if (i < 0)
-                               continue;
-                       if (i > 0)
-                               break;
-                       he->oh->refcnt++;
-                       roh = he->oh;
-                       Lck_Unlock(&hp->mtx);
-                       /*
-                        * If we loose the race, we need to clean up
-                        * the work we did for our second attempt.
-                        */
-                       if (he2 != NULL)
-                               free(he2);
-                       if (noh != NULL && noh->hash != NULL) {
-                               free(noh->hash);
-                               noh->hash = NULL;
-                       }
-                       return (roh);
-               }
-               if (noh == NULL) {
-                       Lck_Unlock(&hp->mtx);
-                       return (NULL);
-               }
-               if (he2 != NULL) {
-                       if (he != NULL)
-                               VTAILQ_INSERT_BEFORE(he, he2, list);
-                       else
-                               VTAILQ_INSERT_TAIL(&hp->head, he2, list);
-                       he2->oh->refcnt++;
-                       noh = he2->oh;
-                       Lck_Unlock(&hp->mtx);
-                       return (noh);
-               }
+       Lck_Lock(&hp->mtx);
+       VTAILQ_FOREACH(oh, &hp->head, hoh_list) {
+               if (sp->lhashptr < oh->hashlen)
+                       continue;
+               if (sp->lhashptr > oh->hashlen)
+                       break;
+               if (oh->hoh_digest < digest)
+                       continue;
+               if (oh->hoh_digest > digest)
+                       break;
+               i = HSH_Compare(sp, oh);
+               if (i < 0)
+                       continue;
+               if (i > 0)
+                       break;
+               oh->refcnt++;
                Lck_Unlock(&hp->mtx);
+               return (oh);
+       }
 
-               he2 = calloc(sizeof *he2, 1);
-               XXXAN(he2);
-               he2->magic = HCL_ENTRY_MAGIC;
-               he2->oh = noh;
-               he2->digest = digest;
-               he2->hash = u1;
-               he2->head = hp;
+       if (oh != NULL)
+               VTAILQ_INSERT_BEFORE(oh, noh, hoh_list);
+       else
+               VTAILQ_INSERT_TAIL(&hp->head, noh, hoh_list);
 
-               noh->hashpriv = he2;
-               AZ(noh->hash);
-               noh->hash = malloc(sp->lhashptr);
-               XXXAN(noh->hash);
-               noh->hashlen = sp->lhashptr;
-               HSH_Copy(sp, noh);
-       }
-       assert(he2 == NULL);            /* FlexeLint */
-       INCOMPL();
+       noh->hoh_digest = digest;
+       noh->hoh_head = hp;
+
+       HSH_Copy(sp, noh);
+
+       Lck_Unlock(&hp->mtx);
+       return (noh);
 }
 
 /*--------------------------------------------------------------------
@@ -221,28 +175,22 @@ hcl_lookup(const struct sess *sp, struct objhead *noh)
  */
 
 static int
-hcl_deref(const struct objhead *oh)
+hcl_deref(struct objhead *oh)
 {
-       struct hcl_entry *he;
        struct hcl_hd *hp;
+       int ret;
 
        CHECK_OBJ_NOTNULL(oh, OBJHEAD_MAGIC);
-       CAST_OBJ_NOTNULL(he, oh->hashpriv, HCL_ENTRY_MAGIC);
-       hp = he->head;
-       CHECK_OBJ_NOTNULL(hp, HCL_HEAD_MAGIC);
-       assert(he->oh->refcnt > 0);
-       assert(he->hash < hcl_nhash);
-       assert(hp == &hcl_head[he->hash]);
+       CAST_OBJ_NOTNULL(hp, oh->hoh_head, HCL_HEAD_MAGIC);
+       assert(oh->refcnt > 0);
        Lck_Lock(&hp->mtx);
-       if (--he->oh->refcnt == 0)
-               VTAILQ_REMOVE(&hp->head, he, list);
-       else
-               he = NULL;
+       if (--oh->refcnt == 0) {
+               VTAILQ_REMOVE(&hp->head, oh, hoh_list);
+               ret = 0;
+       } else 
+               ret = 1;
        Lck_Unlock(&hp->mtx);
-       if (he == NULL)
-               return (1);
-       free(he);
-       return (0);
+       return (ret);
 }
 
 /*--------------------------------------------------------------------*/

diff --git a/varnish-cache/bin/varnishd/hash_simple_list.c b/varnish-cache/bin/varnishd/hash_simple_list.c
index a317b76165d1cce76a402ba14fbbc54deaefe783..5cc7475b77d200ea55e48ee499b22d29e6eba509 100644 (file)
--- a/varnish-cache/bin/varnishd/hash_simple_list.c
+++ b/varnish-cache/bin/varnishd/hash_simple_list.c
@@ -33,23 +33,17 @@
 
 #include "config.h"
 
-#include <sys/types.h>
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "shmlog.h"
 #include "cache.h"
+#include "hash_slinger.h"
 
 /*--------------------------------------------------------------------*/
 
-struct hsl_entry {
-       VTAILQ_ENTRY(hsl_entry) list;
-       struct objhead          *oh;
-};
-
-static VTAILQ_HEAD(, hsl_entry)        hsl_head = VTAILQ_HEAD_INITIALIZER(hsl_head);
+static VTAILQ_HEAD(, objhead)  hsl_head = VTAILQ_HEAD_INITIALIZER(hsl_head);
 static struct lock hsl_mtx;
 
 /*--------------------------------------------------------------------
@@ -74,38 +68,28 @@ hsl_start(void)
 static struct objhead *
 hsl_lookup(const struct sess *sp, struct objhead *noh)
 {
-       struct hsl_entry *he, *he2;
+       struct objhead *oh;
        int i;
 
        Lck_Lock(&hsl_mtx);
-       VTAILQ_FOREACH(he, &hsl_head, list) {
-               i = HSH_Compare(sp, he->oh);
+       VTAILQ_FOREACH(oh, &hsl_head, hoh_list) {
+               i = HSH_Compare(sp, oh);
                if (i < 0)
                        continue;
                if (i > 0)
                        break;
-               he->oh->refcnt++;
-               noh = he->oh;
+               oh->refcnt++;
                Lck_Unlock(&hsl_mtx);
-               return (noh);
-       }
-       if (noh != NULL) {
-               he2 = calloc(sizeof *he2, 1);
-               XXXAN(he2);
-               he2->oh = noh;
-               he2->oh->refcnt = 1;
-
-               noh->hashpriv = he2;
-               noh->hash = malloc(sp->lhashptr);
-               XXXAN(noh->hash);
-               noh->hashlen = sp->lhashptr;
-               HSH_Copy(sp, noh);
-
-               if (he != NULL)
-                       VTAILQ_INSERT_BEFORE(he, he2, list);
-               else
-                       VTAILQ_INSERT_TAIL(&hsl_head, he2, list);
+               return (oh);
        }
+
+       if (oh != NULL)
+               VTAILQ_INSERT_BEFORE(oh, noh, hoh_list);
+       else
+               VTAILQ_INSERT_TAIL(&hsl_head, noh, hoh_list);
+
+       HSH_Copy(sp, noh);
+
        Lck_Unlock(&hsl_mtx);
        return (noh);
 }
@@ -115,17 +99,13 @@ hsl_lookup(const struct sess *sp, struct objhead *noh)
  */
 
 static int
-hsl_deref(const struct objhead *oh)
+hsl_deref(struct objhead *oh)
 {
-       struct hsl_entry *he;
        int ret;
 
-       AN(oh->hashpriv);
-       he = oh->hashpriv;
        Lck_Lock(&hsl_mtx);
-       if (--he->oh->refcnt == 0) {
-               VTAILQ_REMOVE(&hsl_head, he, list);
-               free(he);
+       if (--oh->refcnt == 0) {
+               VTAILQ_REMOVE(&hsl_head, oh, hoh_list);
                ret = 0;
        } else
                ret = 1;

diff --git a/varnish-cache/bin/varnishd/hash_slinger.h b/varnish-cache/bin/varnishd/hash_slinger.h
index 1131ae900154a7d872dc49eca011e63cc43d66f4..753788b722ec143f89b72ffca3cea21c62046c67 100644 (file)
--- a/varnish-cache/bin/varnishd/hash_slinger.h
+++ b/varnish-cache/bin/varnishd/hash_slinger.h
@@ -30,12 +30,13 @@
  */
 
 struct sess;
+struct object;
 
 typedef void hash_init_f(int ac, char * const *av);
 typedef void hash_start_f(void);
 typedef struct objhead *
     hash_lookup_f(const struct sess *sp, struct objhead *nobj);
-typedef int hash_deref_f(const struct objhead *obj);
+typedef int hash_deref_f(struct objhead *obj);
 
 struct hash_slinger {
        unsigned                magic;
@@ -46,3 +47,38 @@ struct hash_slinger {
        hash_lookup_f           *lookup;
        hash_deref_f            *deref;
 };
+
+/* cache_hash.c */
+void HSH_Prealloc(struct sess *sp);
+void HSH_Freestore(struct object *o);
+int HSH_Compare(const struct sess *sp, const struct objhead *o);
+void HSH_Copy(const struct sess *sp, struct objhead *o);
+struct object *HSH_Lookup(struct sess *sp);
+void HSH_Unbusy(const struct sess *sp);
+void HSH_Ref(struct object *o);
+void HSH_Deref(struct object *o);
+double HSH_Grace(double g);
+void HSH_Init(void);
+
+
+#ifdef VARNISH_CACHE_CHILD
+struct objhead {
+       unsigned                magic;
+#define OBJHEAD_MAGIC          0x1b96615d
+
+       struct lock             mtx;
+       unsigned                refcnt;
+       VTAILQ_HEAD(,object)    objects;
+       char                    *hash;
+       unsigned                hashlen;
+       VTAILQ_HEAD(, sess)     waitinglist;
+
+       /*------------------------------------------------------------
+        * The fields below are for the sole private use of the hash 
+        * implementation.
+        */
+       VTAILQ_ENTRY(objhead)   hoh_list;
+       void                    *hoh_head;
+       unsigned                hoh_digest;
+};
+#endif /* VARNISH_CACHE_CHILD */

diff --git a/varnish-cache/bin/varnishd/storage_synth.c b/varnish-cache/bin/varnishd/storage_synth.c
index bcef0a3cf1e573cdce0abf6906ad5ea975d8a876..6acd5877bd80658b8628fc8f61e929cd18fb35aa 100644 (file)
--- a/varnish-cache/bin/varnishd/storage_synth.c
+++ b/varnish-cache/bin/varnishd/storage_synth.c
@@ -42,6 +42,7 @@
 #include "cache.h"
 #include "vsb.h"
 #include "stevedore.h"
+#include "hash_slinger.h"
 
 static struct lock             sms_mtx;