Skip to content

V
varnish-cache
Commit 08d8a294 authored by Nils Goroll's avatar Nils Goroll
Browse files
Options

Rename VRB_ -> VRBT_ for red/black tree macros 

sed 's:VRB_:VRBT_:g' -i "$FILES_CHANGED[@]"

Closes #2812
parent ba2bd1b4
Hide whitespace changes
Inline Side-by-side
Showing with 287 additions and 287 deletions
bin/varnishtop/flint.lnt
View file @ 08d8a294
......@@ -8,8 +8,8 @@
-e732 // Loss of sign (arg. no. 2) (int to unsigned
-e713 // Loss of precision (assignment) (unsigned long long to long long)
-sem(t_order_VRB_INSERT, custodial(2))
-sem(t_key_VRB_INSERT, custodial(2))
-sem(t_order_VRBT_INSERT, custodial(2))
-sem(t_key_VRBT_INSERT, custodial(2))
///////////////////////////////////////////////////////////////////////
// Varnishstat specific
......
bin/varnishtop/varnishtop.c
View file @ 08d8a294
......@@ -70,8 +70,8 @@ struct top {
char *rec_buf;
int clen;
unsigned hash;
VRB_ENTRY(top) e_order;
VRB_ENTRY(top) e_key;
VRBT_ENTRY(top) e_order;
VRBT_ENTRY(top) e_key;
double count;
};
......@@ -85,8 +85,8 @@ static const char *ident;
static volatile sig_atomic_t quit = 0;
static VRB_HEAD(t_order, top) h_order = VRB_INITIALIZER(&h_order);
static VRB_HEAD(t_key, top) h_key = VRB_INITIALIZER(&h_key);
static VRBT_HEAD(t_order, top) h_order = VRBT_INITIALIZER(&h_order);
static VRBT_HEAD(t_key, top) h_key = VRBT_INITIALIZER(&h_key);
static inline int
cmp_key(const struct top *a, const struct top *b)
......@@ -110,10 +110,10 @@ cmp_order(const struct top *a, const struct top *b)
return (cmp_key(a, b));
}
VRB_PROTOTYPE_STATIC(t_order, top, e_order, cmp_order)
VRB_GENERATE_STATIC(t_order, top, e_order, cmp_order)
VRB_PROTOTYPE_STATIC(t_key, top, e_key, cmp_key)
VRB_GENERATE_STATIC(t_key, top, e_key, cmp_key)
VRBT_PROTOTYPE_STATIC(t_order, top, e_order, cmp_order)
VRBT_GENERATE_STATIC(t_order, top, e_order, cmp_order)
VRBT_PROTOTYPE_STATIC(t_key, top, e_key, cmp_key)
VRBT_GENERATE_STATIC(t_key, top, e_key, cmp_key)
static int v_matchproto_(VSLQ_dispatch_f)
accumulate(struct VSL_data *vsl, struct VSL_transaction * const pt[],
......@@ -155,12 +155,12 @@ accumulate(struct VSL_data *vsl, struct VSL_transaction * const pt[],
t.rec_data = VSL_CDATA(tr->c->rec.ptr);
AZ(pthread_mutex_lock(&mtx));
tp = VRB_FIND(t_key, &h_key, &t);
tp = VRBT_FIND(t_key, &h_key, &t);
if (tp) {
VRB_REMOVE(t_order, &h_order, tp);
VRBT_REMOVE(t_order, &h_order, tp);
tp->count += 1.0;
/* Reinsert to rebalance */
VRB_INSERT(t_order, &h_order, tp);
VRBT_INSERT(t_order, &h_order, tp);
} else {
ntop++;
tp = calloc(1, sizeof *tp);
......@@ -172,8 +172,8 @@ accumulate(struct VSL_data *vsl, struct VSL_transaction * const pt[],
tp->rec_buf = strdup(t.rec_data);
tp->rec_data = tp->rec_buf;
AN(tp->rec_data);
VRB_INSERT(t_key, &h_key, tp);
VRB_INSERT(t_order, &h_order, tp);
VRBT_INSERT(t_key, &h_key, tp);
VRBT_INSERT(t_order, &h_order, tp);
}
AZ(pthread_mutex_unlock(&mtx));
......@@ -226,8 +226,8 @@ update(int p)
else
AC(mvprintw(0, len - 1, "%s", q));
AC(mvprintw(0, 0, "list length %u", ntop));
for (tp = VRB_MIN(t_order, &h_order); tp != NULL; tp = tp2) {
tp2 = VRB_NEXT(t_order, &h_order, tp);
for (tp = VRBT_MIN(t_order, &h_order); tp != NULL; tp = tp2) {
tp2 = VRBT_NEXT(t_order, &h_order, tp);
if (++l < LINES) {
len = tp->clen;
......@@ -243,8 +243,8 @@ update(int p)
continue;
tp->count += (1.0/3.0 - tp->count) / (double)n;
if (tp->count * 10 < t || l > LINES * 10) {
VRB_REMOVE(t_key, &h_key, tp);
VRB_REMOVE(t_order, &h_order, tp);
VRBT_REMOVE(t_key, &h_key, tp);
VRBT_REMOVE(t_order, &h_order, tp);
free(tp->rec_buf);
free(tp);
ntop--;
......@@ -316,8 +316,8 @@ static void
dump(void)
{
struct top *tp, *tp2;
for (tp = VRB_MIN(t_order, &h_order); tp != NULL; tp = tp2) {
tp2 = VRB_NEXT(t_order, &h_order, tp);
for (tp = VRBT_MIN(t_order, &h_order); tp != NULL; tp = tp2) {
tp2 = VRBT_NEXT(t_order, &h_order, tp);
printf("%9.2f %s %*.*s\n",
tp->count, VSL_tags[tp->tag],
tp->clen, tp->clen, tp->rec_data);
......
flint.lnt
View file @ 08d8a294
......@@ -142,9 +142,9 @@
///////////////////////////////////////////////////////////////////////
// <vtree.h>
-emacro(801, VRB_*) // goto considered bad
-esym(534, *_VRB_REMOVE) // ignore retval
-esym(534, *_VRB_INSERT) // ignore retval
-emacro(801, VRBT_*) // goto considered bad
-esym(534, *_VRBT_REMOVE) // ignore retval
-esym(534, *_VRBT_INSERT) // ignore retval
///////////////////////////////////////////////////////////////////////
// <vqueue.h>
......
include/vtree.h
View file @ 08d8a294
......@@ -291,21 +291,21 @@ void name##_VSPLAY_MINMAX(struct name *head, int __comp) \
(x) = VSPLAY_NEXT(name, head, x))
/* Macros that define a red-black tree */
#define VRB_HEAD(name, type) \
#define VRBT_HEAD(name, type) \
struct name { \
struct type *rbh_root; /* root of the tree */ \
}
#define VRB_INITIALIZER(root) \
#define VRBT_INITIALIZER(root) \
{ NULL }
#define VRB_INIT(root) do { \
#define VRBT_INIT(root) do { \
(root)->rbh_root = NULL; \
} while (/*CONSTCOND*/ 0)
#define VRB_BLACK 0
#define VRB_RED 1
#define VRB_ENTRY(type) \
#define VRBT_BLACK 0
#define VRBT_RED 1
#define VRBT_ENTRY(type) \
struct { \
struct type *rbe_left; /* left element */ \
struct type *rbe_right; /* right element */ \
......@@ -313,328 +313,328 @@ struct { \
int rbe_color; /* node color */ \
}
#define VRB_LEFT(elm, field) (elm)->field.rbe_left
#define VRB_RIGHT(elm, field) (elm)->field.rbe_right
#define VRB_PARENT(elm, field) (elm)->field.rbe_parent
#define VRB_COLOR(elm, field) (elm)->field.rbe_color
#define VRB_ROOT(head) (head)->rbh_root
#define VRB_EMPTY(head) (VRB_ROOT(head) == NULL)
#define VRB_SET(elm, parent, field) do { \
VRB_PARENT(elm, field) = parent; \
VRB_LEFT(elm, field) = VRB_RIGHT(elm, field) = NULL; \
VRB_COLOR(elm, field) = VRB_RED; \
#define VRBT_LEFT(elm, field) (elm)->field.rbe_left
#define VRBT_RIGHT(elm, field) (elm)->field.rbe_right
#define VRBT_PARENT(elm, field) (elm)->field.rbe_parent
#define VRBT_COLOR(elm, field) (elm)->field.rbe_color
#define VRBT_ROOT(head) (head)->rbh_root
#define VRBT_EMPTY(head) (VRBT_ROOT(head) == NULL)
#define VRBT_SET(elm, parent, field) do { \
VRBT_PARENT(elm, field) = parent; \
VRBT_LEFT(elm, field) = VRBT_RIGHT(elm, field) = NULL; \
VRBT_COLOR(elm, field) = VRBT_RED; \
} while (/*CONSTCOND*/ 0)
#define VRB_SET_BLACKRED(black, red, field) do { \
VRB_COLOR(black, field) = VRB_BLACK; \
VRB_COLOR(red, field) = VRB_RED; \
#define VRBT_SET_BLACKRED(black, red, field) do { \
VRBT_COLOR(black, field) = VRBT_BLACK; \
VRBT_COLOR(red, field) = VRBT_RED; \
} while (/*CONSTCOND*/ 0)
#ifndef VRB_AUGMENT
#define VRB_AUGMENT(x) do {} while (0)
#ifndef VRBT_AUGMENT
#define VRBT_AUGMENT(x) do {} while (0)
#endif
#define VRB_ROTATE_LEFT(head, elm, tmp, field) do { \
(tmp) = VRB_RIGHT(elm, field); \
if ((VRB_RIGHT(elm, field) = VRB_LEFT(tmp, field)) != NULL) { \
VRB_PARENT(VRB_LEFT(tmp, field), field) = (elm); \
#define VRBT_ROTATE_LEFT(head, elm, tmp, field) do { \
(tmp) = VRBT_RIGHT(elm, field); \
if ((VRBT_RIGHT(elm, field) = VRBT_LEFT(tmp, field)) != NULL) { \
VRBT_PARENT(VRBT_LEFT(tmp, field), field) = (elm); \
} \
VRB_AUGMENT(elm); \
if ((VRB_PARENT(tmp, field) = VRB_PARENT(elm, field)) != NULL) {\
if ((elm) == VRB_LEFT(VRB_PARENT(elm, field), field)) \
VRB_LEFT(VRB_PARENT(elm, field), field) = (tmp);\
VRBT_AUGMENT(elm); \
if ((VRBT_PARENT(tmp, field) = VRBT_PARENT(elm, field)) != NULL) {\
if ((elm) == VRBT_LEFT(VRBT_PARENT(elm, field), field)) \
VRBT_LEFT(VRBT_PARENT(elm, field), field) = (tmp);\
else \
VRB_RIGHT(VRB_PARENT(elm, field), field) = (tmp);\
VRBT_RIGHT(VRBT_PARENT(elm, field), field) = (tmp);\
} else \
(head)->rbh_root = (tmp); \
VRB_LEFT(tmp, field) = (elm); \
VRB_PARENT(elm, field) = (tmp); \
VRB_AUGMENT(tmp); \
if ((VRB_PARENT(tmp, field))) \
VRB_AUGMENT(VRB_PARENT(tmp, field)); \
VRBT_LEFT(tmp, field) = (elm); \
VRBT_PARENT(elm, field) = (tmp); \
VRBT_AUGMENT(tmp); \
if ((VRBT_PARENT(tmp, field))) \
VRBT_AUGMENT(VRBT_PARENT(tmp, field)); \
} while (/*CONSTCOND*/ 0)
#define VRB_ROTATE_RIGHT(head, elm, tmp, field) do { \
(tmp) = VRB_LEFT(elm, field); \
if ((VRB_LEFT(elm, field) = VRB_RIGHT(tmp, field)) != NULL) { \
VRB_PARENT(VRB_RIGHT(tmp, field), field) = (elm); \
#define VRBT_ROTATE_RIGHT(head, elm, tmp, field) do { \
(tmp) = VRBT_LEFT(elm, field); \
if ((VRBT_LEFT(elm, field) = VRBT_RIGHT(tmp, field)) != NULL) { \
VRBT_PARENT(VRBT_RIGHT(tmp, field), field) = (elm); \
} \
VRB_AUGMENT(elm); \
if ((VRB_PARENT(tmp, field) = VRB_PARENT(elm, field)) != NULL) {\
if ((elm) == VRB_LEFT(VRB_PARENT(elm, field), field)) \
VRB_LEFT(VRB_PARENT(elm, field), field) = (tmp);\
VRBT_AUGMENT(elm); \
if ((VRBT_PARENT(tmp, field) = VRBT_PARENT(elm, field)) != NULL) {\
if ((elm) == VRBT_LEFT(VRBT_PARENT(elm, field), field)) \
VRBT_LEFT(VRBT_PARENT(elm, field), field) = (tmp);\
else \
VRB_RIGHT(VRB_PARENT(elm, field), field) = (tmp);\
VRBT_RIGHT(VRBT_PARENT(elm, field), field) = (tmp);\
} else \
(head)->rbh_root = (tmp); \
VRB_RIGHT(tmp, field) = (elm); \
VRB_PARENT(elm, field) = (tmp); \
VRB_AUGMENT(tmp); \
if ((VRB_PARENT(tmp, field))) \
VRB_AUGMENT(VRB_PARENT(tmp, field)); \
VRBT_RIGHT(tmp, field) = (elm); \
VRBT_PARENT(elm, field) = (tmp); \
VRBT_AUGMENT(tmp); \
if ((VRBT_PARENT(tmp, field))) \
VRBT_AUGMENT(VRBT_PARENT(tmp, field)); \
} while (/*CONSTCOND*/ 0)
/* Generates prototypes and inline functions */
#define VRB_PROTOTYPE(name, type, field, cmp) \
VRB_PROTOTYPE_INTERNAL(name, type, field, cmp,)
#define VRB_PROTOTYPE_STATIC(name, type, field, cmp) \
VRB_PROTOTYPE_INTERNAL(name, type, field, cmp, v_unused_ static)
#define VRB_PROTOTYPE_INTERNAL(name, type, field, cmp, attr) \
/*lint -esym(528, name##_VRB_*) */ \
attr void name##_VRB_INSERT_COLOR(struct name *, struct type *); \
attr void name##_VRB_REMOVE_COLOR(struct name *, struct type *, struct type *);\
attr struct type *name##_VRB_REMOVE(struct name *, struct type *); \
attr struct type *name##_VRB_INSERT(struct name *, struct type *); \
attr struct type *name##_VRB_FIND(const struct name *, const struct type *); \
attr struct type *name##_VRB_NFIND(const struct name *, const struct type *); \
attr struct type *name##_VRB_NEXT(struct type *); \
attr struct type *name##_VRB_PREV(struct type *); \
attr struct type *name##_VRB_MINMAX(const struct name *, int); \
#define VRBT_PROTOTYPE(name, type, field, cmp) \
VRBT_PROTOTYPE_INTERNAL(name, type, field, cmp,)
#define VRBT_PROTOTYPE_STATIC(name, type, field, cmp) \
VRBT_PROTOTYPE_INTERNAL(name, type, field, cmp, v_unused_ static)
#define VRBT_PROTOTYPE_INTERNAL(name, type, field, cmp, attr) \
/*lint -esym(528, name##_VRBT_*) */ \
attr void name##_VRBT_INSERT_COLOR(struct name *, struct type *); \
attr void name##_VRBT_REMOVE_COLOR(struct name *, struct type *, struct type *);\
attr struct type *name##_VRBT_REMOVE(struct name *, struct type *); \
attr struct type *name##_VRBT_INSERT(struct name *, struct type *); \
attr struct type *name##_VRBT_FIND(const struct name *, const struct type *); \
attr struct type *name##_VRBT_NFIND(const struct name *, const struct type *); \
attr struct type *name##_VRBT_NEXT(struct type *); \
attr struct type *name##_VRBT_PREV(struct type *); \
attr struct type *name##_VRBT_MINMAX(const struct name *, int); \
\
/* Main rb operation.
* Moves node close to the key of elm to top
*/
#define VRB_GENERATE(name, type, field, cmp) \
VRB_GENERATE_INTERNAL(name, type, field, cmp,)
#define VRB_GENERATE_STATIC(name, type, field, cmp) \
VRB_GENERATE_INTERNAL(name, type, field, cmp, v_unused_ static)
#define VRB_GENERATE_INTERNAL(name, type, field, cmp, attr) \
#define VRBT_GENERATE(name, type, field, cmp) \
VRBT_GENERATE_INTERNAL(name, type, field, cmp,)
#define VRBT_GENERATE_STATIC(name, type, field, cmp) \
VRBT_GENERATE_INTERNAL(name, type, field, cmp, v_unused_ static)
#define VRBT_GENERATE_INTERNAL(name, type, field, cmp, attr) \
attr void \
name##_VRB_INSERT_COLOR(struct name *head, struct type *elm) \
name##_VRBT_INSERT_COLOR(struct name *head, struct type *elm) \
{ \
struct type *parent, *gparent, *tmp; \
while ((parent = VRB_PARENT(elm, field)) != NULL && \
VRB_COLOR(parent, field) == VRB_RED) { \
gparent = VRB_PARENT(parent, field); \
if (parent == VRB_LEFT(gparent, field)) { \
tmp = VRB_RIGHT(gparent, field); \
if (tmp && VRB_COLOR(tmp, field) == VRB_RED) { \
VRB_COLOR(tmp, field) = VRB_BLACK; \
VRB_SET_BLACKRED(parent, gparent, field);\
while ((parent = VRBT_PARENT(elm, field)) != NULL && \
VRBT_COLOR(parent, field) == VRBT_RED) { \
gparent = VRBT_PARENT(parent, field); \
if (parent == VRBT_LEFT(gparent, field)) { \
tmp = VRBT_RIGHT(gparent, field); \
if (tmp && VRBT_COLOR(tmp, field) == VRBT_RED) { \
VRBT_COLOR(tmp, field) = VRBT_BLACK; \
VRBT_SET_BLACKRED(parent, gparent, field);\
elm = gparent; \
continue; \
} \
if (VRB_RIGHT(parent, field) == elm) { \
VRB_ROTATE_LEFT(head, parent, tmp, field);\
if (VRBT_RIGHT(parent, field) == elm) { \
VRBT_ROTATE_LEFT(head, parent, tmp, field);\
tmp = parent; \
parent = elm; \
elm = tmp; \
} \
VRB_SET_BLACKRED(parent, gparent, field); \
VRB_ROTATE_RIGHT(head, gparent, tmp, field); \
VRBT_SET_BLACKRED(parent, gparent, field); \
VRBT_ROTATE_RIGHT(head, gparent, tmp, field); \
} else { \
tmp = VRB_LEFT(gparent, field); \
if (tmp && VRB_COLOR(tmp, field) == VRB_RED) { \
VRB_COLOR(tmp, field) = VRB_BLACK; \
VRB_SET_BLACKRED(parent, gparent, field);\
tmp = VRBT_LEFT(gparent, field); \
if (tmp && VRBT_COLOR(tmp, field) == VRBT_RED) { \
VRBT_COLOR(tmp, field) = VRBT_BLACK; \
VRBT_SET_BLACKRED(parent, gparent, field);\
elm = gparent; \
continue; \
} \
if (VRB_LEFT(parent, field) == elm) { \
VRB_ROTATE_RIGHT(head, parent, tmp, field);\
if (VRBT_LEFT(parent, field) == elm) { \
VRBT_ROTATE_RIGHT(head, parent, tmp, field);\
tmp = parent; \
parent = elm; \
elm = tmp; \
} \
VRB_SET_BLACKRED(parent, gparent, field); \
VRB_ROTATE_LEFT(head, gparent, tmp, field); \
VRBT_SET_BLACKRED(parent, gparent, field); \
VRBT_ROTATE_LEFT(head, gparent, tmp, field); \
} \
} \
VRB_COLOR(head->rbh_root, field) = VRB_BLACK; \
VRBT_COLOR(head->rbh_root, field) = VRBT_BLACK; \
} \
\
attr void \
name##_VRB_REMOVE_COLOR(struct name *head, struct type *parent, struct type *elm) \
name##_VRBT_REMOVE_COLOR(struct name *head, struct type *parent, struct type *elm) \
{ \
struct type *tmp; \
while ((elm == NULL || VRB_COLOR(elm, field) == VRB_BLACK) && \
elm != VRB_ROOT(head)) { \
while ((elm == NULL || VRBT_COLOR(elm, field) == VRBT_BLACK) && \
elm != VRBT_ROOT(head)) { \
AN(parent); \
if (VRB_LEFT(parent, field) == elm) { \
tmp = VRB_RIGHT(parent, field); \
if (VRB_COLOR(tmp, field) == VRB_RED) { \
VRB_SET_BLACKRED(tmp, parent, field); \
VRB_ROTATE_LEFT(head, parent, tmp, field);\
tmp = VRB_RIGHT(parent, field); \
if (VRBT_LEFT(parent, field) == elm) { \
tmp = VRBT_RIGHT(parent, field); \
if (VRBT_COLOR(tmp, field) == VRBT_RED) { \
VRBT_SET_BLACKRED(tmp, parent, field); \
VRBT_ROTATE_LEFT(head, parent, tmp, field);\
tmp = VRBT_RIGHT(parent, field); \
} \
if ((VRB_LEFT(tmp, field) == NULL || \
VRB_COLOR(VRB_LEFT(tmp, field), field) == VRB_BLACK) &&\
(VRB_RIGHT(tmp, field) == NULL || \
VRB_COLOR(VRB_RIGHT(tmp, field), field) == VRB_BLACK)) {\
VRB_COLOR(tmp, field) = VRB_RED; \
if ((VRBT_LEFT(tmp, field) == NULL || \
VRBT_COLOR(VRBT_LEFT(tmp, field), field) == VRBT_BLACK) &&\
(VRBT_RIGHT(tmp, field) == NULL || \
VRBT_COLOR(VRBT_RIGHT(tmp, field), field) == VRBT_BLACK)) {\
VRBT_COLOR(tmp, field) = VRBT_RED; \
elm = parent; \
parent = VRB_PARENT(elm, field); \
parent = VRBT_PARENT(elm, field); \
} else { \
if (VRB_RIGHT(tmp, field) == NULL || \
VRB_COLOR(VRB_RIGHT(tmp, field), field) == VRB_BLACK) {\
if (VRBT_RIGHT(tmp, field) == NULL || \
VRBT_COLOR(VRBT_RIGHT(tmp, field), field) == VRBT_BLACK) {\
struct type *oleft; \
if ((oleft = VRB_LEFT(tmp, field)) \
if ((oleft = VRBT_LEFT(tmp, field)) \
!= NULL) \
VRB_COLOR(oleft, field) = VRB_BLACK;\
VRB_COLOR(tmp, field) = VRB_RED;\
VRB_ROTATE_RIGHT(head, tmp, oleft, field);\
tmp = VRB_RIGHT(parent, field); \
VRBT_COLOR(oleft, field) = VRBT_BLACK;\
VRBT_COLOR(tmp, field) = VRBT_RED;\
VRBT_ROTATE_RIGHT(head, tmp, oleft, field);\
tmp = VRBT_RIGHT(parent, field); \
} \
VRB_COLOR(tmp, field) = VRB_COLOR(parent, field);\
VRB_COLOR(parent, field) = VRB_BLACK; \
if (VRB_RIGHT(tmp, field)) \
VRB_COLOR(VRB_RIGHT(tmp, field), field) = VRB_BLACK;\
VRB_ROTATE_LEFT(head, parent, tmp, field);\
elm = VRB_ROOT(head); \
VRBT_COLOR(tmp, field) = VRBT_COLOR(parent, field);\
VRBT_COLOR(parent, field) = VRBT_BLACK; \
if (VRBT_RIGHT(tmp, field)) \
VRBT_COLOR(VRBT_RIGHT(tmp, field), field) = VRBT_BLACK;\
VRBT_ROTATE_LEFT(head, parent, tmp, field);\
elm = VRBT_ROOT(head); \
break; \
} \
} else { \
tmp = VRB_LEFT(parent, field); \
if (VRB_COLOR(tmp, field) == VRB_RED) { \
VRB_SET_BLACKRED(tmp, parent, field); \
VRB_ROTATE_RIGHT(head, parent, tmp, field);\
tmp = VRB_LEFT(parent, field); \
tmp = VRBT_LEFT(parent, field); \
if (VRBT_COLOR(tmp, field) == VRBT_RED) { \
VRBT_SET_BLACKRED(tmp, parent, field); \
VRBT_ROTATE_RIGHT(head, parent, tmp, field);\
tmp = VRBT_LEFT(parent, field); \
} \
if ((VRB_LEFT(tmp, field) == NULL || \
VRB_COLOR(VRB_LEFT(tmp, field), field) == VRB_BLACK) &&\
(VRB_RIGHT(tmp, field) == NULL || \
VRB_COLOR(VRB_RIGHT(tmp, field), field) == VRB_BLACK)) {\
VRB_COLOR(tmp, field) = VRB_RED; \
if ((VRBT_LEFT(tmp, field) == NULL || \
VRBT_COLOR(VRBT_LEFT(tmp, field), field) == VRBT_BLACK) &&\
(VRBT_RIGHT(tmp, field) == NULL || \
VRBT_COLOR(VRBT_RIGHT(tmp, field), field) == VRBT_BLACK)) {\
VRBT_COLOR(tmp, field) = VRBT_RED; \
elm = parent; \
parent = VRB_PARENT(elm, field); \
parent = VRBT_PARENT(elm, field); \
} else { \
if (VRB_LEFT(tmp, field) == NULL || \
VRB_COLOR(VRB_LEFT(tmp, field), field) == VRB_BLACK) {\
if (VRBT_LEFT(tmp, field) == NULL || \
VRBT_COLOR(VRBT_LEFT(tmp, field), field) == VRBT_BLACK) {\
struct type *oright; \
if ((oright = VRB_RIGHT(tmp, field)) \
if ((oright = VRBT_RIGHT(tmp, field)) \
!= NULL) \
VRB_COLOR(oright, field) = VRB_BLACK;\
VRB_COLOR(tmp, field) = VRB_RED;\
VRB_ROTATE_LEFT(head, tmp, oright, field);\
tmp = VRB_LEFT(parent, field); \
VRBT_COLOR(oright, field) = VRBT_BLACK;\
VRBT_COLOR(tmp, field) = VRBT_RED;\
VRBT_ROTATE_LEFT(head, tmp, oright, field);\
tmp = VRBT_LEFT(parent, field); \
} \
VRB_COLOR(tmp, field) = VRB_COLOR(parent, field);\
VRB_COLOR(parent, field) = VRB_BLACK; \
if (VRB_LEFT(tmp, field)) \
VRB_COLOR(VRB_LEFT(tmp, field), field) = VRB_BLACK;\
VRB_ROTATE_RIGHT(head, parent, tmp, field);\
elm = VRB_ROOT(head); \
VRBT_COLOR(tmp, field) = VRBT_COLOR(parent, field);\
VRBT_COLOR(parent, field) = VRBT_BLACK; \
if (VRBT_LEFT(tmp, field)) \
VRBT_COLOR(VRBT_LEFT(tmp, field), field) = VRBT_BLACK;\
VRBT_ROTATE_RIGHT(head, parent, tmp, field);\
elm = VRBT_ROOT(head); \
break; \
} \
} \
} \
if (elm) \
VRB_COLOR(elm, field) = VRB_BLACK; \
VRBT_COLOR(elm, field) = VRBT_BLACK; \
} \
\
attr struct type * \
name##_VRB_REMOVE(struct name *head, struct type *elm) \
name##_VRBT_REMOVE(struct name *head, struct type *elm) \
{ \
struct type *child, *parent, *old = elm; \
int color; \
if (VRB_LEFT(elm, field) == NULL) \
child = VRB_RIGHT(elm, field); \
else if (VRB_RIGHT(elm, field) == NULL) \
child = VRB_LEFT(elm, field); \
if (VRBT_LEFT(elm, field) == NULL) \
child = VRBT_RIGHT(elm, field); \
else if (VRBT_RIGHT(elm, field) == NULL) \
child = VRBT_LEFT(elm, field); \
else { \
struct type *left; \
elm = VRB_RIGHT(elm, field); \
while ((left = VRB_LEFT(elm, field)) != NULL) \
elm = VRBT_RIGHT(elm, field); \
while ((left = VRBT_LEFT(elm, field)) != NULL) \
elm = left; \
child = VRB_RIGHT(elm, field); \
parent = VRB_PARENT(elm, field); \
color = VRB_COLOR(elm, field); \
child = VRBT_RIGHT(elm, field); \
parent = VRBT_PARENT(elm, field); \
color = VRBT_COLOR(elm, field); \
if (child) \
VRB_PARENT(child, field) = parent; \
VRBT_PARENT(child, field) = parent; \
if (parent) { \
if (VRB_LEFT(parent, field) == elm) \
VRB_LEFT(parent, field) = child; \
if (VRBT_LEFT(parent, field) == elm) \
VRBT_LEFT(parent, field) = child; \
else \
VRB_RIGHT(parent, field) = child; \
VRB_AUGMENT(parent); \
VRBT_RIGHT(parent, field) = child; \
VRBT_AUGMENT(parent); \
} else \
VRB_ROOT(head) = child; \
if (VRB_PARENT(elm, field) == old) \
VRBT_ROOT(head) = child; \
if (VRBT_PARENT(elm, field) == old) \
parent = elm; \
(elm)->field = (old)->field; \
if (VRB_PARENT(old, field)) { \
if (VRB_LEFT(VRB_PARENT(old, field), field) == old)\
VRB_LEFT(VRB_PARENT(old, field), field) = elm;\
if (VRBT_PARENT(old, field)) { \
if (VRBT_LEFT(VRBT_PARENT(old, field), field) == old)\
VRBT_LEFT(VRBT_PARENT(old, field), field) = elm;\
else \
VRB_RIGHT(VRB_PARENT(old, field), field) = elm;\
VRB_AUGMENT(VRB_PARENT(old, field)); \
VRBT_RIGHT(VRBT_PARENT(old, field), field) = elm;\
VRBT_AUGMENT(VRBT_PARENT(old, field)); \
} else \
VRB_ROOT(head) = elm; \
VRB_PARENT(VRB_LEFT(old, field), field) = elm; \
if (VRB_RIGHT(old, field)) \
VRB_PARENT(VRB_RIGHT(old, field), field) = elm; \
VRBT_ROOT(head) = elm; \
VRBT_PARENT(VRBT_LEFT(old, field), field) = elm; \
if (VRBT_RIGHT(old, field)) \
VRBT_PARENT(VRBT_RIGHT(old, field), field) = elm; \
if (parent) { \
left = parent; \
do { \
VRB_AUGMENT(left); \
} while ((left = VRB_PARENT(left, field)) != NULL); \
VRBT_AUGMENT(left); \
} while ((left = VRBT_PARENT(left, field)) != NULL); \
} \
goto color; \
} \
parent = VRB_PARENT(elm, field); \
color = VRB_COLOR(elm, field); \
parent = VRBT_PARENT(elm, field); \
color = VRBT_COLOR(elm, field); \
if (child) \
VRB_PARENT(child, field) = parent; \
VRBT_PARENT(child, field) = parent; \
if (parent) { \
if (VRB_LEFT(parent, field) == elm) \
VRB_LEFT(parent, field) = child; \
if (VRBT_LEFT(parent, field) == elm) \
VRBT_LEFT(parent, field) = child; \
else \
VRB_RIGHT(parent, field) = child; \
VRB_AUGMENT(parent); \
VRBT_RIGHT(parent, field) = child; \
VRBT_AUGMENT(parent); \
} else \
VRB_ROOT(head) = child; \
VRBT_ROOT(head) = child; \
color: \
if (color == VRB_BLACK) { \
name##_VRB_REMOVE_COLOR(head, parent, child); \
if (color == VRBT_BLACK) { \
name##_VRBT_REMOVE_COLOR(head, parent, child); \
} \
return (old); \
} \
\
/* Inserts a node into the RB tree */ \
attr struct type * \
name##_VRB_INSERT(struct name *head, struct type *elm) \
name##_VRBT_INSERT(struct name *head, struct type *elm) \
{ \
struct type *tmp; \
struct type *parent = NULL; \
int comp = 0; \
tmp = VRB_ROOT(head); \
tmp = VRBT_ROOT(head); \
while (tmp) { \
parent = tmp; \
comp = (cmp)(elm, parent); \
if (comp < 0) \
tmp = VRB_LEFT(tmp, field); \
tmp = VRBT_LEFT(tmp, field); \
else if (comp > 0) \
tmp = VRB_RIGHT(tmp, field); \
tmp = VRBT_RIGHT(tmp, field); \
else \
return (tmp); \
} \
VRB_SET(elm, parent, field); \
VRBT_SET(elm, parent, field); \
if (parent != NULL) { \
if (comp < 0) \
VRB_LEFT(parent, field) = elm; \
VRBT_LEFT(parent, field) = elm; \
else \
VRB_RIGHT(parent, field) = elm; \
VRB_AUGMENT(parent); \
VRBT_RIGHT(parent, field) = elm; \
VRBT_AUGMENT(parent); \
} else \
VRB_ROOT(head) = elm; \
name##_VRB_INSERT_COLOR(head, elm); \
VRBT_ROOT(head) = elm; \
name##_VRBT_INSERT_COLOR(head, elm); \
return (NULL); \
} \
\
/* Finds the node with the same key as elm */ \
attr struct type * \
name##_VRB_FIND(const struct name *head, const struct type *elm) \
name##_VRBT_FIND(const struct name *head, const struct type *elm) \
{ \
struct type *tmp = VRB_ROOT(head); \
struct type *tmp = VRBT_ROOT(head); \
int comp; \
while (tmp) { \
comp = cmp(elm, tmp); \
if (comp < 0) \
tmp = VRB_LEFT(tmp, field); \
tmp = VRBT_LEFT(tmp, field); \
else if (comp > 0) \
tmp = VRB_RIGHT(tmp, field); \
tmp = VRBT_RIGHT(tmp, field); \
else \
return (tmp); \
} \
......@@ -643,19 +643,19 @@ name##_VRB_FIND(const struct name *head, const struct type *elm) \
\
/* Finds the first node greater than or equal to the search key */ \
attr struct type * \
name##_VRB_NFIND(const struct name *head, const struct type *elm) \
name##_VRBT_NFIND(const struct name *head, const struct type *elm) \
{ \
struct type *tmp = VRB_ROOT(head); \
struct type *tmp = VRBT_ROOT(head); \
struct type *res = NULL; \
int comp; \
while (tmp) { \
comp = cmp(elm, tmp); \
if (comp < 0) { \
res = tmp; \
tmp = VRB_LEFT(tmp, field); \
tmp = VRBT_LEFT(tmp, field); \
} \
else if (comp > 0) \
tmp = VRB_RIGHT(tmp, field); \
tmp = VRBT_RIGHT(tmp, field); \
else \
return (tmp); \
} \
......@@ -664,21 +664,21 @@ name##_VRB_NFIND(const struct name *head, const struct type *elm) \
\
/* ARGSUSED */ \
attr struct type * \
name##_VRB_NEXT(struct type *elm) \
name##_VRBT_NEXT(struct type *elm) \
{ \
if (VRB_RIGHT(elm, field)) { \
elm = VRB_RIGHT(elm, field); \
while (VRB_LEFT(elm, field)) \
elm = VRB_LEFT(elm, field); \
if (VRBT_RIGHT(elm, field)) { \
elm = VRBT_RIGHT(elm, field); \
while (VRBT_LEFT(elm, field)) \
elm = VRBT_LEFT(elm, field); \
} else { \
if (VRB_PARENT(elm, field) && \
(elm == VRB_LEFT(VRB_PARENT(elm, field), field))) \
elm = VRB_PARENT(elm, field); \
if (VRBT_PARENT(elm, field) && \
(elm == VRBT_LEFT(VRBT_PARENT(elm, field), field))) \
elm = VRBT_PARENT(elm, field); \
else { \
while (VRB_PARENT(elm, field) && \
(elm == VRB_RIGHT(VRB_PARENT(elm, field), field)))\
elm = VRB_PARENT(elm, field); \
elm = VRB_PARENT(elm, field); \
while (VRBT_PARENT(elm, field) && \
(elm == VRBT_RIGHT(VRBT_PARENT(elm, field), field)))\
elm = VRBT_PARENT(elm, field); \
elm = VRBT_PARENT(elm, field); \
} \
} \
return (elm); \
......@@ -686,81 +686,81 @@ name##_VRB_NEXT(struct type *elm) \
\
/* ARGSUSED */ \
attr struct type * \
name##_VRB_PREV(struct type *elm) \
name##_VRBT_PREV(struct type *elm) \
{ \
if (VRB_LEFT(elm, field)) { \
elm = VRB_LEFT(elm, field); \
while (VRB_RIGHT(elm, field)) \
elm = VRB_RIGHT(elm, field); \
if (VRBT_LEFT(elm, field)) { \
elm = VRBT_LEFT(elm, field); \
while (VRBT_RIGHT(elm, field)) \
elm = VRBT_RIGHT(elm, field); \
} else { \
if (VRB_PARENT(elm, field) && \
(elm == VRB_RIGHT(VRB_PARENT(elm, field), field))) \
elm = VRB_PARENT(elm, field); \
if (VRBT_PARENT(elm, field) && \
(elm == VRBT_RIGHT(VRBT_PARENT(elm, field), field))) \
elm = VRBT_PARENT(elm, field); \
else { \
while (VRB_PARENT(elm, field) && \
(elm == VRB_LEFT(VRB_PARENT(elm, field), field)))\
elm = VRB_PARENT(elm, field); \
elm = VRB_PARENT(elm, field); \
while (VRBT_PARENT(elm, field) && \
(elm == VRBT_LEFT(VRBT_PARENT(elm, field), field)))\
elm = VRBT_PARENT(elm, field); \
elm = VRBT_PARENT(elm, field); \
} \
} \
return (elm); \
} \
\
attr struct type * \
name##_VRB_MINMAX(const struct name *head, int val) \
name##_VRBT_MINMAX(const struct name *head, int val) \
{ \
struct type *tmp = VRB_ROOT(head); \
struct type *tmp = VRBT_ROOT(head); \
struct type *parent = NULL; \
while (tmp) { \
parent = tmp; \
if (val < 0) \
tmp = VRB_LEFT(tmp, field); \
tmp = VRBT_LEFT(tmp, field); \
else \
tmp = VRB_RIGHT(tmp, field); \
tmp = VRBT_RIGHT(tmp, field); \
} \
return (parent); \
}
#define VRB_NEGINF -1
#define VRB_INF 1
#define VRBT_NEGINF -1
#define VRBT_INF 1
#define VRB_INSERT(name, x, y) name##_VRB_INSERT(x, y)
#define VRB_REMOVE(name, x, y) name##_VRB_REMOVE(x, y)
#define VRB_FIND(name, x, y) name##_VRB_FIND(x, y)
#define VRB_NFIND(name, x, y) name##_VRB_NFIND(x, y)
#define VRB_NEXT(name, x, y) name##_VRB_NEXT(y)
#define VRB_PREV(name, x, y) name##_VRB_PREV(y)
#define VRB_MIN(name, x) name##_VRB_MINMAX(x, VRB_NEGINF)
#define VRB_MAX(name, x) name##_VRB_MINMAX(x, VRB_INF)
#define VRBT_INSERT(name, x, y) name##_VRBT_INSERT(x, y)
#define VRBT_REMOVE(name, x, y) name##_VRBT_REMOVE(x, y)
#define VRBT_FIND(name, x, y) name##_VRBT_FIND(x, y)
#define VRBT_NFIND(name, x, y) name##_VRBT_NFIND(x, y)
#define VRBT_NEXT(name, x, y) name##_VRBT_NEXT(y)
#define VRBT_PREV(name, x, y) name##_VRBT_PREV(y)
#define VRBT_MIN(name, x) name##_VRBT_MINMAX(x, VRBT_NEGINF)
#define VRBT_MAX(name, x) name##_VRBT_MINMAX(x, VRBT_INF)
#define VRB_FOREACH(x, name, head) \
for ((x) = VRB_MIN(name, head); \
#define VRBT_FOREACH(x, name, head) \
for ((x) = VRBT_MIN(name, head); \
(x) != NULL; \
(x) = name##_VRB_NEXT(x))
(x) = name##_VRBT_NEXT(x))
#define VRB_FOREACH_FROM(x, name, y) \
#define VRBT_FOREACH_FROM(x, name, y) \
for ((x) = (y); \
((x) != NULL) && ((y) = name##_VRB_NEXT(x), (x) != NULL); \
((x) != NULL) && ((y) = name##_VRBT_NEXT(x), (x) != NULL); \
(x) = (y))
#define VRB_FOREACH_SAFE(x, name, head, y) \
for ((x) = VRB_MIN(name, head); \
((x) != NULL) && ((y) = name##_VRB_NEXT(x), (x) != NULL); \
#define VRBT_FOREACH_SAFE(x, name, head, y) \
for ((x) = VRBT_MIN(name, head); \
((x) != NULL) && ((y) = name##_VRBT_NEXT(x), (x) != NULL); \
(x) = (y))
#define VRB_FOREACH_REVERSE(x, name, head) \
for ((x) = VRB_MAX(name, head); \
#define VRBT_FOREACH_REVERSE(x, name, head) \
for ((x) = VRBT_MAX(name, head); \
(x) != NULL; \
(x) = name##_VRB_PREV(x))
(x) = name##_VRBT_PREV(x))
#define VRB_FOREACH_REVERSE_FROM(x, name, y) \
#define VRBT_FOREACH_REVERSE_FROM(x, name, y) \
for ((x) = (y); \
((x) != NULL) && ((y) = name##_VRB_PREV(x), (x) != NULL); \
((x) != NULL) && ((y) = name##_VRBT_PREV(x), (x) != NULL); \
(x) = (y))
#define VRB_FOREACH_REVERSE_SAFE(x, name, head, y) \
for ((x) = VRB_MAX(name, head); \
((x) != NULL) && ((y) = name##_VRB_PREV(x), (x) != NULL); \
#define VRBT_FOREACH_REVERSE_SAFE(x, name, head, y) \
for ((x) = VRBT_MAX(name, head); \
((x) != NULL) && ((y) = name##_VRBT_PREV(x), (x) != NULL); \
(x) = (y))
#endif /* _VTREE_H_ */
lib/libvarnishapi/vsl_dispatch.c
View file @ 08d8a294
......@@ -135,9 +135,9 @@ struct vslc_vtx {
struct vtx_key {
unsigned vxid;
VRB_ENTRY(vtx_key) entry;
VRBT_ENTRY(vtx_key) entry;
};
VRB_HEAD(vtx_tree, vtx_key);
VRBT_HEAD(vtx_tree, vtx_key);
struct vtx {
struct vtx_key key;
......@@ -222,8 +222,8 @@ vtx_keycmp(const struct vtx_key *a, const struct vtx_key *b)
return (0);
}
VRB_PROTOTYPE_STATIC(vtx_tree, vtx_key, entry, vtx_keycmp)
VRB_GENERATE_STATIC(vtx_tree, vtx_key, entry, vtx_keycmp)
VRBT_PROTOTYPE_STATIC(vtx_tree, vtx_key, entry, vtx_keycmp)
VRBT_GENERATE_STATIC(vtx_tree, vtx_key, entry, vtx_keycmp)
static enum vsl_status v_matchproto_(vslc_next_f)
vslc_raw_next(const struct VSL_cursor *cursor)
......@@ -549,7 +549,7 @@ vtx_retire(struct VSLQ *vslq, struct vtx **pvtx)
AZ(vtx->n_child);
AZ(vtx->n_descend);
vtx->n_childready = 0;
AN(VRB_REMOVE(vtx_tree, &vslq->tree, &vtx->key));
AN(VRBT_REMOVE(vtx_tree, &vslq->tree, &vtx->key));
vtx->key.vxid = 0;
vtx->flags = 0;
......@@ -594,7 +594,7 @@ vtx_lookup(const struct VSLQ *vslq, unsigned vxid)
AN(vslq);
lkey.vxid = vxid;
key = VRB_FIND(vtx_tree, &vslq->tree, &lkey);
key = VRBT_FIND(vtx_tree, &vslq->tree, &lkey);
if (key == NULL)
return (NULL);
CAST_OBJ_NOTNULL(vtx, (void *)key, VTX_MAGIC);
......@@ -611,7 +611,7 @@ vtx_add(struct VSLQ *vslq, unsigned vxid)
vtx = vtx_new(vslq);
AN(vtx);
vtx->key.vxid = vxid;
AZ(VRB_INSERT(vtx_tree, &vslq->tree, &vtx->key));
AZ(VRBT_INSERT(vtx_tree, &vslq->tree, &vtx->key));
VTAILQ_INSERT_TAIL(&vslq->incomplete, vtx, list_vtx);
vslq->n_outstanding++;
return (vtx);
......@@ -1080,7 +1080,7 @@ VSLQ_New(struct VSL_data *vsl, struct VSL_cursor **cp,
vslq->query = query;
/* Setup normal mode */
VRB_INIT(&vslq->tree);
VRBT_INIT(&vslq->tree);
VTAILQ_INIT(&vslq->ready);
VTAILQ_INIT(&vslq->incomplete);
VTAILQ_INIT(&vslq->shmrefs);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment