GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2011 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * 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.
 *
 * We maintain a number of worker thread pools, to spread lock contention.
 *
 * Pools can be added on the fly, as a means to mitigate lock contention,
 * but can only be removed again by a restart. (XXX: we could fix that)
 *
 */

#include "config.h"

#include <stdlib.h>

#include "cache_varnishd.h"
#include "cache_pool.h"

#include "vtim.h"

static pthread_t                thr_pool_herder;

static struct lock              wstat_mtx;
struct lock                     pool_mtx;
static VTAILQ_HEAD(,pool)       pools = VTAILQ_HEAD_INITIALIZER(pools);

/*--------------------------------------------------------------------
 * Summing of stats into global stats counters
 */

void
Pool_Sumstat(const struct worker *wrk)
{

        Lck_Lock(&wstat_mtx);
        VSC_main_Summ_wrk(VSC_C_main, wrk->stats);
        Lck_Unlock(&wstat_mtx);
        memset(wrk->stats, 0, sizeof *wrk->stats);
}

int
Pool_TrySumstat(const struct worker *wrk)
{
        if (Lck_Trylock(&wstat_mtx))
                return (0);
        VSC_main_Summ_wrk(VSC_C_main, wrk->stats);
        Lck_Unlock(&wstat_mtx);
        memset(wrk->stats, 0, sizeof *wrk->stats);
        return (1);
}

/*--------------------------------------------------------------------
 * Facility for scheduling a task on any convenient pool.
 */

int
Pool_Task_Any(struct pool_task *task, enum task_prio prio)
{
        struct pool *pp;

        Lck_Lock(&pool_mtx);
        pp = VTAILQ_FIRST(&pools);
        if (pp != NULL) {
                VTAILQ_REMOVE(&pools, pp, list);
                VTAILQ_INSERT_TAIL(&pools, pp, list);
        }
        Lck_Unlock(&pool_mtx);
        if (pp == NULL)
                return (-1);
        // NB: When we remove pools, is there a race here ?
        return (Pool_Task(pp, task, prio));
}

/*--------------------------------------------------------------------
 * Helper function to update stats for purges under lock
 */

void
Pool_PurgeStat(unsigned nobj)
{
        Lck_Lock(&wstat_mtx);
        VSC_C_main->n_purges++;
        VSC_C_main->n_obj_purged += nobj;
        Lck_Unlock(&wstat_mtx);
}

/*--------------------------------------------------------------------
 * Special function to summ stats
 */

void v_matchproto_(task_func_t)
pool_stat_summ(struct worker *wrk, void *priv)
{
        struct VSC_main_wrk *src;
        struct pool *pp;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        pp = wrk->pool;
        CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
        AN(priv);
        src = priv;

        Lck_Lock(&wstat_mtx);
        VSC_main_Summ_wrk(VSC_C_main, src);

        Lck_Lock(&pp->mtx);
        VSC_main_Summ_pool(VSC_C_main, pp->stats);
        Lck_Unlock(&pp->mtx);
        memset(pp->stats, 0, sizeof pp->stats);

        Lck_Unlock(&wstat_mtx);
        memset(src, 0, sizeof *src);

        AZ(pp->b_stat);
        pp->b_stat = src;
}

/*--------------------------------------------------------------------
 * Add a thread pool
 */

static struct pool *
pool_mkpool(unsigned pool_no)
{
        struct pool *pp;
        int i;

        ALLOC_OBJ(pp, POOL_MAGIC);
        if (pp == NULL)
                return (NULL);
        pp->a_stat = calloc(1, sizeof *pp->a_stat);
        AN(pp->a_stat);
        pp->b_stat = calloc(1, sizeof *pp->b_stat);
        AN(pp->b_stat);
        Lck_New(&pp->mtx, lck_perpool);

        VTAILQ_INIT(&pp->idle_queue);
        VTAILQ_INIT(&pp->poolsocks);
        for (i = 0; i < TASK_QUEUE_RESERVE; i++)
                VTAILQ_INIT(&pp->queues[i]);
        PTOK(pthread_cond_init(&pp->herder_cond, NULL));
        PTOK(pthread_create(&pp->herder_thr, NULL, pool_herder, pp));

        while (VTAILQ_EMPTY(&pp->idle_queue))
                VTIM_sleep(0.01);

        SES_NewPool(pp, pool_no);
        VCA_NewPool(pp);

        return (pp);
}

/*--------------------------------------------------------------------
 * This thread adjusts the number of pools to match the parameter.
 *
 * NB: This is quite silly.  The master should tell the child through
 * NB: CLI when parameters change and an appropriate call-out table
 * NB: be maintained for params which require action.
 */

static void * v_matchproto_()
pool_poolherder(void *priv)
{
        unsigned nwq;
        struct pool *pp, *ppx;
        uint64_t u;
        void *rvp;

        THR_SetName("pool_poolherder");
        THR_Init();
        (void)priv;

        nwq = 0;
        while (1) {
                if (nwq < cache_param->wthread_pools) {
                        pp = pool_mkpool(nwq);
                        if (pp != NULL) {
                                Lck_Lock(&pool_mtx);
                                VTAILQ_INSERT_TAIL(&pools, pp, list);
                                Lck_Unlock(&pool_mtx);
                                VSC_C_main->pools++;
                                nwq++;
                                continue;
                        }
                } else if (nwq > cache_param->wthread_pools &&
                                EXPERIMENT(EXPERIMENT_DROP_POOLS)) {
                        Lck_Lock(&pool_mtx);
                        pp = VTAILQ_FIRST(&pools);
                        CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
                        VTAILQ_REMOVE(&pools, pp, list);
                        VTAILQ_INSERT_TAIL(&pools, pp, list);
                        if (!pp->die)
                                nwq--;
                        Lck_Unlock(&pool_mtx);
                        if (!pp->die) {
                                VSL(SLT_Debug, NO_VXID, "XXX Kill Pool %p", pp);
                                pp->die = 1;
                                VCA_DestroyPool(pp);
                                PTOK(pthread_cond_signal(&pp->herder_cond));
                        }
                }
                (void)sleep(1);
                u = 0;
                ppx = NULL;
                Lck_Lock(&pool_mtx);
                VTAILQ_FOREACH(pp, &pools, list) {
                        CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);

                        if (pp->die && pp->nthr == 0)
                                ppx = pp;
                        u += pp->lqueue;
                }
                if (ppx != NULL) {
                        VTAILQ_REMOVE(&pools, ppx, list);
                        PTOK(pthread_join(ppx->herder_thr, &rvp));
                        PTOK(pthread_cond_destroy(&ppx->herder_cond));
                        free(ppx->a_stat);
                        free(ppx->b_stat);
                        SES_DestroyPool(ppx);
                        Lck_Delete(&ppx->mtx);
                        FREE_OBJ(ppx);
                        VSC_C_main->pools--;
                }
                Lck_Unlock(&pool_mtx);
                VSC_C_main->thread_queue_len = u;
        }
        NEEDLESS(return (NULL));
}

/*--------------------------------------------------------------------*/
void
pan_pool(struct vsb *vsb)
{
        struct pool *pp;

        VSB_cat(vsb, "pools = {\n");
        VSB_indent(vsb, 2);
        VTAILQ_FOREACH(pp, &pools, list) {
                if (PAN_dump_struct(vsb, pp, POOL_MAGIC, "pool"))
                        continue;
                VSB_printf(vsb, "nidle = %u,\n", pp->nidle);
                VSB_printf(vsb, "nthr = %u,\n", pp->nthr);
                VSB_printf(vsb, "lqueue = %u\n", pp->lqueue);
                VSB_indent(vsb, -2);
                VSB_cat(vsb, "},\n");
        }
        VSB_indent(vsb, -2);
        VSB_cat(vsb, "},\n");
}

/*--------------------------------------------------------------------*/

void
Pool_Init(void)
{

        Lck_New(&wstat_mtx, lck_wstat);
        Lck_New(&pool_mtx, lck_wq);
        PTOK(pthread_create(&thr_pool_herder, NULL, pool_poolherder, NULL));
        while (!VSC_C_main->pools)
                VTIM_sleep(0.01);
}

		varnish-cache/bin/varnishd/cache/cache_pool.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2011 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*
30		* We maintain a number of worker thread pools, to spread lock contention.
31		*
32		* Pools can be added on the fly, as a means to mitigate lock contention,
33		* but can only be removed again by a restart. (XXX: we could fix that)
34		*
35		*/
36
37		#include "config.h"
38
39		#include <stdlib.h>
40
41		#include "cache_varnishd.h"
42		#include "cache_pool.h"
43
44		#include "vtim.h"
45
46		static pthread_t thr_pool_herder;
47
48		static struct lock wstat_mtx;
49		struct lock pool_mtx;
50		static VTAILQ_HEAD(,pool) pools = VTAILQ_HEAD_INITIALIZER(pools);
51
52		/*--------------------------------------------------------------------
53		* Summing of stats into global stats counters
54		*/
55
56		void
57	227737	Pool_Sumstat(const struct worker *wrk)
58		{
59
60	227737	Lck_Lock(&wstat_mtx);
61	227737	VSC_main_Summ_wrk(VSC_C_main, wrk->stats);
62	227737	Lck_Unlock(&wstat_mtx);
63	227737	memset(wrk->stats, 0, sizeof *wrk->stats);
64	227737	}
65
66		int
67	0	Pool_TrySumstat(const struct worker *wrk)
68		{
69	0	if (Lck_Trylock(&wstat_mtx))
70	0	return (0);
71	0	VSC_main_Summ_wrk(VSC_C_main, wrk->stats);
72	0	Lck_Unlock(&wstat_mtx);
73	0	memset(wrk->stats, 0, sizeof *wrk->stats);
74	0	return (1);
75	0	}
76
77		/*--------------------------------------------------------------------
78		* Facility for scheduling a task on any convenient pool.
79		*/
80
81		int
82	7973	Pool_Task_Any(struct pool_task *task, enum task_prio prio)
83		{
84		struct pool *pp;
85
86	7973	Lck_Lock(&pool_mtx);
87	7973	pp = VTAILQ_FIRST(&pools);
88	7973	if (pp != NULL) {
89	7973	VTAILQ_REMOVE(&pools, pp, list);
90	7973	VTAILQ_INSERT_TAIL(&pools, pp, list);
91	7973	}
92	7973	Lck_Unlock(&pool_mtx);
93	7973	if (pp == NULL)
94	0	return (-1);
95		// NB: When we remove pools, is there a race here ?
96	7973	return (Pool_Task(pp, task, prio));
97	7973	}
98
99		/*--------------------------------------------------------------------
100		* Helper function to update stats for purges under lock
101		*/
102
103		void
104	560	Pool_PurgeStat(unsigned nobj)
105		{
106	560	Lck_Lock(&wstat_mtx);
107	560	VSC_C_main->n_purges++;
108	560	VSC_C_main->n_obj_purged += nobj;
109	560	Lck_Unlock(&wstat_mtx);
110	560	}
111
112		/*--------------------------------------------------------------------
113		* Special function to summ stats
114		*/
115
116		void v_matchproto_(task_func_t)
117	203269	pool_stat_summ(struct worker wrk, void priv)
118		{
119		struct VSC_main_wrk *src;
120		struct pool *pp;
121
122	203269	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
123	203269	pp = wrk->pool;
124	203269	CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
125	203269	AN(priv);
126	203269	src = priv;
127
128	203269	Lck_Lock(&wstat_mtx);
129	203269	VSC_main_Summ_wrk(VSC_C_main, src);
130
131	203269	Lck_Lock(&pp->mtx);
132	203269	VSC_main_Summ_pool(VSC_C_main, pp->stats);
133	203269	Lck_Unlock(&pp->mtx);
134	203269	memset(pp->stats, 0, sizeof pp->stats);
135
136	203269	Lck_Unlock(&wstat_mtx);
137	203269	memset(src, 0, sizeof *src);
138
139	203269	AZ(pp->b_stat);
140	203269	pp->b_stat = src;
141	203269	}
142
143		/*--------------------------------------------------------------------
144		* Add a thread pool
145		*/
146
147		static struct pool *
148	75189	pool_mkpool(unsigned pool_no)
149		{
150		struct pool *pp;
151		int i;
152
153	75189	ALLOC_OBJ(pp, POOL_MAGIC);
154	75187	if (pp == NULL)
155	0	return (NULL);
156	75187	pp->a_stat = calloc(1, sizeof *pp->a_stat);
157	75187	AN(pp->a_stat);
158	75187	pp->b_stat = calloc(1, sizeof *pp->b_stat);
159	75187	AN(pp->b_stat);
160	75187	Lck_New(&pp->mtx, lck_perpool);
161
162	75187	VTAILQ_INIT(&pp->idle_queue);
163	75187	VTAILQ_INIT(&pp->poolsocks);
164	451127	for (i = 0; i < TASK_QUEUE_RESERVE; i++)
165	375940	VTAILQ_INIT(&pp->queues[i]);
166	75187	PTOK(pthread_cond_init(&pp->herder_cond, NULL));
167	75187	PTOK(pthread_create(&pp->herder_thr, NULL, pool_herder, pp));
168
169	150375	while (VTAILQ_EMPTY(&pp->idle_queue))
170	75188	VTIM_sleep(0.01);
171
172	75187	SES_NewPool(pp, pool_no);
173	75187	VCA_NewPool(pp);
174
175	75187	return (pp);
176	75187	}
177
178		/*--------------------------------------------------------------------
179		* This thread adjusts the number of pools to match the parameter.
180		*
181		* NB: This is quite silly. The master should tell the child through
182		* NB: CLI when parameters change and an appropriate call-out table
183		* NB: be maintained for params which require action.
184		*/
185
186		static void * v_matchproto_()
187	0	pool_poolherder(void *priv)
188		{
189		unsigned nwq;
190		struct pool pp, ppx;
191		uint64_t u;
192		void *rvp;
193
194	0	THR_SetName("pool_poolherder");
195	0	THR_Init();
196	0	(void)priv;
197
198	0	nwq = 0;
199	101137	while (1) {
200	176324	if (nwq < cache_param->wthread_pools) {
201	75187	pp = pool_mkpool(nwq);
202	75187	if (pp != NULL) {
203	75187	Lck_Lock(&pool_mtx);
204	75187	VTAILQ_INSERT_TAIL(&pools, pp, list);
205	75187	Lck_Unlock(&pool_mtx);
206	75187	VSC_C_main->pools++;
207	75187	nwq++;
208	75187	continue;
209		}
210	101137	} else if (nwq > cache_param->wthread_pools &&
211	80	EXPERIMENT(EXPERIMENT_DROP_POOLS)) {
212	80	Lck_Lock(&pool_mtx);
213	80	pp = VTAILQ_FIRST(&pools);
214	80	CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
215	80	VTAILQ_REMOVE(&pools, pp, list);
216	80	VTAILQ_INSERT_TAIL(&pools, pp, list);
217	80	if (!pp->die)
218	80	nwq--;
219	80	Lck_Unlock(&pool_mtx);
220	80	if (!pp->die) {
221	80	VSL(SLT_Debug, NO_VXID, "XXX Kill Pool %p", pp);
222	80	pp->die = 1;
223	80	VCA_DestroyPool(pp);
224	80	PTOK(pthread_cond_signal(&pp->herder_cond));
225	80	}
226	80	}
227	101137	(void)sleep(1);
228	101137	u = 0;
229	101137	ppx = NULL;
230	101137	Lck_Lock(&pool_mtx);
231	223725	VTAILQ_FOREACH(pp, &pools, list) {
232	122588	CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
233
234	122588	if (pp->die && pp->nthr == 0)
235	80	ppx = pp;
236	122588	u += pp->lqueue;
237	122588	}
238	101137	if (ppx != NULL) {
239	80	VTAILQ_REMOVE(&pools, ppx, list);
240	80	PTOK(pthread_join(ppx->herder_thr, &rvp));
241	80	PTOK(pthread_cond_destroy(&ppx->herder_cond));
242	80	free(ppx->a_stat);
243	80	free(ppx->b_stat);
244	80	SES_DestroyPool(ppx);
245	80	Lck_Delete(&ppx->mtx);
246	80	FREE_OBJ(ppx);
247	80	VSC_C_main->pools--;
248	80	}
249	101137	Lck_Unlock(&pool_mtx);
250	101137	VSC_C_main->thread_queue_len = u;
251		}
252		NEEDLESS(return (NULL));
253		}
254
255		/--------------------------------------------------------------------/
256		void
257	514	pan_pool(struct vsb *vsb)
258		{
259		struct pool *pp;
260
261	514	VSB_cat(vsb, "pools = {\n");
262	514	VSB_indent(vsb, 2);
263	1541	VTAILQ_FOREACH(pp, &pools, list) {
264	1027	if (PAN_dump_struct(vsb, pp, POOL_MAGIC, "pool"))
265	0	continue;
266	1027	VSB_printf(vsb, "nidle = %u,\n", pp->nidle);
267	1027	VSB_printf(vsb, "nthr = %u,\n", pp->nthr);
268	1027	VSB_printf(vsb, "lqueue = %u\n", pp->lqueue);
269	1027	VSB_indent(vsb, -2);
270	1027	VSB_cat(vsb, "},\n");
271	1027	}
272	514	VSB_indent(vsb, -2);
273	514	VSB_cat(vsb, "},\n");
274	514	}
275
276		/--------------------------------------------------------------------/
277
278		void
279	38034	Pool_Init(void)
280		{
281
282	38034	Lck_New(&wstat_mtx, lck_wstat);
283	38034	Lck_New(&pool_mtx, lck_wq);
284	38034	PTOK(pthread_create(&thr_pool_herder, NULL, pool_poolherder, NULL));
285	114102	while (!VSC_C_main->pools)
286	76068	VTIM_sleep(0.01);
287	38034	}