StarPU Internal Handbook
prio_list.h
Go to the documentation of this file.
1/* StarPU --- Runtime system for heterogeneous multicore architectures.
2 *
3 * Copyright (C) 2015-2025 University of Bordeaux, CNRS (LaBRI UMR 5800), Inria
4 *
5 * StarPU is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU Lesser General Public License as published by
7 * the Free Software Foundation; either version 2.1 of the License, or (at
8 * your option) any later version.
9 *
10 * StarPU is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 *
14 * See the GNU Lesser General Public License in COPYING.LGPL for more details.
15 */
16
19/*
20 * This implements list with priorities (as an int), by using two stages:
21 * - an RB tree stage sorted by priority, whose leaves are...
22 * - ... double-linked lists sorted by insertion order.
23 *
24 * We always keep the 0-priority list allocated, to avoid keeping
25 * allocating/deallocating it when all priorities are 0.
26 *
27 * We maintain an "empty" flag, to allow lockless FOO_prio_list_empty call.
28 *
29 * PRIO_LIST_TYPE(FOO, priority_field)
30 *
31 * - Declares the following type:
32 * + priority list: struct FOO_prio_list
33 *
34 * - Declares the following inlines (all O(1) except stated otherwise, n is the
35 * number of elements, p is the number of different priorities):
36 *
37 * * Initialize a new priority list
38 * void FOO_prio_list_init(struct FOO_prio_list*)
39 *
40 * * Initialize a new priority list, assuming that the content of FOO_prio_list was already zeroed
41 * void FOO_prio_list_init0(struct FOO_prio_list*)
42 *
43 * * Free an empty priority list
44 * void FOO_prio_list_deinit(struct FOO_prio_list*)
45 *
46 * * Add a new cell at the end of the list of the priority of the cell (O(log2 p))
47 * void FOO_prio_list_push_back(struct FOO_prio_list*, struct FOO*)
48 *
49 * * Add a new cell at the beginning of the list of the priority of the cell (O(log2 p))
50 * void FOO_prio_list_push_front(struct FOO_prio_list*, struct FOO*)
51 *
52 * * Test whether the priority list is empty
53 * void FOO_prio_list_empty(struct FOO_prio_list*)
54 *
55 * * Remove given cell from the priority list
56 * void FOO_prio_list_erase(struct FOO_prio_list*, struct FOO*)
57 *
58 * * Return and remove the first cell of highest priority of the priority list
59 * void FOO_prio_list_pop_front_highest(struct FOO_prio_list*)
60 * * Return and remove the first cell of lowest priority of the priority list
61 * void FOO_prio_list_pop_front_lowest(struct FOO_prio_list*)
62 *
63 * * Return and remove the last cell of highest priority of the priority list
64 * void FOO_prio_list_pop_back_highest(struct FOO_prio_list*)
65 * * Return and remove the last cell of lowest priority of the priority list
66 * void FOO_prio_list_pop_back_lowest(struct FOO_prio_list*)
67 *
68 * * Return the first cell of highest priority of the priority list
69 * void FOO_prio_list_front_highest(struct FOO_prio_list*)
70 * * Return the first cell of lowest priority of the priority list
71 * void FOO_prio_list_front_lowest(struct FOO_prio_list*)
72 *
73 * * Return the last cell of highest priority of sthe priority list
74 * void FOO_prio_list_back_highest(struct FOO_prio_list*)
75 * * Return the last cell of lowest priority of sthe priority list
76 * void FOO_prio_list_back_lowest(struct FOO_prio_list*)
77 *
78 * * Append second priority list at ends of the first priority list (O(log2 p))
79 * void FOO_prio_list_push_prio_list_back(struct FOO_prio_list*, struct FOO_prio_list*)
80 *
81 * * Append second priority list at beginning of the first priority list (O(log2 p))
82 * void FOO_prio_list_push_prio_list_front(struct FOO_prio_list*, struct FOO_prio_list*)
83 *
84 * * Test whether cell is part of the list (O(n))
85 * void FOO_prio_list_ismember(struct FOO_prio_list*, struct FOO*)
86 *
87 * * Return the first cell of the list
88 * struct FOO* FOO_prio_list_begin(struct FOO_prio_list*);
89 *
90 * * Return the value to test at the end of the list
91 * struct FOO* FOO_prio_list_end(struct FOO_prio_list*);
92 *
93 * * Return the next cell of the list
94 * struct FOO* FOO_prio_list_next(struct FOO_prio_list*, struct FOO*)
95 *
96 * * Return the last cell of the list
97 * struct FOO* FOO_prio_list_last(struct FOO_prio_list*);
98 *
99 * * Return the value to test at the beginning of the list
100 * struct FOO* FOO_prio_list_alpha(struct FOO_prio_list*);
101 *
102 * * Return the previous cell of the list
103 * struct FOO* FOO_prio_list_prev(struct FOO_prio_list*, struct FOO*)
104 *
105 * Return the previous cell of the same priority, or the last cell of next highest priority
106 * struct FOO* FOO_prio_list_prev_highest(struct FOO_prio_list*, struct FOO*)
107 *
108 * Return the next cell of the same priority, or the first cell of next lowest priority
109 * struct FOO* FOO_prio_list_next_lowest(struct FOO_prio_list*, struct FOO*)
110 *
111 * PRIO_LIST_TYPE assumes that LIST_TYPE has already been called to create the
112 * final structure.
113 *
114 * *********************************************************
115 * Usage example:
116 * LIST_TYPE(my_struct,
117 * int a;
118 * int b;
119 * int prio;
120 * );
121 * PRIO_LIST_TYPE(my_struct, prio);
122 *
123 * and then my_struct_prio_list_* inlines are available
124 */
125
126#ifndef __PRIO_LIST_H__
127#define __PRIO_LIST_H__
128
129#include <common/rbtree.h>
130
131#ifndef PRIO_LIST_INLINE
132#define PRIO_LIST_INLINE static inline
133#endif
134
135#define PRIO_LIST_TYPE(ENAME, PRIOFIELD) \
136 PRIO_LIST_CREATE_TYPE(ENAME, PRIOFIELD)
137
138#ifndef STARPU_DEBUG
139
140#define PRIO_LIST_CREATE_TYPE(ENAME, PRIOFIELD) \
141 /* The main type: an RB binary tree */ \
142 struct ENAME##_prio_list { \
143 struct starpu_rbtree tree; \
144 int empty; \
145 }; \
146 /* The second stage: a list */ \
147 struct ENAME##_prio_list_stage { \
148 struct starpu_rbtree_node node; /* Keep this first so ENAME##_node_to_list_stage can work. */ \
149 int prio; \
150 struct ENAME##_list list; \
151 }; \
152 PRIO_LIST_INLINE struct ENAME##_prio_list_stage *ENAME##_node_to_list_stage(struct starpu_rbtree_node *node) \
153 { \
154 /* This assumes node is first member of stage */ \
155 return (struct ENAME##_prio_list_stage *) node; \
156 } \
157 PRIO_LIST_INLINE const struct ENAME##_prio_list_stage *ENAME##_node_to_list_stage_const(const struct starpu_rbtree_node *node) \
158 { \
159 /* This assumes node is first member of stage */ \
160 return (struct ENAME##_prio_list_stage *) node; \
161 } \
162 PRIO_LIST_INLINE void ENAME##_prio_list_init(struct ENAME##_prio_list *priolist) \
163 { \
164 starpu_rbtree_init(&priolist->tree); \
165 priolist->empty = 1; \
166 } \
167 PRIO_LIST_INLINE void ENAME##_prio_list_init0(struct ENAME##_prio_list *priolist) \
168 { \
169 starpu_rbtree_init0(&priolist->tree); \
170 priolist->empty = 1; \
171 } \
172 PRIO_LIST_INLINE void ENAME##_prio_list_deinit(struct ENAME##_prio_list *priolist) \
173 { \
174 if (starpu_rbtree_empty(&priolist->tree)) \
175 return; \
176 struct starpu_rbtree_node *root = priolist->tree.root; \
177 struct ENAME##_prio_list_stage *stage = ENAME##_node_to_list_stage(root); \
178 assert(ENAME##_list_empty(&stage->list)); \
179 assert(!root->children[0] && !root->children[1]); \
180 starpu_rbtree_remove(&priolist->tree, root); \
181 free(stage); \
182 } \
183 PRIO_LIST_INLINE int ENAME##_prio_list_cmp_fn(int prio, const struct starpu_rbtree_node *node) \
184 { \
185 /* Sort by decreasing order */ \
186 const struct ENAME##_prio_list_stage *e2 = ENAME##_node_to_list_stage_const(node); \
187 if (e2->prio < prio) \
188 return -1; \
189 if (e2->prio == prio) \
190 return 0; \
191 /* e2->prio > prio */ \
192 return 1; \
193 } \
194 PRIO_LIST_INLINE struct ENAME##_prio_list_stage *ENAME##_prio_list_add(struct ENAME##_prio_list *priolist, int prio) \
195 { \
196 uintptr_t slot; \
197 struct starpu_rbtree_node *node; \
198 struct ENAME##_prio_list_stage *stage; \
199 node = starpu_rbtree_lookup_slot(&priolist->tree, prio, ENAME##_prio_list_cmp_fn, slot); \
200 if (node) \
201 stage = ENAME##_node_to_list_stage(node); \
202 else { \
203 _STARPU_CALLOC(stage, 1, sizeof(*stage)); \
204 starpu_rbtree_node_init0(&stage->node); \
205 stage->prio = prio; \
206 ENAME##_list_init0(&stage->list); \
207 starpu_rbtree_insert_slot(&priolist->tree, slot, &stage->node); \
208 } \
209 return stage; \
210 } \
211 PRIO_LIST_INLINE void ENAME##_prio_list_push_back(struct ENAME##_prio_list *priolist, struct ENAME *e) \
212 { \
213 struct ENAME##_prio_list_stage *stage = ENAME##_prio_list_add(priolist, e->PRIOFIELD); \
214 ENAME##_list_push_back(&stage->list, e); \
215 priolist->empty = 0; \
216 } \
217 PRIO_LIST_INLINE void ENAME##_prio_list_push_front(struct ENAME##_prio_list *priolist, struct ENAME *e) \
218 { \
219 struct ENAME##_prio_list_stage *stage = ENAME##_prio_list_add(priolist, e->PRIOFIELD); \
220 ENAME##_list_push_front(&stage->list, e); \
221 priolist->empty = 0; \
222 } \
223 PRIO_LIST_INLINE int ENAME##_prio_list_empty(const struct ENAME##_prio_list *priolist) \
224 { \
225 return priolist->empty; \
226 } \
227 /* Version of list_empty which does not use the cached empty flag,
228 * typically used to compute the value of the flag */ \
229 PRIO_LIST_INLINE int ENAME##_prio_list_empty_slow(const struct ENAME##_prio_list *priolist) \
230 { \
231 if (starpu_rbtree_empty(&priolist->tree)) \
232 return 1; \
233 struct starpu_rbtree_node *root = priolist->tree.root; \
234 const struct ENAME##_prio_list_stage *stage = ENAME##_node_to_list_stage_const(root); \
235 if (ENAME##_list_empty(&stage->list) && !root->children[0] && !root->children[1]) \
236 /* Just one empty list */ \
237 return 1; \
238 return 0; \
239 } \
240 /* To be called when removing an element from a stage, to potentially remove this stage */ \
241 PRIO_LIST_INLINE void ENAME##_prio_list_check_empty_stage(struct ENAME##_prio_list *priolist, struct ENAME##_prio_list_stage *stage) \
242 { \
243 if (ENAME##_list_empty(&stage->list)) { \
244 if (stage->prio != 0) \
245 { \
246 /* stage got empty, remove it */ \
247 starpu_rbtree_remove(&priolist->tree, &stage->node); \
248 free(stage); \
249 } \
250 priolist->empty = ENAME##_prio_list_empty_slow(priolist); \
251 } \
252 } \
253 PRIO_LIST_INLINE void ENAME##_prio_list_erase(struct ENAME##_prio_list *priolist, struct ENAME *e) \
254 { \
255 struct starpu_rbtree_node *node = starpu_rbtree_lookup(&priolist->tree, e->PRIOFIELD, ENAME##_prio_list_cmp_fn); \
256 assert(node); \
257 struct ENAME##_prio_list_stage *stage = ENAME##_node_to_list_stage(node); \
258 ENAME##_list_erase(&stage->list, e); \
259 ENAME##_prio_list_check_empty_stage(priolist, stage); \
260 } \
261 PRIO_LIST_INLINE int ENAME##_prio_list_get_next_nonempty_stage(struct ENAME##_prio_list *priolist, struct starpu_rbtree_node *node, struct starpu_rbtree_node **pnode, struct ENAME##_prio_list_stage **pstage) \
262 { \
263 struct ENAME##_prio_list_stage *stage; \
264 while(1) { \
265 struct starpu_rbtree_node *next; \
266 if (!node) \
267 /* Tree is empty */ \
268 return 0; \
269 stage = ENAME##_node_to_list_stage(node); \
270 if (!ENAME##_list_empty(&stage->list)) \
271 break; \
272 /* Empty list, skip to next tree entry */ \
273 next = starpu_rbtree_next(node); \
274 /* drop it if not 0-prio */ \
275 if (stage->prio != 0) \
276 { \
277 starpu_rbtree_remove(&priolist->tree, node); \
278 free(stage); \
279 } \
280 node = next; \
281 } \
282 *pnode = node; \
283 *pstage = stage; \
284 return 1; \
285 } \
286 PRIO_LIST_INLINE int ENAME##_prio_list_get_prev_nonempty_stage(struct ENAME##_prio_list *priolist, struct starpu_rbtree_node *node, struct starpu_rbtree_node **pnode, struct ENAME##_prio_list_stage **pstage) \
287 { \
288 struct ENAME##_prio_list_stage *stage; \
289 while(1) { \
290 struct starpu_rbtree_node *prev; \
291 if (!node) \
292 /* Tree is empty */ \
293 return 0; \
294 stage = ENAME##_node_to_list_stage(node); \
295 if (!ENAME##_list_empty(&stage->list)) \
296 break; \
297 /* Empty list, skip to prev tree entry */ \
298 prev = starpu_rbtree_prev(node); \
299 /* drop it if not 0-prio */ \
300 if (stage->prio != 0) \
301 { \
302 starpu_rbtree_remove(&priolist->tree, node); \
303 free(stage); \
304 } \
305 node = prev; \
306 } \
307 *pnode = node; \
308 *pstage = stage; \
309 return 1; \
310 } \
311 PRIO_LIST_INLINE int ENAME##_prio_list_get_first_nonempty_stage(struct ENAME##_prio_list *priolist, struct starpu_rbtree_node **pnode, struct ENAME##_prio_list_stage **pstage) \
312 { \
313 struct starpu_rbtree_node *node = starpu_rbtree_first(&priolist->tree); \
314 return ENAME##_prio_list_get_next_nonempty_stage(priolist, node, pnode, pstage); \
315 } \
316 PRIO_LIST_INLINE int ENAME##_prio_list_get_last_nonempty_stage(struct ENAME##_prio_list *priolist, struct starpu_rbtree_node **pnode, struct ENAME##_prio_list_stage **pstage) \
317 { \
318 struct starpu_rbtree_node *node = starpu_rbtree_last(&priolist->tree); \
319 return ENAME##_prio_list_get_prev_nonempty_stage(priolist, node, pnode, pstage); \
320 } \
321 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_pop_front_highest(struct ENAME##_prio_list *priolist) \
322 { \
323 struct starpu_rbtree_node *node; \
324 struct ENAME##_prio_list_stage *stage; \
325 struct ENAME *ret; \
326 if (!ENAME##_prio_list_get_first_nonempty_stage(priolist, &node, &stage)) \
327 return NULL; \
328 ret = ENAME##_list_pop_front(&stage->list); \
329 ENAME##_prio_list_check_empty_stage(priolist, stage); \
330 return ret; \
331 } \
332 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_pop_front_lowest(struct ENAME##_prio_list *priolist) \
333 { \
334 struct starpu_rbtree_node *node; \
335 struct ENAME##_prio_list_stage *stage; \
336 struct ENAME *ret; \
337 if (!ENAME##_prio_list_get_last_nonempty_stage(priolist, &node, &stage)) \
338 return NULL; \
339 ret = ENAME##_list_pop_front(&stage->list); \
340 ENAME##_prio_list_check_empty_stage(priolist, stage); \
341 return ret; \
342 } \
343 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_front_highest(struct ENAME##_prio_list *priolist) \
344 { \
345 struct starpu_rbtree_node *node; \
346 struct ENAME##_prio_list_stage *stage; \
347 if (!ENAME##_prio_list_get_first_nonempty_stage(priolist, &node, &stage)) \
348 return NULL; \
349 return ENAME##_list_front(&stage->list); \
350 } \
351 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_front_lowest(struct ENAME##_prio_list *priolist) \
352 { \
353 struct starpu_rbtree_node *node; \
354 struct ENAME##_prio_list_stage *stage; \
355 if (!ENAME##_prio_list_get_last_nonempty_stage(priolist, &node, &stage)) \
356 return NULL; \
357 return ENAME##_list_front(&stage->list); \
358 } \
359 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_pop_back_highest(struct ENAME##_prio_list *priolist) \
360 { \
361 struct starpu_rbtree_node *node; \
362 struct ENAME##_prio_list_stage *stage; \
363 struct ENAME *ret; \
364 if (!ENAME##_prio_list_get_first_nonempty_stage(priolist, &node, &stage)) \
365 return NULL; \
366 ret = ENAME##_list_pop_back(&stage->list); \
367 ENAME##_prio_list_check_empty_stage(priolist, stage); \
368 return ret; \
369 } \
370 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_pop_back_lowest(struct ENAME##_prio_list *priolist) \
371 { \
372 struct starpu_rbtree_node *node; \
373 struct ENAME##_prio_list_stage *stage; \
374 struct ENAME *ret; \
375 if (!ENAME##_prio_list_get_last_nonempty_stage(priolist, &node, &stage)) \
376 return NULL; \
377 ret = ENAME##_list_pop_back(&stage->list); \
378 ENAME##_prio_list_check_empty_stage(priolist, stage); \
379 return ret; \
380 } \
381 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_back_highest(struct ENAME##_prio_list *priolist) \
382 { \
383 struct starpu_rbtree_node *node; \
384 struct ENAME##_prio_list_stage *stage; \
385 if (!ENAME##_prio_list_get_first_nonempty_stage(priolist, &node, &stage)) \
386 return NULL; \
387 return ENAME##_list_back(&stage->list); \
388 } \
389 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_back_lowest(struct ENAME##_prio_list *priolist) \
390 { \
391 struct starpu_rbtree_node *node; \
392 struct ENAME##_prio_list_stage *stage; \
393 if (!ENAME##_prio_list_get_last_nonempty_stage(priolist, &node, &stage)) \
394 return NULL; \
395 return ENAME##_list_back(&stage->list); \
396 } \
397 PRIO_LIST_INLINE void ENAME##_prio_list_push_prio_list_back(struct ENAME##_prio_list *priolist, struct ENAME##_prio_list *priolist_toadd) \
398 { \
399 struct starpu_rbtree_node *node_toadd, *tmp; \
400 starpu_rbtree_for_each_remove(&priolist_toadd->tree, node_toadd, tmp) { \
401 struct ENAME##_prio_list_stage *stage_toadd = ENAME##_node_to_list_stage(node_toadd); \
402 uintptr_t slot; \
403 struct starpu_rbtree_node *node = starpu_rbtree_lookup_slot(&priolist->tree, stage_toadd->prio, ENAME##_prio_list_cmp_fn, slot); \
404 if (node) \
405 { \
406 /* Catenate the lists */ \
407 if (!ENAME##_list_empty(&stage_toadd->list)) { \
408 struct ENAME##_prio_list_stage *stage = ENAME##_node_to_list_stage(node); \
409 ENAME##_list_push_list_back(&stage->list, &stage_toadd->list); \
410 free(node_toadd); \
411 priolist->empty = 0; \
412 } \
413 } \
414 else \
415 { \
416 if (!ENAME##_list_empty(&stage_toadd->list)) { \
417 /* Just move the node between the trees */ \
418 starpu_rbtree_insert_slot(&priolist->tree, slot, node_toadd); \
419 priolist->empty = 0; \
420 } \
421 else \
422 { \
423 /* Actually empty, don't bother moving the list */ \
424 free(node_toadd); \
425 } \
426 } \
427 } \
428 } \
429 PRIO_LIST_INLINE int ENAME##_prio_list_ismember(const struct ENAME##_prio_list *priolist, const struct ENAME *e) \
430 { \
431 struct starpu_rbtree_node *node = starpu_rbtree_lookup(&priolist->tree, e->PRIOFIELD, ENAME##_prio_list_cmp_fn); \
432 if (node) { \
433 const struct ENAME##_prio_list_stage *stage = ENAME##_node_to_list_stage_const(node); \
434 return ENAME##_list_ismember(&stage->list, e); \
435 } \
436 return 0; \
437 } \
438 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_begin(struct ENAME##_prio_list *priolist) \
439 { \
440 struct starpu_rbtree_node *node; \
441 struct ENAME##_prio_list_stage *stage; \
442 if (!ENAME##_prio_list_get_first_nonempty_stage(priolist, &node, &stage)) \
443 return NULL; \
444 return ENAME##_list_begin(&stage->list); \
445 } \
446 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_end(struct ENAME##_prio_list *priolist STARPU_ATTRIBUTE_UNUSED) \
447 { return NULL; } \
448 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_next(struct ENAME##_prio_list *priolist, const struct ENAME *i) \
449 { \
450 struct ENAME *next = ENAME##_list_next(i); \
451 if (next != ENAME##_list_end(NULL)) \
452 return next; \
453 struct starpu_rbtree_node *node = starpu_rbtree_lookup(&priolist->tree, i->PRIOFIELD, ENAME##_prio_list_cmp_fn); \
454 assert(node); \
455 struct ENAME##_prio_list_stage *stage; \
456 node = starpu_rbtree_next(node); \
457 if (!ENAME##_prio_list_get_next_nonempty_stage(priolist, node, &node, &stage)) \
458 return NULL; \
459 return ENAME##_list_begin(&stage->list); \
460 } \
461 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_last(struct ENAME##_prio_list *priolist) \
462 { \
463 struct starpu_rbtree_node *node; \
464 struct ENAME##_prio_list_stage *stage; \
465 if (!ENAME##_prio_list_get_last_nonempty_stage(priolist, &node, &stage)) \
466 return NULL; \
467 return ENAME##_list_last(&stage->list); \
468 } \
469 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_alpha(struct ENAME##_prio_list *priolist STARPU_ATTRIBUTE_UNUSED) \
470 { return NULL; } \
471 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_prev(struct ENAME##_prio_list *priolist, const struct ENAME *i) \
472 { \
473 struct ENAME *next = ENAME##_list_prev(i); \
474 if (next != ENAME##_list_alpha(NULL)) \
475 return next; \
476 struct starpu_rbtree_node *node = starpu_rbtree_lookup(&priolist->tree, i->PRIOFIELD, ENAME##_prio_list_cmp_fn); \
477 assert(node); \
478 struct ENAME##_prio_list_stage *stage; \
479 node = starpu_rbtree_prev(node); \
480 if (!ENAME##_prio_list_get_prev_nonempty_stage(priolist, node, &node, &stage)) \
481 return NULL; \
482 return ENAME##_list_last(&stage->list); \
483 } \
484 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_prev_highest(struct ENAME##_prio_list *priolist, const struct ENAME *i) \
485 { \
486 struct ENAME *next = ENAME##_list_prev(i); \
487 if (next != ENAME##_list_alpha(NULL)) \
488 return next; \
489 struct starpu_rbtree_node *node = starpu_rbtree_lookup(&priolist->tree, i->PRIOFIELD, ENAME##_prio_list_cmp_fn); \
490 assert(node); \
491 struct ENAME##_prio_list_stage *stage; \
492 node = starpu_rbtree_next(node); \
493 if (!ENAME##_prio_list_get_next_nonempty_stage(priolist, node, &node, &stage)) \
494 return NULL; \
495 return ENAME##_list_last(&stage->list); \
496 } \
497 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_next_lowest(struct ENAME##_prio_list *priolist, const struct ENAME *i) \
498 { \
499 struct ENAME *next = ENAME##_list_next(i); \
500 if (next != ENAME##_list_end(NULL)) \
501 return next; \
502 struct starpu_rbtree_node *node = starpu_rbtree_lookup(&priolist->tree, i->PRIOFIELD, ENAME##_prio_list_cmp_fn); \
503 assert(node); \
504 struct ENAME##_prio_list_stage *stage; \
505 node = starpu_rbtree_prev(node); \
506 if (!ENAME##_prio_list_get_prev_nonempty_stage(priolist, node, &node, &stage)) \
507 return NULL; \
508 return ENAME##_list_begin(&stage->list); \
509 } \
510
511#else
512
513/* gdbinit can't recurse in a tree. Use a mere list in debugging mode. */
514#define PRIO_LIST_CREATE_TYPE(ENAME, PRIOFIELD) \
515 struct ENAME##_prio_list { struct ENAME##_list list; }; \
516 PRIO_LIST_INLINE void ENAME##_prio_list_init(struct ENAME##_prio_list *priolist) \
517 { ENAME##_list_init(&(priolist)->list); } \
518 PRIO_LIST_INLINE void ENAME##_prio_list_init0(struct ENAME##_prio_list *priolist) \
519 { ENAME##_list_init0(&(priolist)->list); } \
520 PRIO_LIST_INLINE void ENAME##_prio_list_deinit(struct ENAME##_prio_list *priolist) \
521 { (void) (priolist); /* ENAME##_list_deinit(&(priolist)->list); */ } \
522 PRIO_LIST_INLINE void ENAME##_prio_list_push_back(struct ENAME##_prio_list *priolist, struct ENAME *e) \
523 { \
524 struct ENAME *cur; \
525 for (cur = ENAME##_list_begin(&(priolist)->list); \
526 cur != ENAME##_list_end(&(priolist)->list); \
527 cur = ENAME##_list_next(cur)) \
528 if ((e)->PRIOFIELD > cur->PRIOFIELD) \
529 break; \
530 if (cur == ENAME##_list_end(&(priolist)->list)) \
531 ENAME##_list_push_back(&(priolist)->list, (e)); \
532 else \
533 ENAME##_list_insert_before(&(priolist)->list, (e), cur); \
534 } \
535 PRIO_LIST_INLINE void ENAME##_prio_list_push_front(struct ENAME##_prio_list *priolist, struct ENAME *e) \
536 { \
537 struct ENAME *cur; \
538 for (cur = ENAME##_list_begin(&(priolist)->list); \
539 cur != ENAME##_list_end(&(priolist)->list); \
540 cur = ENAME##_list_next(cur)) \
541 if ((e)->PRIOFIELD >= cur->PRIOFIELD) \
542 break; \
543 if (cur == ENAME##_list_end(&(priolist)->list)) \
544 ENAME##_list_push_back(&(priolist)->list, (e)); \
545 else \
546 ENAME##_list_insert_before(&(priolist)->list, (e), cur); \
547 } \
548 PRIO_LIST_INLINE int ENAME##_prio_list_empty(const struct ENAME##_prio_list *priolist) \
549 { return ENAME##_list_empty(&(priolist)->list); } \
550 PRIO_LIST_INLINE void ENAME##_prio_list_erase(struct ENAME##_prio_list *priolist, struct ENAME *e) \
551 { ENAME##_list_erase(&(priolist)->list, (e)); } \
552 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_pop_front_highest(struct ENAME##_prio_list *priolist) \
553 { return ENAME##_list_pop_front(&(priolist)->list); } \
554 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_pop_front_lowest(struct ENAME##_prio_list *priolist) \
555 { return ENAME##_list_pop_front(&(priolist)->list); } \
556 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_pop_back_highest(struct ENAME##_prio_list *priolist) \
557 { return ENAME##_list_pop_back(&(priolist)->list); } \
558 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_pop_back_lowest(struct ENAME##_prio_list *priolist) \
559 { return ENAME##_list_pop_back(&(priolist)->list); } \
560 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_front_highest(struct ENAME##_prio_list *priolist) \
561 { return ENAME##_list_front(&(priolist)->list); } \
562 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_front_lowest(struct ENAME##_prio_list *priolist) \
563 { return ENAME##_list_front(&(priolist)->list); } \
564 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_back_highest(struct ENAME##_prio_list *priolist) \
565 { return ENAME##_list_back(&(priolist)->list); } \
566 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_back_lowest(struct ENAME##_prio_list *priolist) \
567 { return ENAME##_list_back(&(priolist)->list); } \
568 PRIO_LIST_INLINE void ENAME##_prio_list_push_prio_list_back(struct ENAME##_prio_list *priolist, struct ENAME##_prio_list *priolist_toadd) \
569 { ENAME##_list_push_list_back(&(priolist)->list, &(priolist_toadd)->list); } \
570 PRIO_LIST_INLINE int ENAME##_prio_list_ismember(const struct ENAME##_prio_list *priolist, const struct ENAME *e) \
571 { return ENAME##_list_ismember(&(priolist)->list, (e)); } \
572 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_begin(struct ENAME##_prio_list *priolist) \
573 { return ENAME##_list_begin(&(priolist)->list); } \
574 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_end(struct ENAME##_prio_list *priolist) \
575 { return ENAME##_list_end(&(priolist)->list); } \
576 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_next(struct ENAME##_prio_list *priolist STARPU_ATTRIBUTE_UNUSED, const struct ENAME *i) \
577 { return ENAME##_list_next(i); } \
578 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_last(struct ENAME##_prio_list *priolist) \
579 { return ENAME##_list_last(&(priolist)->list); } \
580 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_alpha(struct ENAME##_prio_list *priolist) \
581 { return ENAME##_list_alpha(&(priolist)->list); } \
582 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_prev(struct ENAME##_prio_list *priolist STARPU_ATTRIBUTE_UNUSED, const struct ENAME *i) \
583 { return ENAME##_list_prev(i); } \
584 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_prev_highest(struct ENAME##_prio_list *priolist STARPU_ATTRIBUTE_UNUSED, const struct ENAME *i) \
585 { return ENAME##_list_prev(i); } \
586 PRIO_LIST_INLINE struct ENAME *ENAME##_prio_list_next_lowest(struct ENAME##_prio_list *priolist STARPU_ATTRIBUTE_UNUSED, const struct ENAME *i) \
587 { return ENAME##_list_next(i); } \
588
589#endif
590
591#endif // __PRIO_LIST_H__