Code Coverage: vinyl-cache/bin/vinyld/cache/cache_mempool.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2011 Varnish Software AS
2
 * All rights reserved.
3
 *
4
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
5
 *
6
 * SPDX-License-Identifier: BSD-2-Clause
7
 *
8
 * Redistribution and use in source and binary forms, with or without
9
 * modification, are permitted provided that the following conditions
10
 * are met:
11
 * 1. Redistributions of source code must retain the above copyright
12
 *    notice, this list of conditions and the following disclaimer.
13
 * 2. Redistributions in binary form must reproduce the above copyright
14
 *    notice, this list of conditions and the following disclaimer in the
15
 *    documentation and/or other materials provided with the distribution.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 *
29
 * Generic memory pool
30
 */
31
32
#include "config.h"
33
34
#include "cache_int.h"
35
36
#include <stdio.h>
37
#include <stdlib.h>
38
39
#include "vtim.h"
40
41
#include "VSC_mempool.h"
42
43
struct memitem {
44
        unsigned                        magic;
45 51609
#define MEMITEM_MAGIC                   0x42e55401
46
        unsigned                        size;
47
        VTAILQ_ENTRY(memitem)           list;
48
        vtim_real                       touched;        // XXX -> mono?
49
};
50
51
VTAILQ_HEAD(memhead_s, memitem);
52
53
struct mempool {
54
        unsigned                        magic;
55
#define MEMPOOL_MAGIC                   0x37a75a8d
56
        char                            name[12];
57
        struct memhead_s                list;
58
        struct memhead_s                surplus;
59
        struct lock                     mtx;
60
        volatile struct poolparam       *param;
61
        volatile unsigned               *cur_size;
62
        uint64_t                        live;
63
        struct vsc_seg                  *vsc_seg;
64
        struct VSC_mempool              *vsc;
65
        unsigned                        n_pool;
66
        pthread_t                       thread;
67
        vtim_real                       t_now;  // XXX -> mono?
68
        int                             self_destruct;
69
};
70
71
/*---------------------------------------------------------------------
72
 */
73
74
static struct memitem *
75
mpl_alloc(const struct mempool *mpl)
76 51609
{
77 51609
        unsigned tsz;
78 51609
        struct memitem *mi;
79
80 51609
        CHECK_OBJ_NOTNULL(mpl, MEMPOOL_MAGIC);
81 51609
        tsz = *mpl->cur_size;
82 51609
        mi = calloc(1, tsz);
83 51609
        AN(mi);
84 51609
        mi->magic = MEMITEM_MAGIC;
85 51609
        mi->size = tsz;
86 51609
        mpl->vsc->sz_wanted = tsz;
87 51609
        mpl->vsc->sz_actual = tsz - sizeof *mi;
88 51609
        return (mi);
89 51609
}
90
91
/*---------------------------------------------------------------------
92
 * Pool-guard
93
 *   Attempt to keep number of free items in pool inside bounds with
94
 *   minimum locking activity, and keep an eye on items at the tail
95
 *   of the list not getting too old.
96
 */
97
98
static void *
99
mpl_guard(void *priv)
100 5102
{
101 5102
        struct mempool *mpl;
102 5102
        struct memitem *mi = NULL;
103 5102
        vtim_dur v_statevariable_(mpl_slp);
104 5102
        vtim_real last = 0;
105
106 5102
        CAST_OBJ_NOTNULL(mpl, priv, MEMPOOL_MAGIC);
107 5102
        THR_SetName(mpl->name);
108 5102
        THR_Init();
109 5102
        mpl_slp = 0.15; // random
110 79232
        while (1) {
111 74158
                VTIM_sleep(mpl_slp);
112 74158
                mpl_slp = 0.814;        // random
113 74158
                mpl->t_now = VTIM_real();
114
115 74158
                if (mi != NULL && (mpl->n_pool > mpl->param->max_pool ||
116 0
                    mi->size < *mpl->cur_size)) {
117 0
                        CHECK_OBJ(mi, MEMITEM_MAGIC);
118 0
                        FREE_OBJ(mi);
119 0
                }
120
121 74158
                if (mi == NULL && mpl->n_pool < mpl->param->min_pool)
122 51571
                        mi = mpl_alloc(mpl);
123
124 74158
                if (mpl->n_pool < mpl->param->min_pool && mi != NULL) {
125
                        /* can do */
126 51746
                } else if (mpl->n_pool > mpl->param->max_pool && mi == NULL) {
127
                        /* can do */
128 22388
                } else if (!VTAILQ_EMPTY(&mpl->surplus)) {
129
                        /* can do */
130 22387
                } else if (last + .1 * mpl->param->max_age < mpl->t_now) {
131
                        /* should do */
132 18531
                } else if (mpl->self_destruct) {
133
                        /* can do */
134 18510
                } else {
135 18510
                        continue;       /* nothing to do */
136 18510
                }
137
138 55648
                mpl_slp = 0.314;        // random
139
140 55648
                if (Lck_Trylock(&mpl->mtx))
141 0
                        continue;
142
143 55648
                if (mpl->self_destruct) {
144 28
                        AZ(mpl->live);
145 322
                        while (1) {
146 322
                                if (mi == NULL) {
147 322
                                        mi = VTAILQ_FIRST(&mpl->list);
148 322
                                        if (mi != NULL) {
149 293
                                                mpl->vsc->pool = --mpl->n_pool;
150 293
                                                VTAILQ_REMOVE(&mpl->list,
151 293
                                                    mi, list);
152 293
                                        }
153 322
                                }
154 322
                                if (mi == NULL) {
155 28
                                        mi = VTAILQ_FIRST(&mpl->surplus);
156 28
                                        if (mi != NULL)
157 0
                                                VTAILQ_REMOVE(&mpl->surplus,
158 28
                                                    mi, list);
159 28
                                }
160 322
                                if (mi == NULL)
161 28
                                        break;
162 294
                                CHECK_OBJ(mi, MEMITEM_MAGIC);
163 294
                                FREE_OBJ(mi);
164 294
                        }
165 28
                        VSC_mempool_Destroy(&mpl->vsc_seg);
166 28
                        Lck_Unlock(&mpl->mtx);
167 28
                        Lck_Delete(&mpl->mtx);
168 28
                        FREE_OBJ(mpl);
169 28
                        break;
170 28
                }
171
172 55620
                if (mpl->n_pool < mpl->param->min_pool &&
173 55620
                    mi != NULL && mi->size >= *mpl->cur_size) {
174 51736
                        CHECK_OBJ(mi, MEMITEM_MAGIC);
175 51736
                        mpl->vsc->pool = ++mpl->n_pool;
176 51736
                        mi->touched = mpl->t_now;
177 51736
                        VTAILQ_INSERT_HEAD(&mpl->list, mi, list);
178 51736
                        mi = NULL;
179 51736
                        mpl_slp = .01;  // random
180
181 51736
                }
182 55620
                if (mpl->n_pool > mpl->param->max_pool && mi == NULL) {
183 24
                        mi = VTAILQ_FIRST(&mpl->list);
184 24
                        CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);
185 24
                        mpl->vsc->pool = --mpl->n_pool;
186 24
                        mpl->vsc->surplus++;
187 24
                        VTAILQ_REMOVE(&mpl->list, mi, list);
188 24
                        mpl_slp = .01;  // random
189 24
                }
190 55620
                if (mi == NULL) {
191 55583
                        mi = VTAILQ_FIRST(&mpl->surplus);
192 55583
                        if (mi != NULL) {
193 1
                                CHECK_OBJ(mi, MEMITEM_MAGIC);
194 1
                                VTAILQ_REMOVE(&mpl->surplus, mi, list);
195 1
                                mpl_slp = .01;  // random
196 1
                        }
197 55583
                }
198 55620
                if (mi == NULL && mpl->n_pool > mpl->param->min_pool) {
199 711
                        mi = VTAILQ_LAST(&mpl->list, memhead_s);
200 711
                        CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);
201 711
                        if (mi->touched + mpl->param->max_age < mpl->t_now) {
202 167
                                mpl->vsc->pool = --mpl->n_pool;
203 167
                                mpl->vsc->timeout++;
204 167
                                VTAILQ_REMOVE(&mpl->list, mi, list);
205 167
                                mpl_slp = .01;  // random
206 544
                        } else {
207 544
                                mi = NULL;
208 544
                                last = mpl->t_now;
209 544
                        }
210 54909
                } else if (mpl->n_pool <= mpl->param->min_pool) {
211 54877
                        last = mpl->t_now;
212 54877
                }
213
214 55620
                Lck_Unlock(&mpl->mtx);
215
216 55620
                if (mi != NULL) {
217 190
                        CHECK_OBJ(mi, MEMITEM_MAGIC);
218 190
                        FREE_OBJ(mi);
219 190
                }
220 55620
        }
221 5102
        return (NULL);
222 5102
}
223
224
/*---------------------------------------------------------------------
225
 * Create a new memory pool, and start the guard thread for it.
226
 */
227
228
struct mempool *
229
MPL_New(const char *name,
230
    volatile struct poolparam *pp, volatile unsigned *cur_size)
