vdp / tree segregation (to some extend, more could be done)

src/Makefile.am

@@ -8,11 +8,11 @@ AM_LDFLAGS = $(VARNISHAPI_LIBS) $(VMOD_LDFLAGS) -ldl
 vmod_LTLIBRARIES = libvmod_pesi.la
 
 libvmod_pesi_la_SOURCES = \
+	misc.c \
+	pesi.c \
+	node.c \
 	vmod_pesi.c \
 	vdp_pesi.c \
-	tbl_set_parameter.h \
-	foreign/qdef.h \
-	foreign/from_cache_esi_deliver.h \
 	foreign/from_cache_esi_deliver.c
 
 nodist_libvmod_pesi_la_SOURCES = \

src/debug.h

+#ifdef DEBUG
+#include <stdio.h>
+#define Debug(fmt, ...) printf(fmt, __VA_ARGS__)
+#define VSLdbgv(req, fmt, ...)						\
+	do {								\
+		VSL(SLT_Debug, 0, "xid=%u t=%.6f " fmt,			\
+		    VXID(req->vsl->wid), VTIM_real(), __VA_ARGS__);	\
+		VSLb(req->vsl, SLT_Debug, fmt, __VA_ARGS__);		\
+	} while(0)
+
+#define VSLdbg(req, msg)				\
+	do {						\
+		VSL(SLT_Debug, 0, "xid=%u t=%.6f " msg,	\
+		    VXID(req->vsl->wid), VTIM_real());	\
+		VSLb(req->vsl, SLT_Debug, msg);		\
+	} while(0)
+#define VSL0dbg(...) VSL(SLT_Debug, 0, __VA_ARGS__)
+#else
+#define VSLdbgv(req, fmt, ...)	(void)0
+#define VSLdbg(req, msg)	(void)0
+#define VSL0dbg(...)	(void)0
+#define Debug(fmt, ...) /**/
+#endif

src/misc.c

+/*-
+ * Copyright 2019 UPLEX Nils Goroll Systemoptimierung
+ * All rights reserved
+ *
+ * Authors: Geoffrey Simmons <geoffrey.simmons@uplex.de>
+ *	    Nils Goroll <nils.goroll@uplex.de>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * utility function(s) used by node.c and vdp_pesi.c
+ */
+
+#include "config.h"
+
+#include "cache/cache_varnishd.h"
+
+#include "misc.h"
+#include "debug.h"
+
+void
+req_fini(struct req **reqp, struct worker *wrk)
+{
+	struct req *req;
+
+	AN(reqp);
+	if (*reqp == NULL)
+		return;
+
+	TAKE_OBJ_NOTNULL(req, reqp, REQ_MAGIC);
+
+	VSLdbg(req, "req_fini called");
+
+	VDP_close(req);
+	Req_Cleanup(req->sp, wrk, req);
+	Req_Release(req);
+}

src/misc.h

+#define OC_F_FINAL (OC_F_PRIVATE | OC_F_HFM | OC_F_HFP)
+
+void req_fini(struct req **, struct worker *);

src/node.h

@@ -27,10 +27,24 @@
  * SUCH DAMAGE.
  *
  * node interface
- *
- * XXX mempool vs. struct node
  */
 
+struct node;
+
+struct bytes_tree {
+	unsigned		magic;
+#define BYTES_TREE_MAGIC 0x49c59d46
+	struct lock		tree_lock;
+	// esi_level > 1 signalling new data
+	pthread_cond_t		cond;
+	struct node		*root;
+	struct node		*front;
+	const struct worker	*front_owner;
+	const struct worker	*unpend_owner;
+	int			npending;
+	int			retval;
+};
+
 enum n_type {
 	T_INVALID = 0,
 	T_NEXUS,	// can change into T_SUBREQ / T_FINAL / T_DATA
@@ -170,3 +184,76 @@ struct node {
 	};
 };
 
