mirror of
https://github.com/nginx/nginx.git
synced 2024-12-15 21:39:00 +08:00
baa239c487
Integer overflow is undefined behaviour in C and this indeed caused problems on Solaris/SPARC (at least in some cases). Fix is to subtract unsigned integers instead, and then cast result to a signed one, which is implementation-defined behaviour and used to work. Strictly speaking, we should compare (unsigned) result with the maximum value of the corresponding signed integer type instead, this will be defined behaviour. This will require much more changes though, and considered to be overkill for now.
383 lines
8.8 KiB
C
383 lines
8.8 KiB
C
|
|
/*
|
|
* Copyright (C) Igor Sysoev
|
|
* Copyright (C) Nginx, Inc.
|
|
*/
|
|
|
|
|
|
#include <ngx_config.h>
|
|
#include <ngx_core.h>
|
|
|
|
|
|
/*
|
|
* The red-black tree code is based on the algorithm described in
|
|
* the "Introduction to Algorithms" by Cormen, Leiserson and Rivest.
|
|
*/
|
|
|
|
|
|
static ngx_inline void ngx_rbtree_left_rotate(ngx_rbtree_node_t **root,
|
|
ngx_rbtree_node_t *sentinel, ngx_rbtree_node_t *node);
|
|
static ngx_inline void ngx_rbtree_right_rotate(ngx_rbtree_node_t **root,
|
|
ngx_rbtree_node_t *sentinel, ngx_rbtree_node_t *node);
|
|
|
|
|
|
void
|
|
ngx_rbtree_insert(ngx_thread_volatile ngx_rbtree_t *tree,
|
|
ngx_rbtree_node_t *node)
|
|
{
|
|
ngx_rbtree_node_t **root, *temp, *sentinel;
|
|
|
|
/* a binary tree insert */
|
|
|
|
root = (ngx_rbtree_node_t **) &tree->root;
|
|
sentinel = tree->sentinel;
|
|
|
|
if (*root == sentinel) {
|
|
node->parent = NULL;
|
|
node->left = sentinel;
|
|
node->right = sentinel;
|
|
ngx_rbt_black(node);
|
|
*root = node;
|
|
|
|
return;
|
|
}
|
|
|
|
tree->insert(*root, node, sentinel);
|
|
|
|
/* re-balance tree */
|
|
|
|
while (node != *root && ngx_rbt_is_red(node->parent)) {
|
|
|
|
if (node->parent == node->parent->parent->left) {
|
|
temp = node->parent->parent->right;
|
|
|
|
if (ngx_rbt_is_red(temp)) {
|
|
ngx_rbt_black(node->parent);
|
|
ngx_rbt_black(temp);
|
|
ngx_rbt_red(node->parent->parent);
|
|
node = node->parent->parent;
|
|
|
|
} else {
|
|
if (node == node->parent->right) {
|
|
node = node->parent;
|
|
ngx_rbtree_left_rotate(root, sentinel, node);
|
|
}
|
|
|
|
ngx_rbt_black(node->parent);
|
|
ngx_rbt_red(node->parent->parent);
|
|
ngx_rbtree_right_rotate(root, sentinel, node->parent->parent);
|
|
}
|
|
|
|
} else {
|
|
temp = node->parent->parent->left;
|
|
|
|
if (ngx_rbt_is_red(temp)) {
|
|
ngx_rbt_black(node->parent);
|
|
ngx_rbt_black(temp);
|
|
ngx_rbt_red(node->parent->parent);
|
|
node = node->parent->parent;
|
|
|
|
} else {
|
|
if (node == node->parent->left) {
|
|
node = node->parent;
|
|
ngx_rbtree_right_rotate(root, sentinel, node);
|
|
}
|
|
|
|
ngx_rbt_black(node->parent);
|
|
ngx_rbt_red(node->parent->parent);
|
|
ngx_rbtree_left_rotate(root, sentinel, node->parent->parent);
|
|
}
|
|
}
|
|
}
|
|
|
|
ngx_rbt_black(*root);
|
|
}
|
|
|
|
|
|
void
|
|
ngx_rbtree_insert_value(ngx_rbtree_node_t *temp, ngx_rbtree_node_t *node,
|
|
ngx_rbtree_node_t *sentinel)
|
|
{
|
|
ngx_rbtree_node_t **p;
|
|
|
|
for ( ;; ) {
|
|
|
|
p = (node->key < temp->key) ? &temp->left : &temp->right;
|
|
|
|
if (*p == sentinel) {
|
|
break;
|
|
}
|
|
|
|
temp = *p;
|
|
}
|
|
|
|
*p = node;
|
|
node->parent = temp;
|
|
node->left = sentinel;
|
|
node->right = sentinel;
|
|
ngx_rbt_red(node);
|
|
}
|
|
|
|
|
|
void
|
|
ngx_rbtree_insert_timer_value(ngx_rbtree_node_t *temp, ngx_rbtree_node_t *node,
|
|
ngx_rbtree_node_t *sentinel)
|
|
{
|
|
ngx_rbtree_node_t **p;
|
|
|
|
for ( ;; ) {
|
|
|
|
/*
|
|
* Timer values
|
|
* 1) are spread in small range, usually several minutes,
|
|
* 2) and overflow each 49 days, if milliseconds are stored in 32 bits.
|
|
* The comparison takes into account that overflow.
|
|
*/
|
|
|
|
/* node->key < temp->key */
|
|
|
|
p = ((ngx_rbtree_key_int_t) (node->key - temp->key) < 0)
|
|
? &temp->left : &temp->right;
|
|
|
|
if (*p == sentinel) {
|
|
break;
|
|
}
|
|
|
|
temp = *p;
|
|
}
|
|
|
|
*p = node;
|
|
node->parent = temp;
|
|
node->left = sentinel;
|
|
node->right = sentinel;
|
|
ngx_rbt_red(node);
|
|
}
|
|
|
|
|
|
void
|
|
ngx_rbtree_delete(ngx_thread_volatile ngx_rbtree_t *tree,
|
|
ngx_rbtree_node_t *node)
|
|
{
|
|
ngx_uint_t red;
|
|
ngx_rbtree_node_t **root, *sentinel, *subst, *temp, *w;
|
|
|
|
/* a binary tree delete */
|
|
|
|
root = (ngx_rbtree_node_t **) &tree->root;
|
|
sentinel = tree->sentinel;
|
|
|
|
if (node->left == sentinel) {
|
|
temp = node->right;
|
|
subst = node;
|
|
|
|
} else if (node->right == sentinel) {
|
|
temp = node->left;
|
|
subst = node;
|
|
|
|
} else {
|
|
subst = ngx_rbtree_min(node->right, sentinel);
|
|
|
|
if (subst->left != sentinel) {
|
|
temp = subst->left;
|
|
} else {
|
|
temp = subst->right;
|
|
}
|
|
}
|
|
|
|
if (subst == *root) {
|
|
*root = temp;
|
|
ngx_rbt_black(temp);
|
|
|
|
/* DEBUG stuff */
|
|
node->left = NULL;
|
|
node->right = NULL;
|
|
node->parent = NULL;
|
|
node->key = 0;
|
|
|
|
return;
|
|
}
|
|
|
|
red = ngx_rbt_is_red(subst);
|
|
|
|
if (subst == subst->parent->left) {
|
|
subst->parent->left = temp;
|
|
|
|
} else {
|
|
subst->parent->right = temp;
|
|
}
|
|
|
|
if (subst == node) {
|
|
|
|
temp->parent = subst->parent;
|
|
|
|
} else {
|
|
|
|
if (subst->parent == node) {
|
|
temp->parent = subst;
|
|
|
|
} else {
|
|
temp->parent = subst->parent;
|
|
}
|
|
|
|
subst->left = node->left;
|
|
subst->right = node->right;
|
|
subst->parent = node->parent;
|
|
ngx_rbt_copy_color(subst, node);
|
|
|
|
if (node == *root) {
|
|
*root = subst;
|
|
|
|
} else {
|
|
if (node == node->parent->left) {
|
|
node->parent->left = subst;
|
|
} else {
|
|
node->parent->right = subst;
|
|
}
|
|
}
|
|
|
|
if (subst->left != sentinel) {
|
|
subst->left->parent = subst;
|
|
}
|
|
|
|
if (subst->right != sentinel) {
|
|
subst->right->parent = subst;
|
|
}
|
|
}
|
|
|
|
/* DEBUG stuff */
|
|
node->left = NULL;
|
|
node->right = NULL;
|
|
node->parent = NULL;
|
|
node->key = 0;
|
|
|
|
if (red) {
|
|
return;
|
|
}
|
|
|
|
/* a delete fixup */
|
|
|
|
while (temp != *root && ngx_rbt_is_black(temp)) {
|
|
|
|
if (temp == temp->parent->left) {
|
|
w = temp->parent->right;
|
|
|
|
if (ngx_rbt_is_red(w)) {
|
|
ngx_rbt_black(w);
|
|
ngx_rbt_red(temp->parent);
|
|
ngx_rbtree_left_rotate(root, sentinel, temp->parent);
|
|
w = temp->parent->right;
|
|
}
|
|
|
|
if (ngx_rbt_is_black(w->left) && ngx_rbt_is_black(w->right)) {
|
|
ngx_rbt_red(w);
|
|
temp = temp->parent;
|
|
|
|
} else {
|
|
if (ngx_rbt_is_black(w->right)) {
|
|
ngx_rbt_black(w->left);
|
|
ngx_rbt_red(w);
|
|
ngx_rbtree_right_rotate(root, sentinel, w);
|
|
w = temp->parent->right;
|
|
}
|
|
|
|
ngx_rbt_copy_color(w, temp->parent);
|
|
ngx_rbt_black(temp->parent);
|
|
ngx_rbt_black(w->right);
|
|
ngx_rbtree_left_rotate(root, sentinel, temp->parent);
|
|
temp = *root;
|
|
}
|
|
|
|
} else {
|
|
w = temp->parent->left;
|
|
|
|
if (ngx_rbt_is_red(w)) {
|
|
ngx_rbt_black(w);
|
|
ngx_rbt_red(temp->parent);
|
|
ngx_rbtree_right_rotate(root, sentinel, temp->parent);
|
|
w = temp->parent->left;
|
|
}
|
|
|
|
if (ngx_rbt_is_black(w->left) && ngx_rbt_is_black(w->right)) {
|
|
ngx_rbt_red(w);
|
|
temp = temp->parent;
|
|
|
|
} else {
|
|
if (ngx_rbt_is_black(w->left)) {
|
|
ngx_rbt_black(w->right);
|
|
ngx_rbt_red(w);
|
|
ngx_rbtree_left_rotate(root, sentinel, w);
|
|
w = temp->parent->left;
|
|
}
|
|
|
|
ngx_rbt_copy_color(w, temp->parent);
|
|
ngx_rbt_black(temp->parent);
|
|
ngx_rbt_black(w->left);
|
|
ngx_rbtree_right_rotate(root, sentinel, temp->parent);
|
|
temp = *root;
|
|
}
|
|
}
|
|
}
|
|
|
|
ngx_rbt_black(temp);
|
|
}
|
|
|
|
|
|
static ngx_inline void
|
|
ngx_rbtree_left_rotate(ngx_rbtree_node_t **root, ngx_rbtree_node_t *sentinel,
|
|
ngx_rbtree_node_t *node)
|
|
{
|
|
ngx_rbtree_node_t *temp;
|
|
|
|
temp = node->right;
|
|
node->right = temp->left;
|
|
|
|
if (temp->left != sentinel) {
|
|
temp->left->parent = node;
|
|
}
|
|
|
|
temp->parent = node->parent;
|
|
|
|
if (node == *root) {
|
|
*root = temp;
|
|
|
|
} else if (node == node->parent->left) {
|
|
node->parent->left = temp;
|
|
|
|
} else {
|
|
node->parent->right = temp;
|
|
}
|
|
|
|
temp->left = node;
|
|
node->parent = temp;
|
|
}
|
|
|
|
|
|
static ngx_inline void
|
|
ngx_rbtree_right_rotate(ngx_rbtree_node_t **root, ngx_rbtree_node_t *sentinel,
|
|
ngx_rbtree_node_t *node)
|
|
{
|
|
ngx_rbtree_node_t *temp;
|
|
|
|
temp = node->left;
|
|
node->left = temp->right;
|
|
|
|
if (temp->right != sentinel) {
|
|
temp->right->parent = node;
|
|
}
|
|
|
|
temp->parent = node->parent;
|
|
|
|
if (node == *root) {
|
|
*root = temp;
|
|
|
|
} else if (node == node->parent->right) {
|
|
node->parent->right = temp;
|
|
|
|
} else {
|
|
node->parent->left = temp;
|
|
}
|
|
|
|
temp->right = node;
|
|
node->parent = temp;
|
|
}
|