Branch data Line data Source code
1 : : /*--------------------------------------------------------------------------
2 : : *
3 : : * test_resowner_many.c
4 : : * Test ResourceOwner functionality with lots of resources
5 : : *
6 : : * Copyright (c) 2022-2026, PostgreSQL Global Development Group
7 : : *
8 : : * IDENTIFICATION
9 : : * src/test/modules/test_resowner/test_resowner_many.c
10 : : *
11 : : * -------------------------------------------------------------------------
12 : : */
13 : : #include "postgres.h"
14 : :
15 : : #include "fmgr.h"
16 : : #include "lib/ilist.h"
17 : : #include "utils/resowner.h"
18 : :
19 : : /*
20 : : * Define a custom resource type to use in the test. The resource being
21 : : * tracked is a palloc'd ManyTestResource struct.
22 : : *
23 : : * To cross-check that the ResourceOwner calls the callback functions
24 : : * correctly, we keep track of the remembered resources ourselves in a linked
25 : : * list, and also keep counters of how many times the callback functions have
26 : : * been called.
27 : : */
28 : : typedef struct
29 : : {
30 : : ResourceOwnerDesc desc;
31 : : int nremembered;
32 : : int nforgotten;
33 : : int nreleased;
34 : : int nleaked;
35 : :
36 : : dlist_head current_resources;
37 : : } ManyTestResourceKind;
38 : :
39 : : typedef struct
40 : : {
41 : : ManyTestResourceKind *kind;
42 : : dlist_node node;
43 : : } ManyTestResource;
44 : :
45 : : /*
46 : : * Current release phase, and priority of last call to the release callback.
47 : : * This is used to check that the resources are released in correct order.
48 : : */
49 : : static ResourceReleasePhase current_release_phase;
50 : : static uint32 last_release_priority = 0;
51 : :
52 : : /* prototypes for local functions */
53 : : static void ReleaseManyTestResource(Datum res);
54 : : static char *PrintManyTest(Datum res);
55 : : static void InitManyTestResourceKind(ManyTestResourceKind *kind, char *name,
56 : : ResourceReleasePhase phase, uint32 priority);
57 : : static void RememberManyTestResources(ResourceOwner owner,
58 : : ManyTestResourceKind *kinds, int nkinds,
59 : : int nresources);
60 : : static void ForgetManyTestResources(ResourceOwner owner,
61 : : ManyTestResourceKind *kinds, int nkinds,
62 : : int nresources);
63 : : static int GetTotalResourceCount(ManyTestResourceKind *kinds, int nkinds);
64 : :
65 : : /* ResourceOwner callback */
66 : : static void
67 : 199000 : ReleaseManyTestResource(Datum res)
68 : : {
69 : 199000 : ManyTestResource *mres = (ManyTestResource *) DatumGetPointer(res);
70 : :
71 [ - + ]: 199000 : elog(DEBUG1, "releasing resource %p from %s", mres, mres->kind->desc.name);
72 : : Assert(last_release_priority <= mres->kind->desc.release_priority);
73 : :
74 : 199000 : dlist_delete(&mres->node);
75 : 199000 : mres->kind->nreleased++;
76 : 199000 : last_release_priority = mres->kind->desc.release_priority;
77 : 199000 : pfree(mres);
78 : 199000 : }
79 : :
80 : : /* ResourceOwner callback */
81 : : static char *
82 : 0 : PrintManyTest(Datum res)
83 : : {
84 : 0 : ManyTestResource *mres = (ManyTestResource *) DatumGetPointer(res);
85 : :
86 : : /*
87 : : * XXX: we assume that the DebugPrint function is called once for each
88 : : * leaked resource, and that there are no other callers.
89 : : */
90 : 0 : mres->kind->nleaked++;
91 : :
92 : 0 : return psprintf("many-test resource from %s", mres->kind->desc.name);
93 : : }
94 : :
95 : : static void
96 : 6 : InitManyTestResourceKind(ManyTestResourceKind *kind, char *name,
97 : : ResourceReleasePhase phase, uint32 priority)
98 : : {
99 : 6 : kind->desc.name = name;
100 : 6 : kind->desc.release_phase = phase;
101 : 6 : kind->desc.release_priority = priority;
102 : 6 : kind->desc.ReleaseResource = ReleaseManyTestResource;
103 : 6 : kind->desc.DebugPrint = PrintManyTest;
104 : 6 : kind->nremembered = 0;
105 : 6 : kind->nforgotten = 0;
106 : 6 : kind->nreleased = 0;
107 : 6 : kind->nleaked = 0;
108 : 6 : dlist_init(&kind->current_resources);
109 : 6 : }
110 : :
111 : : /*
112 : : * Remember 'nresources' resources. The resources are remembered in round
113 : : * robin fashion with the kinds from 'kinds' array.
114 : : */
115 : : static void
116 : 2 : RememberManyTestResources(ResourceOwner owner,
117 : : ManyTestResourceKind *kinds, int nkinds,
118 : : int nresources)
119 : : {
120 : 2 : int kind_idx = 0;
121 : :
122 [ + + ]: 200002 : for (int i = 0; i < nresources; i++)
123 : : {
124 : 200000 : ManyTestResource *mres = palloc_object(ManyTestResource);
125 : :
126 : 200000 : mres->kind = &kinds[kind_idx];
127 : 200000 : dlist_node_init(&mres->node);
128 : :
129 : 200000 : ResourceOwnerEnlarge(owner);
130 : 200000 : ResourceOwnerRemember(owner, PointerGetDatum(mres), &kinds[kind_idx].desc);
131 : 200000 : kinds[kind_idx].nremembered++;
132 : 200000 : dlist_push_tail(&kinds[kind_idx].current_resources, &mres->node);
133 : :
134 [ - + ]: 200000 : elog(DEBUG1, "remembered resource %p from %s", mres, mres->kind->desc.name);
135 : :
136 : 200000 : kind_idx = (kind_idx + 1) % nkinds;
137 : : }
138 : 2 : }
139 : :
140 : : /*
141 : : * Forget 'nresources' resources, in round robin fashion from 'kinds'.
142 : : */
143 : : static void
144 : 2 : ForgetManyTestResources(ResourceOwner owner,
145 : : ManyTestResourceKind *kinds, int nkinds,
146 : : int nresources)
147 : : {
148 : 2 : int kind_idx = 0;
149 : : int ntotal;
150 : :
151 : 2 : ntotal = GetTotalResourceCount(kinds, nkinds);
152 [ - + ]: 2 : if (ntotal < nresources)
153 [ # # ]: 0 : elog(PANIC, "cannot free %d resources, only %d remembered", nresources, ntotal);
154 : :
155 [ + + ]: 1002 : for (int i = 0; i < nresources; i++)
156 : : {
157 : 1000 : bool found = false;
158 : :
159 [ + - ]: 1000 : for (int j = 0; j < nkinds; j++)
160 : : {
161 : 1000 : kind_idx = (kind_idx + 1) % nkinds;
162 [ + - ]: 1000 : if (!dlist_is_empty(&kinds[kind_idx].current_resources))
163 : : {
164 : 1000 : ManyTestResource *mres = dlist_head_element(ManyTestResource, node, &kinds[kind_idx].current_resources);
165 : :
166 : 1000 : ResourceOwnerForget(owner, PointerGetDatum(mres), &kinds[kind_idx].desc);
167 : 1000 : kinds[kind_idx].nforgotten++;
168 : 1000 : dlist_delete(&mres->node);
169 : 1000 : pfree(mres);
170 : :
171 : 1000 : found = true;
172 : 1000 : break;
173 : : }
174 : : }
175 [ - + ]: 1000 : if (!found)
176 [ # # ]: 0 : elog(ERROR, "could not find a test resource to forget");
177 : : }
178 : 2 : }
179 : :
180 : : /*
181 : : * Get total number of currently active resources among 'kinds'.
182 : : */
183 : : static int
184 : 2 : GetTotalResourceCount(ManyTestResourceKind *kinds, int nkinds)
185 : : {
186 : 2 : int ntotal = 0;
187 : :
188 [ + + ]: 8 : for (int i = 0; i < nkinds; i++)
189 : 6 : ntotal += kinds[i].nremembered - kinds[i].nforgotten - kinds[i].nreleased;
190 : :
191 : 2 : return ntotal;
192 : : }
193 : :
194 : : /*
195 : : * Remember lots of resources, belonging to 'nkinds' different resource types
196 : : * with different priorities. Then forget some of them, and finally, release
197 : : * the resource owner. We use a custom resource type that performs various
198 : : * sanity checks to verify that all the resources are released, and in the
199 : : * correct order.
200 : : */
201 : 2 : PG_FUNCTION_INFO_V1(test_resowner_many);
202 : : Datum
203 : 1 : test_resowner_many(PG_FUNCTION_ARGS)
204 : : {
205 : 1 : int32 nkinds = PG_GETARG_INT32(0);
206 : 1 : int32 nremember_bl = PG_GETARG_INT32(1);
207 : 1 : int32 nforget_bl = PG_GETARG_INT32(2);
208 : 1 : int32 nremember_al = PG_GETARG_INT32(3);
209 : 1 : int32 nforget_al = PG_GETARG_INT32(4);
210 : :
211 : : ResourceOwner resowner;
212 : :
213 : : ManyTestResourceKind *before_kinds;
214 : : ManyTestResourceKind *after_kinds;
215 : :
216 : : /* Sanity check the arguments */
217 [ - + ]: 1 : if (nkinds < 0)
218 [ # # ]: 0 : elog(ERROR, "nkinds must be >= 0");
219 [ - + ]: 1 : if (nremember_bl < 0)
220 [ # # ]: 0 : elog(ERROR, "nremember_bl must be >= 0");
221 [ + - - + ]: 1 : if (nforget_bl < 0 || nforget_bl > nremember_bl)
222 [ # # ]: 0 : elog(ERROR, "nforget_bl must between 0 and 'nremember_bl'");
223 [ - + ]: 1 : if (nremember_al < 0)
224 [ # # ]: 0 : elog(ERROR, "nremember_al must be greater than zero");
225 [ + - - + ]: 1 : if (nforget_al < 0 || nforget_al > nremember_al)
226 [ # # ]: 0 : elog(ERROR, "nforget_al must between 0 and 'nremember_al'");
227 : :
228 : : /* Initialize all the different resource kinds to use */
229 : 1 : before_kinds = palloc(nkinds * sizeof(ManyTestResourceKind));
230 [ + + ]: 4 : for (int i = 0; i < nkinds; i++)
231 : : {
232 : 3 : InitManyTestResourceKind(&before_kinds[i],
233 : : psprintf("resource before locks %d", i),
234 : : RESOURCE_RELEASE_BEFORE_LOCKS,
235 : 3 : RELEASE_PRIO_FIRST + i);
236 : : }
237 : 1 : after_kinds = palloc(nkinds * sizeof(ManyTestResourceKind));
238 [ + + ]: 4 : for (int i = 0; i < nkinds; i++)
239 : : {
240 : 3 : InitManyTestResourceKind(&after_kinds[i],
241 : : psprintf("resource after locks %d", i),
242 : : RESOURCE_RELEASE_AFTER_LOCKS,
243 : 3 : RELEASE_PRIO_FIRST + i);
244 : : }
245 : :
246 : 1 : resowner = ResourceOwnerCreate(CurrentResourceOwner, "TestOwner");
247 : :
248 : : /* Remember a bunch of resources */
249 [ + - ]: 1 : if (nremember_bl > 0)
250 : : {
251 [ + - ]: 1 : elog(NOTICE, "remembering %d before-locks resources", nremember_bl);
252 : 1 : RememberManyTestResources(resowner, before_kinds, nkinds, nremember_bl);
253 : : }
254 [ + - ]: 1 : if (nremember_al > 0)
255 : : {
256 [ + - ]: 1 : elog(NOTICE, "remembering %d after-locks resources", nremember_al);
257 : 1 : RememberManyTestResources(resowner, after_kinds, nkinds, nremember_al);
258 : : }
259 : :
260 : : /* Forget what was remembered */
261 [ + - ]: 1 : if (nforget_bl > 0)
262 : : {
263 [ + - ]: 1 : elog(NOTICE, "forgetting %d before-locks resources", nforget_bl);
264 : 1 : ForgetManyTestResources(resowner, before_kinds, nkinds, nforget_bl);
265 : : }
266 : :
267 [ + - ]: 1 : if (nforget_al > 0)
268 : : {
269 [ + - ]: 1 : elog(NOTICE, "forgetting %d after-locks resources", nforget_al);
270 : 1 : ForgetManyTestResources(resowner, after_kinds, nkinds, nforget_al);
271 : : }
272 : :
273 : : /* Start releasing */
274 [ + - ]: 1 : elog(NOTICE, "releasing resources before locks");
275 : 1 : current_release_phase = RESOURCE_RELEASE_BEFORE_LOCKS;
276 : 1 : last_release_priority = 0;
277 : 1 : ResourceOwnerRelease(resowner, RESOURCE_RELEASE_BEFORE_LOCKS, false, false);
278 : : Assert(GetTotalResourceCount(before_kinds, nkinds) == 0);
279 : :
280 [ + - ]: 1 : elog(NOTICE, "releasing locks");
281 : 1 : current_release_phase = RESOURCE_RELEASE_LOCKS;
282 : 1 : last_release_priority = 0;
283 : 1 : ResourceOwnerRelease(resowner, RESOURCE_RELEASE_LOCKS, false, false);
284 : :
285 [ + - ]: 1 : elog(NOTICE, "releasing resources after locks");
286 : 1 : current_release_phase = RESOURCE_RELEASE_AFTER_LOCKS;
287 : 1 : last_release_priority = 0;
288 : 1 : ResourceOwnerRelease(resowner, RESOURCE_RELEASE_AFTER_LOCKS, false, false);
289 : : Assert(GetTotalResourceCount(before_kinds, nkinds) == 0);
290 : : Assert(GetTotalResourceCount(after_kinds, nkinds) == 0);
291 : :
292 : 1 : ResourceOwnerDelete(resowner);
293 : :
294 : 1 : PG_RETURN_VOID();
295 : : }
|
