/** @brief Validate and fix-up tree properties for a new insert/colored node * * This routine checks and fixes the Red-Black Tree properties based on * @a the_node being just added to the tree. * * @note It does NOT disable interrupts to ensure the atomicity of the * append operation. */ static void _RBTree_Validate_insert( RBTree_Node *the_node ) { RBTree_Node *parent = _RBTree_Parent( the_node ); RBTree_Color parentcolor; RBTree_Node *grandparent = _RBTree_Parent_and_color( parent, &parentcolor ); /* note: the insert root case is handled already */ /* if the parent is black, nothing needs to be done * otherwise may need to loop a few times */ while ( parentcolor == RBT_RED ) { /* The root is black, so the grandparent must exist */ RBTree_Node *uncle = _RBTree_Sibling( parent, grandparent ); RBTree_Node *grandgrandparent = _RBTree_Parent( grandparent ); /* * If uncle exists and is red, repaint uncle/parent black and grandparent * red. */ if ( uncle != NULL && _RBTree_Color( uncle ) == RBT_RED ) { _RBTree_Set_parent_and_color( parent, grandparent, RBT_BLACK ); _RBTree_Set_parent_and_color( uncle, grandparent, RBT_BLACK ); _RBTree_Set_parent_and_color( grandparent, grandgrandparent, RBT_RED ); the_node = grandparent; parent = grandgrandparent; grandparent = _RBTree_Parent_and_color( parent, &parentcolor ); if ( grandparent == NULL ) break; } else { /* If uncle does not exist or is black */ RBTree_Direction dir = _RBTree_Direction( the_node, parent ); RBTree_Direction parentdir = _RBTree_Direction( parent, grandparent ); /* ensure node is on the same branch direction as parent */ if ( dir != parentdir ) { RBTree_Node *oldparent = parent; parent = the_node; the_node = oldparent; _RBTree_Rotate( oldparent, parentdir ); } _RBTree_Set_color( parent, RBT_BLACK ); _RBTree_Set_parent_and_color( grandparent, grandgrandparent, RBT_RED ); /* now rotate grandparent in the other branch direction (toward uncle) */ _RBTree_Rotate( grandparent, _RBTree_Opposite_direction( parentdir ) ); grandparent = _RBTree_Parent( parent ); break; } } if ( grandparent == NULL ) _RBTree_Set_parent_and_color( the_node, parent, RBT_BLACK ); }
/** @brief Validate and fix-up tree properties for a new insert/colored node * * This routine checks and fixes the Red-Black Tree properties based on * @a the_node being just added to the tree. * * @note It does NOT disable interrupts to ensure the atomicity of the * append operation. */ void _RBTree_Validate_insert_unprotected( RBTree_Node *the_node ) { RBTree_Node *u,*g; /* note: the insert root case is handled already */ /* if the parent is black, nothing needs to be done * otherwise may need to loop a few times */ while (_RBTree_Is_red(_RBTree_Parent(the_node))) { u = _RBTree_Parent_sibling(the_node); g = the_node->parent->parent; /* if uncle is red, repaint uncle/parent black and grandparent red */ if(_RBTree_Is_red(u)) { the_node->parent->color = RBT_BLACK; u->color = RBT_BLACK; g->color = RBT_RED; the_node = g; } else { /* if uncle is black */ RBTree_Direction dir = the_node != the_node->parent->child[0]; RBTree_Direction pdir = the_node->parent != g->child[0]; /* ensure node is on the same branch direction as parent */ if (dir != pdir) { _RBTree_Rotate(the_node->parent, pdir); the_node = the_node->child[pdir]; } the_node->parent->color = RBT_BLACK; g->color = RBT_RED; /* now rotate grandparent in the other branch direction (toward uncle) */ _RBTree_Rotate(g, (1-pdir)); } } if(!the_node->parent->parent) the_node->color = RBT_BLACK; }
rtems_task Init( rtems_task_argument ignored ) { rtems_rbtree_control rbtree1; rtems_rbtree_node *p; test_node node1, node2; test_node node_array[100]; test_node search_node; int id; int i; puts( "\n\n*** TEST OF RTEMS RBTREE API ***" ); puts( "Init - Initialize rbtree empty" ); rtems_rbtree_initialize_empty( &rbtree1, &test_compare_function, true ); if ( !rtems_rbtree_is_unique( &rbtree1 ) ) puts( "INIT - FAILED IS UNIQUE CHECK" ); if ( rtems_rbtree_is_unique( NULL ) ) puts( "INIT - FAILED IS UNIQUE CHECK" ); /* verify that the rbtree insert work */ puts( "INIT - Verify rtems_rbtree_insert with two nodes" ); node1.id = 1; node1.key = 1; node2.id = 2; node2.key = 2; rtems_rbtree_insert( &rbtree1, &node1.Node ); rtems_rbtree_insert( &rbtree1, &node2.Node ); p = rtems_rbtree_insert( &rbtree1, NULL ); if (p != (void *)(-1)) puts( "INIT - FAILED NULL NODE INSERT" ); _RBTree_Rotate(NULL, RBT_LEFT); i = (node1.Node.parent == &node2.Node); _RBTree_Rotate( &node1.Node, !node1.Node.child[RBT_LEFT] ? RBT_RIGHT : RBT_LEFT ); if ( (node1.Node.parent == &node2.Node) != i ) puts( "INIT - FAILED FALSE ROTATION" ); if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); for ( p = rtems_rbtree_get_min(&rbtree1), id = 1 ; p ; p = rtems_rbtree_get_min(&rbtree1) , id++ ) { test_node *t = rtems_rbtree_container_of(p,test_node,Node); if ( id > 2 ) { puts( "INIT - TOO MANY NODES ON RBTREE" ); rtems_test_exit(0); } if ( t->id != id ) { puts( "INIT - ERROR ON RBTREE ID MISMATCH" ); rtems_test_exit(0); } if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } if (id < 2) { puts("INIT - NOT ENOUGH NODES ON RBTREE"); rtems_test_exit(0); } puts("INIT - Verify rtems_rbtree_insert with the same value twice"); node2.key = node1.key; rtems_rbtree_insert(&rbtree1, &node1.Node); p = rtems_rbtree_insert(&rbtree1, &node2.Node); if (p != &node1.Node) puts( "INIT - FAILED DUPLICATE INSERT" ); for ( p = rtems_rbtree_get_min(&rbtree1), id = 1 ; p ; p = rtems_rbtree_get_min(&rbtree1) , id++ ) { test_node *t = rtems_rbtree_container_of(p,test_node,Node); if ( id > 1 ) { puts( "INIT - TOO MANY NODES ON RBTREE" ); rtems_test_exit(0); } if ( t->id != id ) { puts( "INIT - ERROR ON RBTREE ID MISMATCH" ); rtems_test_exit(0); } if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } if (id < 1) { puts("INIT - NOT ENOUGH NODES ON RBTREE"); rtems_test_exit(0); } node2.key = 2; /* verify that the rbtree is empty */ puts( "INIT - Verify rtems_rbtree_is_empty" ); if(!rtems_rbtree_is_empty(&rbtree1)) { puts( "INIT - TREE NOT EMPTY" ); rtems_test_exit(0); } puts( "INIT - Verify rtems_XXX on an empty tree" ); if(rtems_rbtree_get_min(&rbtree1)) { puts("INIT - get_min on empty returned non-NULL"); rtems_test_exit(0); } if(rtems_rbtree_get_max(&rbtree1)) { puts("INIT - get_max on empty returned non-NULL"); rtems_test_exit(0); } if(rtems_rbtree_peek_min(&rbtree1)) { puts("INIT - peek_min on empty returned non-NULL"); rtems_test_exit(0); } if(rtems_rbtree_peek_max(&rbtree1)) { puts("INIT - peek_max on empty returned non-NULL"); rtems_test_exit(0); } /* verify that the rbtree insert works after a tree is emptied */ puts( "INIT - Verify rtems_rbtree_insert after empty tree" ); node1.id = 2; node1.key = 2; node2.id = 1; node2.key = 1; rtems_rbtree_insert( &rbtree1, &node1.Node ); rtems_rbtree_insert( &rbtree1, &node2.Node ); puts( "INIT - Verify rtems_rbtree_peek_max/min, rtems_rbtree_extract" ); test_node *t1 = rtems_rbtree_container_of(rtems_rbtree_peek_max(&rbtree1), test_node,Node); test_node *t2 = rtems_rbtree_container_of(rtems_rbtree_peek_min(&rbtree1), test_node,Node); if (t1->key - t2->key != 1) { puts( "INIT - Peek Min - Max failed" ); rtems_test_exit(0); } p = rtems_rbtree_peek_max(&rbtree1); rtems_rbtree_extract(&rbtree1, p); t1 = rtems_rbtree_container_of(p,test_node,Node); if (t1->key != 2) { puts( "INIT - rtems_rbtree_extract failed"); rtems_test_exit(0); } rtems_rbtree_insert(&rbtree1, p); for ( p = rtems_rbtree_get_min(&rbtree1), id = 1 ; p ; p = rtems_rbtree_get_min(&rbtree1) , id++ ) { test_node *t = rtems_rbtree_container_of(p,test_node,Node); if ( id > 2 ) { puts( "INIT - TOO MANY NODES ON RBTREE" ); rtems_test_exit(0); } if ( t->id != id ) { puts( "INIT - ERROR ON RBTREE ID MISMATCH" ); rtems_test_exit(0); } } puts( "INIT - Verify rtems_rbtree_insert with 100 nodes value [0,99]" ); for (i = 0; i < 100; i++) { node_array[i].id = i; node_array[i].key = i; rtems_rbtree_insert( &rbtree1, &node_array[i].Node ); if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } puts( "INIT - Removing 100 nodes" ); for ( p = rtems_rbtree_get_min(&rbtree1), id = 0 ; p ; p = rtems_rbtree_get_min(&rbtree1) , id++ ) { test_node *t = rtems_rbtree_container_of(p,test_node,Node); if ( id > 99 ) { puts( "INIT - TOO MANY NODES ON RBTREE" ); rtems_test_exit(0); } if ( t->id != id ) { puts( "INIT - ERROR ON RBTREE ID MISMATCH" ); rtems_test_exit(0); } if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } if(!rtems_rbtree_is_empty(&rbtree1)) { puts( "INIT - TREE NOT EMPTY" ); rtems_test_exit(0); } puts( "INIT - Verify rtems_rbtree_insert with 100 nodes value [99,0]" ); for (i = 0; i < 100; i++) { node_array[i].id = 99-i; node_array[i].key = 99-i; rtems_rbtree_insert( &rbtree1, &node_array[i].Node ); if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } puts( "INIT - Removing 100 nodes" ); for ( p = rtems_rbtree_get_min(&rbtree1), id = 0 ; p ; p = rtems_rbtree_get_min(&rbtree1) , id++ ) { test_node *t = rtems_rbtree_container_of(p,test_node,Node); if ( id > 99 ) { puts( "INIT - TOO MANY NODES ON RBTREE" ); rtems_test_exit(0); } if ( t->id != id ) { puts( "INIT - ERROR ON RBTREE ID MISMATCH" ); rtems_test_exit(0); } if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } if(!rtems_rbtree_is_empty(&rbtree1)) { puts( "INIT - TREE NOT EMPTY" ); rtems_test_exit(0); } /* testing rbtree_extract by adding 100 nodes then removing the 20 with * keys specified by the numbers array, then removing the rest */ puts( "INIT - Verify rtems_rbtree_extract with 100 nodes value [0,99]" ); for (i = 0; i < 100; i++) { node_array[i].id = i; node_array[i].key = i; rtems_rbtree_insert( &rbtree1, &node_array[i].Node ); if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } puts( "INIT - Extracting 20 random nodes" ); for (i = 0; i < 20; i++) { id = numbers[i]; rtems_rbtree_extract( &rbtree1, &node_array[id].Node ); if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } puts( "INIT - Removing 80 nodes" ); for ( p = rtems_rbtree_get_min(&rbtree1), id = 0, i = 0 ; p ; p = rtems_rbtree_get_min(&rbtree1) , id++ ) { test_node *t = rtems_rbtree_container_of(p, test_node, Node); while ( id == numbers_sorted[i] ) { /* skip if expected minimum (id) is in the set of extracted numbers */ id++; i++; } if ( id > 99 ) { puts( "INIT - TOO MANY NODES ON RBTREE" ); rtems_test_exit(0); } if ( t->id != id ) { puts( "INIT - ERROR ON RBTREE ID MISMATCH" ); rtems_test_exit(0); } if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } if(!rtems_rbtree_is_empty(&rbtree1)) { puts( "INIT - TREE NOT EMPTY" ); rtems_test_exit(0); } /* Additional rtems_rbtree_extract test which removes a node * with two children while target node has a left child only. */ for ( i = 0; i < 7; i++ ) { node_array[i].id = i; node_array[i].key = i; } rtems_rbtree_insert( &rbtree1, &node_array[3].Node ); rtems_rbtree_insert( &rbtree1, &node_array[1].Node ); rtems_rbtree_insert( &rbtree1, &node_array[5].Node ); rtems_rbtree_insert( &rbtree1, &node_array[0].Node ); rtems_rbtree_insert( &rbtree1, &node_array[2].Node ); rtems_rbtree_insert( &rbtree1, &node_array[4].Node ); rtems_rbtree_insert( &rbtree1, &node_array[6].Node ); rtems_rbtree_extract( &rbtree1, &node_array[2].Node ); /* node_array[1] has now only a left child. */ if ( !node_array[1].Node.child[RBT_LEFT] || node_array[1].Node.child[RBT_RIGHT] ) puts( "INIT - LEFT CHILD ONLY NOT FOUND" ); rtems_rbtree_extract( &rbtree1, &node_array[3].Node ); while( (p = rtems_rbtree_get_max(&rbtree1)) ); puts( "INIT - Verify rtems_rbtree_get_max with 100 nodes value [99,0]" ); for (i = 0; i < 100; i++) { node_array[i].id = 99-i; node_array[i].key = 99-i; rtems_rbtree_insert( &rbtree1, &node_array[i].Node ); if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } puts( "INIT - Removing 100 nodes" ); for ( p = rtems_rbtree_get_max(&rbtree1), id = 0 ; p ; p = rtems_rbtree_get_max(&rbtree1) , id++ ) { test_node *t = rtems_rbtree_container_of(p,test_node,Node); if ( id > 99 ) { puts( "INIT - TOO MANY NODES ON RBTREE" ); rtems_test_exit(0); } if ( t->id != 99-id ) { puts( "INIT - ERROR ON RBTREE ID MISMATCH" ); rtems_test_exit(0); } if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } if(!rtems_rbtree_is_empty(&rbtree1)) { puts( "INIT - TREE NOT EMPTY" ); rtems_test_exit(0); } puts( "INIT - Verify rtems_rbtree_get_max with 100 nodes value [0,99]" ); for (i = 0; i < 100; i++) { node_array[i].id = i; node_array[i].key = i; rtems_rbtree_insert( &rbtree1, &node_array[i].Node ); if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } puts( "INIT - Verify rtems_rbtree_find" ); search_node.key = 30; p = rtems_rbtree_find(&rbtree1, &search_node.Node); if(rtems_rbtree_container_of(p,test_node,Node)->id != 30) { puts ("INIT - ERROR ON RBTREE ID MISMATCH"); rtems_test_exit(0); } puts( "INIT - Verify rtems_rbtree_predecessor/successor"); p = rtems_rbtree_predecessor(&rbtree1, p); if(p && rtems_rbtree_container_of(p,test_node,Node)->id != 29) { puts ("INIT - ERROR ON RBTREE ID MISMATCH"); rtems_test_exit(0); } p = rtems_rbtree_find(&rbtree1, &search_node.Node); p = rtems_rbtree_successor(&rbtree1, p); if(p && rtems_rbtree_container_of(p,test_node,Node)->id != 31) { puts ("INIT - ERROR ON RBTREE ID MISMATCH"); rtems_test_exit(0); } p = rtems_rbtree_find(&rbtree1, &search_node.Node); puts( "INIT - Verify rtems_rbtree_find_header" ); if (rtems_rbtree_find_header(p) != &rbtree1) { puts ("INIT - ERROR ON RBTREE HEADER MISMATCH"); rtems_test_exit(0); } if ( _RBTree_Sibling( NULL ) != NULL ) puts ( "INIT - ERROR ON RBTREE NULL SIBLING MISMATCH" ); if ( _RBTree_Sibling( rbtree1.root ) != NULL ) puts ( "INIT - ERROR ON RBTREE NULL SIBLING MISMATCH" ); if ( _RBTree_Grandparent( NULL ) != NULL ) puts ( "INIT - ERROR ON RBTREE NULL GRANDPARENT MISMATCH" ); if ( _RBTree_Is_red( NULL ) != 0 ) puts ( "INIT - ERROR ON RBTREE NULL IS RED MISMATCH" ); if ( _RBTree_Is_red( rbtree1.root ) != 0 ) puts ( "INIT - ERROR ON RBTREE NULL IS RED MISMATCH" ); puts( "INIT - Removing 100 nodes" ); for ( p = rtems_rbtree_get_max(&rbtree1), id = 99 ; p ; p = rtems_rbtree_get_max(&rbtree1) , id-- ) { test_node *t = rtems_rbtree_container_of(p,test_node,Node); if ( id < 0 ) { puts( "INIT - TOO MANY NODES ON RBTREE" ); rtems_test_exit(0); } if ( t->id != id ) { puts( "INIT - ERROR ON RBTREE ID MISMATCH" ); rtems_test_exit(0); } if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } if(!rtems_rbtree_is_empty(&rbtree1)) { puts( "INIT - TREE NOT EMPTY" ); rtems_test_exit(0); } if (rtems_rbtree_find_header(&node_array[0].Node) != NULL) { puts ("INIT - ERROR ON RBTREE HEADER MISMATCH"); rtems_test_exit(0); } if (rtems_rbtree_find_header(NULL) != NULL) { puts ("INIT - ERROR ON RBTREE HEADER MISMATCH"); rtems_test_exit(0); } puts("INIT - Insert 20 random numbers"); for (i = 0; i < 20; i++) { node_array[i].id = numbers[i]; node_array[i].key = numbers[i]; rtems_rbtree_insert( &rbtree1, &node_array[i].Node ); if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } puts( "INIT - Removing 20 nodes" ); for ( p = rtems_rbtree_get_min(&rbtree1), id = 0 ; p ; p = rtems_rbtree_get_min(&rbtree1) , id++ ) { test_node *t = rtems_rbtree_container_of(p,test_node,Node); if ( id > 19 ) { puts( "INIT - TOO MANY NODES ON RBTREE" ); rtems_test_exit(0); } if ( t->id != numbers_sorted[id] ) { puts( "INIT - ERROR ON RBTREE ID MISMATCH" ); rtems_test_exit(0); } if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } if(!rtems_rbtree_is_empty(&rbtree1)) { puts( "INIT - TREE NOT EMPTY" ); rtems_test_exit(0); } puts( "INIT - Verify rtems_rbtree_initialize with 100 nodes value [0,99]" ); for (i = 0; i < 100; i++) { node_array[i].id = i; node_array[i].key = i; } rtems_rbtree_initialize( &rbtree1, &test_compare_function, &node_array[0].Node, 100, sizeof(test_node), true ); puts( "INIT - Removing 100 nodes" ); for ( p = rtems_rbtree_get_min(&rbtree1), id = 0 ; p ; p = rtems_rbtree_get_min(&rbtree1) , id++ ) { test_node *t = rtems_rbtree_container_of(p,test_node,Node); if ( id > 99 ) { puts( "INIT - TOO MANY NODES ON RBTREE" ); rtems_test_exit(0); } if ( t->id != id ) { puts( "INIT - ERROR ON RBTREE ID MISMATCH" ); rtems_test_exit(0); } if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } if(!rtems_rbtree_is_empty(&rbtree1)) { puts( "INIT - TREE NOT EMPTY" ); rtems_test_exit(0); } /* Initialize the tree for duplicate keys */ puts( "Init - Initialize duplicate rbtree empty" ); rtems_rbtree_initialize_empty( &rbtree1, &test_compare_function, false ); if ( rtems_rbtree_is_unique( &rbtree1 ) ) puts( "INIT - FAILED IS UNIQUE CHECK" ); if ( rtems_rbtree_is_unique( NULL ) ) puts( "INIT - FAILED IS UNIQUE CHECK" ); puts( "INIT - Verify rtems_rbtree_insert with 100 nodes value [0,99]" ); for (i = 0; i < 100; i++) { node_array[i].id = i; node_array[i].key = i%5; rtems_rbtree_insert( &rbtree1, &node_array[i].Node ); if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } puts( "INIT - Verify rtems_rbtree_find in a duplicate tree" ); search_node.key = 2; p = rtems_rbtree_find(&rbtree1, &search_node.Node); if(rtems_rbtree_container_of(p,test_node,Node)->id != 2) { puts ("INIT - ERROR ON RBTREE ID MISMATCH"); rtems_test_exit(0); } puts( "INIT - Removing 100 nodes" ); for ( p = rtems_rbtree_get_min(&rbtree1), id = 0 ; p ; p = rtems_rbtree_get_min(&rbtree1) , id++ ) { test_node *t = rtems_rbtree_container_of(p,test_node,Node); if ( id > 99 ) { puts( "INIT - TOO MANY NODES ON RBTREE" ); rtems_test_exit(0); } if ( t->id != ( ((id*5)%100) + (id/20) ) ) { puts( "INIT - ERROR ON RBTREE ID MISMATCH" ); rtems_test_exit(0); } if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } if(!rtems_rbtree_is_empty(&rbtree1)) { puts( "INIT - TREE NOT EMPTY" ); rtems_test_exit(0); } puts( "INIT - Verify rtems_rbtree_insert with 100 nodes value [99,0]" ); for (i = 0; i < 100; i++) { node_array[i].id = 99-i; node_array[i].key = (99-i)%5; rtems_rbtree_insert( &rbtree1, &node_array[i].Node ); if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } puts( "INIT - Verify rtems_rbtree_find in a duplicate tree" ); search_node.key = 2; p = rtems_rbtree_find(&rbtree1, &search_node.Node); if(rtems_rbtree_container_of(p,test_node,Node)->id != 97) { puts ("INIT - ERROR ON RBTREE ID MISMATCH"); rtems_test_exit(0); } puts( "INIT - Removing 100 nodes" ); for ( p = rtems_rbtree_get_min(&rbtree1), id = 0 ; p ; p = rtems_rbtree_get_min(&rbtree1) , id++ ) { test_node *t = rtems_rbtree_container_of(p,test_node,Node); if ( id > 99 ) { puts( "INIT - TOO MANY NODES ON RBTREE" ); rtems_test_exit(0); } if ( t->id != ( (((99-id)*5)%100) + (id/20) ) ) { puts( "INIT - ERROR ON RBTREE ID MISMATCH" ); rtems_test_exit(0); } if (!rb_assert(rbtree1.root) ) puts( "INIT - FAILED TREE CHECK" ); } if(!rtems_rbtree_is_empty(&rbtree1)) { puts( "INIT - TREE NOT EMPTY" ); rtems_test_exit(0); } puts( "*** END OF RTEMS RBTREE API TEST ***" ); rtems_test_exit(0); }
/** @brief Validate and fix-up tree properties after deleting a node * * This routine is called on a black node, @a the_node, after its deletion. * This function maintains the properties of the red-black tree. * * @note It does NOT disable interrupts to ensure the atomicity * of the extract operation. */ static void _RBTree_Extract_validate( RBTree_Node *the_node ) { RBTree_Node *parent; parent = the_node->parent; if ( !parent->parent ) return; /* continue to correct tree as long as the_node is black and not the root */ while ( !_RBTree_Is_red( the_node ) && parent->parent ) { RBTree_Node *sibling = _RBTree_Sibling( the_node, parent ); /* if sibling is red, switch parent (black) and sibling colors, * then rotate parent left, making the sibling be the_node's grandparent. * Now the_node has a black sibling and red parent. After rotation, * update sibling pointer. */ if ( _RBTree_Is_red( sibling ) ) { RBTree_Direction dir = _RBTree_Direction( the_node, parent ); RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); parent->color = RBT_RED; sibling->color = RBT_BLACK; _RBTree_Rotate( parent, dir ); sibling = parent->child[ opp_dir ]; } /* sibling is black, see if both of its children are also black. */ if ( !_RBTree_Is_red( sibling->child[ RBT_RIGHT ] ) && !_RBTree_Is_red( sibling->child[ RBT_LEFT ] ) ) { sibling->color = RBT_RED; if ( _RBTree_Is_red( parent ) ) { parent->color = RBT_BLACK; break; } the_node = parent; /* done if parent is red */ parent = the_node->parent; } else { /* at least one of sibling's children is red. we now proceed in two * cases, either the_node is to the left or the right of the parent. * In both cases, first check if one of sibling's children is black, * and if so rotate in the proper direction and update sibling pointer. * Then switch the sibling and parent colors, and rotate through parent. */ RBTree_Direction dir = _RBTree_Direction( the_node, parent ); RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); if ( !_RBTree_Is_red( sibling->child[ opp_dir ] ) ) { sibling->color = RBT_RED; sibling->child[ dir ]->color = RBT_BLACK; _RBTree_Rotate( sibling, opp_dir ); sibling = parent->child[ opp_dir ]; } sibling->color = parent->color; parent->color = RBT_BLACK; sibling->child[ opp_dir ]->color = RBT_BLACK; _RBTree_Rotate( parent, dir ); break; /* done */ } } /* while */ if ( !the_node->parent->parent ) the_node->color = RBT_BLACK; }
/** @brief Validate and fix-up tree properties after deleting a node * * This routine is called on a black node, @a the_node, after its deletion. * This function maintains the properties of the red-black tree. */ static void rtems_rbtree_extract_validate( RBTree_Node *the_node ) { RBTree_Color color; RBTree_Node *parent = _RBTree_Parent_and_color( the_node, &color ); RBTree_Color parentcolor; RBTree_Node *grandparent = _RBTree_Parent_and_color( parent, &parentcolor ); if ( grandparent == NULL ) return; /* continue to correct tree as long as the_node is black and not the root */ while ( grandparent != NULL && color == RBT_BLACK ) { RBTree_Node *sibling = _RBTree_Sibling( the_node, parent ); /* if sibling is red, switch parent (black) and sibling colors, * then rotate parent left, making the sibling be the_node's grandparent. * Now the_node has a black sibling and red parent. After rotation, * update sibling pointer. */ if ( _RBTree_Color( sibling ) == RBT_RED ) { RBTree_Direction dir = _RBTree_Direction( the_node, parent ); RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); parentcolor = RBT_RED; _RBTree_Set_parent_and_color( parent, grandparent, parentcolor ); _RBTree_Set_parent_and_color( sibling, parent, RBT_BLACK ); _RBTree_Rotate( parent, dir ); grandparent = sibling; sibling = parent->child[ opp_dir ]; } /* sibling is black, see if both of its children are also black. */ if ( _RBTree_Is_null_or_black( sibling->child[ RBT_RIGHT ] ) && _RBTree_Is_null_or_black( sibling->child[ RBT_LEFT ] ) ) { _RBTree_Set_parent_and_color( sibling, parent, RBT_RED ); if ( parentcolor == RBT_RED ) { _RBTree_Set_parent_and_color( parent, grandparent, RBT_BLACK ); break; } the_node = parent; /* done if parent is red */ parent = grandparent; grandparent = _RBTree_Parent_and_color( parent, &parentcolor ); } else { /* at least one of sibling's children is red. we now proceed in two * cases, either the_node is to the left or the right of the parent. * In both cases, first check if one of sibling's children is black, * and if so rotate in the proper direction and update sibling pointer. * Then switch the sibling and parent colors, and rotate through parent. */ RBTree_Direction dir = _RBTree_Direction( the_node, parent ); RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); if ( _RBTree_Is_null_or_black( sibling->child[ opp_dir ] ) ) { _RBTree_Set_parent_and_color( sibling, parent, RBT_RED ); _RBTree_Set_parent_and_color( sibling->child[ dir ], sibling, RBT_BLACK ); _RBTree_Rotate( sibling, opp_dir ); sibling = parent->child[ opp_dir ]; } _RBTree_Set_parent_and_color( sibling, parent, parentcolor ); _RBTree_Set_parent_and_color( parent, grandparent, RBT_BLACK ); _RBTree_Set_parent_and_color( sibling->child[ opp_dir ], sibling, RBT_BLACK ); _RBTree_Rotate( parent, dir ); grandparent = sibling; break; /* done */ } } /* while */ if ( grandparent == NULL ) _RBTree_Set_parent_and_color( the_node, parent, RBT_BLACK ); }