+/*
+ * node mutation: turn an existing nexus into something else
+ *
+ * howto:
+ *
+ * 0) node must be T_NEXUS / ST_PRIVATE, untouched
+ *
+ * 1) call node_mutate_prep()
+ *
+ * 2) modify data in the destination-type specific struct
+ *
+ * 3) call node_mutate_lock() with destination type/state
+ *
+ * 4) optionally do more things under the lock
+ *
+ * 5) call node_mutate_unlock()
+ *
+ */
+
+static inline void
+node_mutate_prep(struct bytes_tree *tree, struct node *node)
+{
+	CHECK_OBJ_NOTNULL(node, NODE_MAGIC);
+	CHECK_OBJ_NOTNULL(node->parent, NODE_MAGIC);
+
+	assert(node->state == ST_PRIVATE);
+	assert(node->type == T_NEXUS);
+	assert(node != tree->root);
+
+	AZ(node->nexus.npending_private);
+	AZ(node->nexus.oc);
+
+	memset(&node->nexus, 0, sizeof node->nexus);
+}
+
+static inline void
+node_mutate_lock(struct bytes_tree *tree, struct node *node,
+		 enum n_type type, enum n_state state)
+{
+	/* these checks can be relexed when needed */
+	assert(type == T_DATA ||
+	       type == T_SUBREQ ||
+	       type == T_FINAL);
+	assert(state == ST_DATA);
+
+	Lck_Lock(&tree->tree_lock);
+	node->type = type;
+	node->state = state;
+	if (node->parent->state != ST_PRIVATE)
+		AZ(pthread_cond_signal(&tree->cond));
+}
+
+static inline void
+node_mutate_unlock(struct bytes_tree *tree)
+{
+	Lck_Unlock(&tree->tree_lock);
+}
+
+//--------------
+
+struct node *node_alloc(void);
+void node_insert(struct bytes_tree *, struct node *, struct node *);
+void set_open(struct bytes_tree *, struct node *, const struct worker *);
+void set_closed(struct bytes_tree *, struct node *, const struct worker *);
+
+//--------------
+
+void tree_fini(struct req *, struct node *);
+void tree_free(struct req *, struct node *);
+
+//--------------
+
+void bytes_unpend(struct req *, struct bytes_tree *);

src/node_assert.h

+/*-
+ * Copyright 2019 UPLEX Nils Goroll Systemoptimierung
+ * All rights reserved
+ *
+ * Authors: Geoffrey Simmons <geoffrey.simmons@uplex.de>
+ *	    Nils Goroll <nils.goroll@uplex.de>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * tree integrity check
+ *
+ * CHK_ORDER: within child list can only transition from ST_DELIVERED -> !
+ * ST_DELIVERED iow, once a child is found pending, all others must be also
+ */
+
+enum check_state {
+	CHK_ANY = 0,
+	CHK_PEND,	// ! ST_DELIVERED && ! ST_UNPENDING
+	CHK_DELI,	// ST_DELIVERED
+	CHK_ORDER
+};
+
+/*
+ * keep in prod builds for now to gain trust in tree sanity
+ *
+ * XXX enable only for DEBUG later?
+ */
+#ifdef NO_ASSERT_NODE
+#define assert_node(n, c) (void)0
+#define assert_nexus(n, c) (void)0
+#else
+static inline void assert_node(struct node *node, enum check_state check);
+
+static inline void
+assert_nexus(struct node *node, enum check_state check)
+{
+	struct node *child;
+
+	CHECK_OBJ_NOTNULL(node, NODE_MAGIC);
+	assert(node->type == T_NEXUS);
+
+	VSTAILQ_FOREACH(child, &node->nexus.children, sibling) {
+		assert_node(child, check);
+		if (check == CHK_ORDER &&
+		    child->state != ST_DELIVERED &&
+		    child->state != ST_UNPENDING)
+			check = CHK_PEND;
+	}
+}
+
+static inline void
+assert_node(struct node *node, enum check_state check)
+{
+	CHECK_OBJ_NOTNULL(node, NODE_MAGIC);
+
+	switch (check) {
+	case CHK_ANY:
+	case CHK_ORDER:
+		break;
+	case CHK_PEND:
+		assert(node->state != ST_DELIVERED &&
+		       node->state != ST_UNPENDING);
+		break;
+	case CHK_DELI:
+		assert(node->state == ST_DELIVERED);
+		break;
+	default:
+		INCOMPL();
+	}
+
+	switch (node->state) {
+	case ST_PRIVATE:
+		assert(node->type == T_NEXUS);
+		/* hands off all nexus fields */
+		break;
+	case ST_DATA:
+	case ST_UNPENDING:
+		assert(node->type != T_NEXUS);
+		break;
+	case ST_OPEN:
+		AN(node->nexus.owner);
+		AZ(node->nexus.npending_private);
+		assert_nexus(node, CHK_ORDER);
+		break;
+	case ST_CLOSED:
+		AZ(node->nexus.owner);
+		AZ(node->nexus.npending_private);
+		assert_nexus(node, CHK_ORDER);
+		break;
+	case ST_DELIVERED:
+		if (node->type == T_NEXUS) {
+			assert_nexus(node, CHK_DELI);
+			AZ(node->nexus.oc);
+		} else if (node->type == T_DATA) {
+			AZ(node->data.st);
+		}
+		break;
+	default:
+		INCOMPL();
+	}
+}
+#endif