231 5102
{
232 5102
        struct mempool *mpl;
233
234 5102
        ALLOC_OBJ(mpl, MEMPOOL_MAGIC);
235 5102
        AN(mpl);
236 5102
        bprintf(mpl->name, "MPL_%s", name);
237 5102
        mpl->param = pp;
238 5102
        mpl->cur_size = cur_size;
239 5102
        VTAILQ_INIT(&mpl->list);
240 5102
        VTAILQ_INIT(&mpl->surplus);
241 5102
        Lck_New(&mpl->mtx, lck_mempool);
242
        /* XXX: prealloc min_pool */
243 5102
        mpl->vsc = VSC_mempool_New(NULL, &mpl->vsc_seg, mpl->name + 4);
244 5102
        AN(mpl->vsc);
245 5102
        PTOK(pthread_create(&mpl->thread, NULL, mpl_guard, mpl));
246 5102
        PTOK(pthread_detach(mpl->thread));
247 5102
        return (mpl);
248 5102
}
249
250
/*---------------------------------------------------------------------
251
 * Destroy a memory pool.  There must be no live items, and we cheat
252
 * and leave all the hard work to the guard thread.
253
 */
254
255
void
256
MPL_Destroy(struct mempool **mpp)
257 4024
{
258 4024
        struct mempool *mpl;
259
260 4024
        TAKE_OBJ_NOTNULL(mpl, mpp, MEMPOOL_MAGIC);
261 4024
        Lck_Lock(&mpl->mtx);
262 4024
        AZ(mpl->live);
263 4024
        mpl->self_destruct = 1;
264 4024
        Lck_Unlock(&mpl->mtx);
265 4024
}
266
267
/*---------------------------------------------------------------------
268
 */
269
270
void *
271
MPL_Get(struct mempool *mpl, unsigned *size)
272 12767
{
273 12767
        struct memitem *mi;
274
275 12767
        CHECK_OBJ_NOTNULL(mpl, MEMPOOL_MAGIC);
276 12767
        AN(size);
277
278 12767
        Lck_Lock(&mpl->mtx);
279
280 12767
        mpl->vsc->allocs++;
281 12767
        mpl->vsc->live = ++mpl->live;
282
283 12768
        do {
284 12768
                mi = VTAILQ_FIRST(&mpl->list);
285 12768
                if (mi == NULL) {
286 45
                        mpl->vsc->randry++;
287 45
                        break;
288 45
                }
289 12723
                mpl->vsc->pool = --mpl->n_pool;
290 12723
                CHECK_OBJ(mi, MEMITEM_MAGIC);
291 12723
                VTAILQ_REMOVE(&mpl->list, mi, list);
292 12723
                if (mi->size < *mpl->cur_size) {
293 1
                        mpl->vsc->toosmall++;
294 1
                        VTAILQ_INSERT_HEAD(&mpl->surplus, mi, list);
295 1
                        mi = NULL;
296 12722
                } else {
297 12722
                        mpl->vsc->recycle++;
298 12722
                }
299 12723
        } while (mi == NULL);
300
301 12767
        Lck_Unlock(&mpl->mtx);
302
303 12767
        if (mi == NULL)
304 45
                mi = mpl_alloc(mpl);
305 12767
        *size = mi->size - sizeof *mi;
306
307 12767
        CHECK_OBJ(mi, MEMITEM_MAGIC);
308
        /* Throw away sizeof info for FlexeLint: */
309 12767
        return ((void *)(uintptr_t)(mi + 1));
310 12767
}
311
312
void
313
MPL_Free(struct mempool *mpl, void *item)
314 12753
{
315 12753
        struct memitem *mi;
316
317 12753
        CHECK_OBJ_NOTNULL(mpl, MEMPOOL_MAGIC);
318 12753
        AN(item);
319
320 12753
        mi = (void*)((uintptr_t)item - sizeof(*mi));
321 12753
        CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);
322 12753
        memset(item, 0, mi->size - sizeof *mi);
323
324 12753
        Lck_Lock(&mpl->mtx);
325
326 12753
        mpl->vsc->frees++;
327 12753
        mpl->vsc->live = --mpl->live;
328
329 12753
        if (mi->size < *mpl->cur_size) {
330 0
                mpl->vsc->toosmall++;
331 0
                VTAILQ_INSERT_HEAD(&mpl->surplus, mi, list);
332 12753
        } else {
333 12753
                mpl->vsc->pool = ++mpl->n_pool;
334 12753
                mi->touched = mpl->t_now;
335 12753
                VTAILQ_INSERT_HEAD(&mpl->list, mi, list);
336 12753
        }
337
338 12753
        Lck_Unlock(&mpl->mtx);
339 12753
}
340
341
void
342
MPL_AssertSane(const void *item)
343 7365
{
344 7365
        struct memitem *mi;
345 7365
        mi = (void*)((uintptr_t)item - sizeof(*mi));
346 7365
        CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);
347 7365
}