src/node_mempool.h

+extern struct mempool *mempool;
+size_t node_size();

src/pesi.c

+/*-
+ * Copyright 2019 UPLEX Nils Goroll Systemoptimierung
+ * All rights reserved
+ *
+ * Authors: Geoffrey Simmons <geoffrey.simmons@uplex.de>
+ *	    Nils Goroll <nils.goroll@uplex.de>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * PESI per request state and task management
+ */
+
+/* for SSIZE_MAX */
+#define _POSIX_C_SOURCE 200809L
+
+#include "config.h"
+
+#include <string.h>
+
+#include "cache/cache.h"
+
+#include "debug.h"
+
+#include "pesi_tree.h"
+#include "pesi_flags.h"
+#include "pesi.h"
+
+/* ------------------------------------------------------------
+ * pesi tasks
+ *
+ * in the top request, we need to wait for all pesis to finish because, via
+ * req->topreq and req->sp, they all reference the top request
+ *
+ * for this purpose, simple refcounting would suffice, but putting all the pesis
+ * on a list does not add any relevant amount of complexity and might help with
+ * troubleshooting and through additional assertions
+ *
+ * pesi_new always happens in a task but the destruction can happen in any
+ * order:
+ * - for T_SUBREQ, pesi outlives the task
+ * - otherwise, pesi gets destroyed before the task
+ */
+struct pesi *
+pesi_new(struct ws *ws, struct pesi_tree *pesi_tree)
+{
+	struct pesi *pesi;
+
+	pesi = WS_Alloc(ws, sizeof *pesi);
+	if (pesi == NULL)
+		return (NULL);
+
+	INIT_OBJ(pesi, PESI_MAGIC);
+	pesi->pecx->magic = PECX_MAGIC;
+	pesi->pesi_tree = pesi_tree;
+	pesi->flags = PF_HAS_TASK | PF_CFG_DEFAULT;
+
+	Lck_Lock(&pesi_tree->task_lock);
+	VTAILQ_INSERT_TAIL(&pesi_tree->task_head, pesi, list);
+	assert(pesi_tree->task_running >= 0);
+	pesi_tree->task_running++;
+	Lck_Unlock(&pesi_tree->task_lock);
+	return (pesi);
+}
+
+/*
+ * shutting down a pesi request is a two stage process, because Req_Cleanup() in
+ * req_fini() called from vped_task() zeroes the workspace including our
+ * per-request struct pesi, so removing the registration from
+ * pesi_tree->task_head need to happen before Req_Cleanup().
+ *
+ * But notification of the topreq needs to happen after Req_Cleanup(), because
+ * it still references topreq and sp, thus the topreq may not finish until all
+ * pesi tasks have finished.
+ *
+ * on the implementation:
+ *
+ * - in vdp_pesi_fini() we call pesi_destroy() to clean up the per-request
+ *   struct pesi and remove it from the global list.
+ *
+ *   For possible debuggung purposes, we record the fact that a pesi request is
+ *   finishing
+ *
+ * - in vped_task(), we call task_fini() to decrement the global counter and
+ *   notify the top request
+ *
+ * for esi_level == 0, all cleanup happens in vdp_pesi_fini
+ */
+
+void
+pesi_destroy(struct pesi **pesip)
+{
+	struct pesi *pesi;
+	struct pesi_tree *pesi_tree;
+
+	TAKE_OBJ_NOTNULL(pesi, pesip, PESI_MAGIC);
+	CHECK_OBJ_NOTNULL(pesi->pecx, PECX_MAGIC);
+	TAKE_OBJ_NOTNULL(pesi_tree, &pesi->pesi_tree, PESI_TREE_MAGIC);
+
+	Lck_Lock(&pesi_tree->task_lock);
+	VTAILQ_REMOVE(&pesi_tree->task_head, pesi, list);
+
+	assert(pesi_tree->task_running >= 0);
+
+	if (pesi->flags & PF_HAS_TASK)
+		pesi_tree->task_finishing++;
+	Lck_Unlock(&pesi_tree->task_lock);
+
+	memset(pesi, 0, sizeof *pesi);
+}
+
+
+void
+task_fini(struct pesi_tree *pesi_tree, struct pesi *pesi)
+{
+	Lck_Lock(&pesi_tree->task_lock);
+	assert(pesi_tree->task_running > 0);
+	if (pesi == NULL) {
+		assert(pesi_tree->task_finishing > 0);
+		pesi_tree->task_finishing--;
+	}
+	else {
+		AN(pesi->flags & PF_HAS_TASK);
+		pesi->flags &= ~PF_HAS_TASK;
+	}
+	pesi_tree->task_running--;
+	if (pesi_tree->task_running == 0) {
+		AZ(pesi_tree->task_finishing);
+		AZ(pthread_cond_signal(&pesi_tree->task_cond));
+	}
+	Lck_Unlock(&pesi_tree->task_lock);
+}

src/pesi.h

+/*-
+ * Copyright 2019 UPLEX Nils Goroll Systemoptimierung
+ * All rights reserved
+ *
+ * Authors: Geoffrey Simmons <geoffrey.simmons@uplex.de>
+ *	    Nils Goroll <nils.goroll@uplex.de>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * PESI per request state
+ */
+
+struct pesi_tree;
+
+struct pesi * pesi_new(struct ws *ws, struct pesi_tree *pesi_tree);
+void pesi_destroy(struct pesi **pesip);
+void task_fini(struct pesi_tree *pesi_tree, struct pesi *pesi);
+
+/*
+ * per request state
+ *
+ * pecx: ESI parser
+ * pesi: any request
+ *
+ */
+struct pecx {
+	unsigned		magic;
+#define PECX_MAGIC		0x5d8cd06d
+	const uint8_t		*p;
+	const uint8_t		*e;
+
+	ssize_t			l;
+	int			state;
+};
+
+struct pesi {
+	unsigned		magic;
+#define PESI_MAGIC 0xa6ba54a0
+	unsigned		flags;
+
+	struct pesi_tree	*pesi_tree;
+	struct worker		*wrk;
+	struct node		*node;
+	int			woken;
+
+	struct pecx		pecx[1];
+	VTAILQ_ENTRY(pesi)	list;
+
+	unsigned		no_thread;
+};

src/pesi_flags.h

+extern int block_final, front_push;
+
+#define PF_HAS_TASK		1U
+/* vcl-controlled flags */
+#define PF_CFG_SERIAL		(1U<<1)
+#define PF_CFG_THREAD		(1U<<2)
+/* undocumented for now */
+#define PF_CFG_BLOCK_FINAL	(1U<<3)
+#define PF_CFG_FRONT_PUSH	(1U<<4)
+
+#define PF_CFG_DEFAULT					\
+	( PF_CFG_THREAD				\
+	| (block_final ? PF_CFG_BLOCK_FINAL : 0)	\
+	| (front_push ? PF_CFG_FRONT_PUSH : 0)		\
+	)
+
+#define PF_MASK_CFG		\
+	( PF_CFG_SERIAL	\
+	| PF_CFG_THREAD	\
+	| PF_CFG_BLOCK_FINAL	\
+	| PF_CFG_FRONT_PUSH	\
+	)

src/pesi_tree.h

+/*-
+ * Copyright 2019 UPLEX Nils Goroll Systemoptimierung
+ * All rights reserved
+ *
+ * Authors: Geoffrey Simmons <geoffrey.simmons@uplex.de>
+ *	    Nils Goroll <nils.goroll@uplex.de>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * pesi_tree is a global context for the entire ESI tree started at level 0.
+ *
+ * XXX merge pesi_tree with bytes_tree ?
+ */
+
+struct pesi_tree {
+	unsigned		magic;
+#define PESI_TREE_MAGIC 0xe8ce8adb
+	struct bytes_tree	*tree;
+
+	/* all pesis (struct pesi) we started */
+	struct lock		task_lock;
+	pthread_cond_t		task_cond;
+	VTAILQ_HEAD(,pesi)	task_head;
+	int			task_running;
+	int			task_finishing;
+};

src/vdp_pesi.h

@@ -29,41 +29,13 @@
  * interfaces shared between vdp_pesi.c and vmod_pesi.c
  */
 
-#define VFAIL(ctx, fmt, ...)					\
-	VRT_fail((ctx), "vdp pesi failure: " fmt, __VA_ARGS__)
-
 extern struct lock stats_lock;
 extern struct VSC_pesi *stats;
 extern struct VSC_lck *lck_bytes_tree, *lck_pesi_tree;
 extern const struct vdp VDP_pesi;
-extern struct mempool *mempool;
-size_t node_size();
-
 
 /* ------------------------------------------------------------
  * task config
  */
-#define PF_HAS_TASK		1U
-/* vcl-controlled flags */
-#define PF_CFG_SERIAL		(1U<<1)
-#define PF_CFG_THREAD		(1U<<2)
-/* undocumented for now */
-#define PF_CFG_BLOCK_FINAL	(1U<<3)
-#define PF_CFG_FRONT_PUSH	(1U<<4)
-
-#define PF_CFG_DEFAULT					\
-	( PF_CFG_THREAD				\
-	| (block_final ? PF_CFG_BLOCK_FINAL : 0)	\
-	| (front_push ? PF_CFG_FRONT_PUSH : 0)		\
-	)
-
-#define PF_MASK_CFG		\
-	( PF_CFG_SERIAL	\
-	| PF_CFG_THREAD	\
-	| PF_CFG_BLOCK_FINAL	\
-	| PF_CFG_FRONT_PUSH	\
-	)
 
 void get_task_cfg(struct req *, unsigned *);
-
-extern int block_final, front_push; // XXX

src/vmod_pesi.c

@@ -29,20 +29,22 @@
 
 #include "config.h"
 
-#include <stdlib.h>
-#include <string.h>
 #include "cache/cache_varnishd.h"
-//#include <cache/cache.h>
 #include <vcl.h>
-#include "vtim.h"
+#include <vtim.h>
 
 #include "vcc_if.h"
 #include "VSC_pesi.h"
 
+#include "node_mempool.h"
+#include "pesi_flags.h"
 #include "vdp_pesi.h"
 
 #include "cache/cache_filter.h"
 
+#define VFAIL(ctx, fmt, ...)					\
+	VRT_fail((ctx), "vdp pesi failure: " fmt, __VA_ARGS__)
+
 /* VMOD shared object globals */
 static unsigned loadcnt = 0, warmcnt = 0;
 static struct vsc_seg  *vsc_seg = NULL, *pesi_vsc_seg = NULL;
@@ -54,7 +56,6 @@ static unsigned node_alloc_sz;
 /* id for PRIV_TASK */
 const void * const priv_task_id_cfg = &priv_task_id_cfg;
 
-
 /* ------------------------------------------------------------
  * mempool
  */