[PATCH 1/3] rbtree: Replace implementation
Sebastian Huber
sebastian.huber at embedded-brains.de
Mon Aug 31 11:54:58 UTC 2015
Use the BSD <sys/tree.h> implementation since it is faster, more
flexible and uses less storage. See https://github.com/sebhub/rb-bench.
---
cpukit/score/include/rtems/score/rbtree.h | 277 +++++----
cpukit/score/include/rtems/score/rbtreeimpl.h | 118 ----
cpukit/score/src/rbtreeextract.c | 190 +-----
cpukit/score/src/rbtreefind.c | 10 +-
cpukit/score/src/rbtreeinsert.c | 128 +---
cpukit/score/src/rbtreenext.c | 57 +-
testsuites/sptests/sprbtree01/init.c | 853 +++++++++++++-------------
7 files changed, 624 insertions(+), 1009 deletions(-)
diff --git a/cpukit/score/include/rtems/score/rbtree.h b/cpukit/score/include/rtems/score/rbtree.h
index b44c09e..077f2b1 100644
--- a/cpukit/score/include/rtems/score/rbtree.h
+++ b/cpukit/score/include/rtems/score/rbtree.h
@@ -18,9 +18,8 @@
#ifndef _RTEMS_SCORE_RBTREE_H
#define _RTEMS_SCORE_RBTREE_H
-#include <stddef.h>
-
-#include <rtems/score/address.h>
+#include <sys/tree.h>
+#include <rtems/score/basedefs.h>
#ifdef __cplusplus
extern "C" {
@@ -40,54 +39,22 @@ extern "C" {
/**@{*/
/**
- * @typedef RBTree_Node
+ * @brief Red-black tree node.
*
- * This type definition promotes the name for the RBTree Node used by
- * all RTEMS code. It is a separate type definition because a forward
- * reference is required to define it. See @ref RBTree_Node_struct for
- * detailed information.
+ * This is used to manage each node (element) which is placed on a red-black
+ * tree.
*/
-typedef struct RBTree_Node_struct RBTree_Node;
+typedef struct RBTree_Node {
+ RB_ENTRY(RBTree_Node) Node;
+} RBTree_Node;
/**
- * This enum type defines the colors available for the RBTree Nodes
- */
-typedef enum {
- RBT_BLACK,
- RBT_RED
-} RBTree_Color;
-
-/**
- * @struct RBTree_Node_struct
- *
- * This is used to manage each element (node) which is placed
- * on a RBT.
- *
- * @note Typically, a more complicated structure will use the
- * rbtree package. The more complicated structure will
- * include a rbtree node as the first element in its
- * control structure. It will then call the rbtree package
- * with a pointer to that node element. The node pointer
- * and the higher level structure start at the same address
- * so the user can cast the pointers back and forth.
+ * @brief Red-black tree control.
*
+ * This is used to manage a red-black tree. A red-black tree consists of a
+ * tree of zero or more nodes.
*/
-struct RBTree_Node_struct {
- /** This points to the node's parent */
- RBTree_Node *parent;
- /** child[0] points to the left child, child[1] points to the right child */
- RBTree_Node *child[2];
- /** The color of the node. Either red or black */
- RBTree_Color color;
-};
-
-/**
- * This type indicates the direction.
- */
-typedef enum {
- RBT_LEFT=0,
- RBT_RIGHT=1
-} RBTree_Direction;
+typedef RB_HEAD(RBTree_Control, RBTree_Node) RBTree_Control;
/**
* @brief Integer type for compare results.
@@ -117,41 +84,13 @@ typedef RBTree_Compare_result ( *RBTree_Compare )(
);
/**
- * @struct RBTree_Control
- *
- * This is used to manage a RBT. A rbtree consists of a tree of zero or more
- * nodes.
- *
- * @note This implementation does not require special checks for
- * manipulating the root element of the RBT.
- * To accomplish this the @a RBTree_Control structure can be overlaid
- * with a @ref RBTree_Node structure to act as a "dummy root",
- * which has a NULL parent and its left child is the root.
- */
-
-/* the RBTree_Control is actually part of the RBTree structure as an
- * RBTree_Node. The mapping of fields from RBTree_Control to RBTree_Node are:
- * permanent_null == parent
- * root == left
- * first[0] == right
- */
-typedef struct {
- /** This points to a NULL. Useful for finding the root. */
- RBTree_Node *permanent_null;
- /** This points to the root node of the RBT. */
- RBTree_Node *root;
- /** This points to the min and max nodes of this RBT. */
- RBTree_Node *first[2];
-} RBTree_Control;
-
-/**
- * @brief RBTree initializer for an empty rbtree with designator @a name.
+ * @brief Initializer for an empty red-black tree with designator @a name.
*/
#define RBTREE_INITIALIZER_EMPTY( name ) \
- { NULL, NULL, { NULL, NULL } }
+ RB_INITIALIZER( name )
/**
- * @brief RBTree definition for an empty rbtree with designator @a name.
+ * @brief Definition for an empty red-black tree with designator @a name.
*/
#define RBTREE_DEFINE_EMPTY( name ) \
RBTree_Control name = RBTREE_INITIALIZER_EMPTY( name )
@@ -201,6 +140,95 @@ RBTree_Node *_RBTree_Insert(
);
/**
+ * @brief Rebalances the red-black tree after insertion of the node.
+ *
+ * @param[in] the_rbtree The red-black tree control.
+ * @param[in] the_node The most recently inserted node.
+ */
+void _RBTree_Insert_color(
+ RBTree_Control *the_rbtree,
+ RBTree_Node *the_node
+);
+
+/**
+ * @brief Adds a child node to a parent node.
+ *
+ * @param[in] child The child node.
+ * @param[in] parent The parent node.
+ * @param[in] link The child node link of the parent node.
+ */
+RTEMS_INLINE_ROUTINE void _RBTree_Add_child(
+ RBTree_Node *child,
+ RBTree_Node *parent,
+ RBTree_Node **link
+)
+{
+ RB_SET( child, parent, Node );
+ *link = child;
+}
+
+/**
+ * @brief Inserts the node into the red-black tree using the specified parent
+ * node and link.
+ *
+ * @param[in] the_rbtree The red-black tree control.
+ * @param[in] the_node The node to insert.
+ * @param[in] parent The parent node.
+ * @param[in] link The child node link of the parent node.
+ *
+ * @code
+ * #include <rtems/score/rbtree.h>
+ *
+ * typedef struct {
+ * int value;
+ * RBTree_Node Node;
+ * } Some_Node;
+ *
+ * bool _Some_Less(
+ * const RBTree_Node *a,
+ * const RBTree_Node *b
+ * )
+ * {
+ * const Some_Node *aa = RTEMS_CONTAINER_OF( a, Some_Node, Node );
+ * const Some_Node *bb = RTEMS_CONTAINER_OF( b, Some_Node, Node );
+ *
+ * return aa->value < bb->value;
+ * }
+ *
+ * void _Some_Insert(
+ * RBTree_Control *the_rbtree,
+ * Some_Node *the_node
+ * )
+ * {
+ * RBTree_Node **link = _RBTree_Root_reference( the_rbtree );
+ * RBTree_Node *parent = NULL;
+ *
+ * while ( *link != NULL ) {
+ * parent = *link;
+ *
+ * if ( _Some_Less( &the_node->Node, parent ) ) {
+ * link = _RBTree_Left_reference( parent );
+ * } else {
+ * link = _RBTree_Right_reference( parent );
+ * }
+ * }
+ *
+ * _RBTree_Insert_with_parent( the_rbtree, &the_node->Node, parent, link );
+ * }
+ * @endcode
+ */
+RTEMS_INLINE_ROUTINE void _RBTree_Insert_with_parent(
+ RBTree_Control *the_rbtree,
+ RBTree_Node *the_node,
+ RBTree_Node *parent,
+ RBTree_Node **link
+)
+{
+ _RBTree_Add_child( the_node, parent, link );
+ _RBTree_Insert_color( the_rbtree, the_node );
+}
+
+/**
* @brief Extracts (removes) the node from the red-black tree.
*
* This function does not set the node off-tree. In case this is desired, then
@@ -218,20 +246,6 @@ void _RBTree_Extract(
);
/**
- * @brief Returns the in-order next node of a node.
- *
- * @param[in] node The node.
- * @param[in] dir The direction.
- *
- * @retval NULL The in-order next node does not exist.
- * @retval otherwise The next node.
- */
-RBTree_Node *_RBTree_Next(
- const RBTree_Node *node,
- RBTree_Direction dir
-);
-
-/**
* @brief Sets a red-black tree node as off-tree.
*
* Do not use this function on nodes which are a part of a tree.
@@ -242,7 +256,7 @@ RBTree_Node *_RBTree_Next(
*/
RTEMS_INLINE_ROUTINE void _RBTree_Set_off_tree( RBTree_Node *the_node )
{
- the_node->parent = NULL;
+ RB_COLOR( the_node, Node ) = -1;
}
/**
@@ -260,7 +274,7 @@ RTEMS_INLINE_ROUTINE bool _RBTree_Is_node_off_tree(
const RBTree_Node *the_node
)
{
- return the_node->parent == NULL;
+ return RB_COLOR( the_node, Node ) == -1;
}
/**
@@ -279,21 +293,17 @@ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Root(
const RBTree_Control *the_rbtree
)
{
- return the_rbtree->root;
+ return RB_ROOT( the_rbtree );
}
/**
- * @brief Return pointer to RBTree's first node.
- *
- * This function returns a pointer to the first node on @a the_rbtree,
- * where @a dir specifies whether to return the minimum (0) or maximum (1).
+ * @brief Returns a reference to the root pointer of the red-black tree.
*/
-RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
- const RBTree_Control *the_rbtree,
- RBTree_Direction dir
+RTEMS_INLINE_ROUTINE RBTree_Node **_RBTree_Root_reference(
+ RBTree_Control *the_rbtree
)
{
- return the_rbtree->first[dir];
+ return &RB_ROOT( the_rbtree );
}
/**
@@ -312,7 +322,7 @@ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
- return the_node->parent;
+ return RB_PARENT( the_node, Node );
}
/**
@@ -328,7 +338,18 @@ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Left(
const RBTree_Node *the_node
)
{
- return the_node->child[RBT_LEFT];
+ return RB_LEFT( the_node, Node );
+}
+
+/**
+ * @brief Returns a reference to the left child pointer of the red-black tree
+ * node.
+ */
+RTEMS_INLINE_ROUTINE RBTree_Node **_RBTree_Left_reference(
+ RBTree_Node *the_node
+)
+{
+ return &RB_LEFT( the_node, Node );
}
/**
@@ -344,7 +365,18 @@ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Right(
const RBTree_Node *the_node
)
{
- return the_node->child[RBT_RIGHT];
+ return RB_RIGHT( the_node, Node );
+}
+
+/**
+ * @brief Returns a reference to the right child pointer of the red-black tree
+ * node.
+ */
+RTEMS_INLINE_ROUTINE RBTree_Node **_RBTree_Right_reference(
+ RBTree_Node *the_node
+)
+{
+ return &RB_RIGHT( the_node, Node );
}
/**
@@ -362,7 +394,7 @@ RTEMS_INLINE_ROUTINE bool _RBTree_Is_empty(
const RBTree_Control *the_rbtree
)
{
- return (the_rbtree->root == NULL);
+ return RB_EMPTY( the_rbtree );
}
/**
@@ -384,7 +416,7 @@ RTEMS_INLINE_ROUTINE bool _RBTree_Is_root(
const RBTree_Node *the_node
)
{
- return _RBTree_Parent( _RBTree_Parent( the_node ) ) == NULL;
+ return _RBTree_Parent( the_node ) == NULL;
}
/**
@@ -396,10 +428,7 @@ RTEMS_INLINE_ROUTINE void _RBTree_Initialize_empty(
RBTree_Control *the_rbtree
)
{
- the_rbtree->permanent_null = NULL;
- the_rbtree->root = NULL;
- the_rbtree->first[RBT_LEFT] = NULL;
- the_rbtree->first[RBT_RIGHT] = NULL;
+ RB_INIT( the_rbtree );
}
/**
@@ -410,12 +439,7 @@ RTEMS_INLINE_ROUTINE void _RBTree_Initialize_empty(
* @retval NULL The red-black tree is empty.
* @retval node The minimum node.
*/
-RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Minimum(
- const RBTree_Control *the_rbtree
-)
-{
- return _RBTree_First( the_rbtree, RBT_LEFT );
-}
+RBTree_Node *_RBTree_Minimum( const RBTree_Control *the_rbtree );
/**
* @brief Returns the maximum node of the red-black tree.
@@ -425,12 +449,7 @@ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Minimum(
* @retval NULL The red-black tree is empty.
* @retval node The maximum node.
*/
-RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Maximum(
- const RBTree_Control *the_rbtree
-)
-{
- return _RBTree_First( the_rbtree, RBT_RIGHT );
-}
+RBTree_Node *_RBTree_Maximum( const RBTree_Control *the_rbtree );
/**
* @brief Returns the predecessor of a node.
@@ -440,12 +459,7 @@ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Maximum(
* @retval NULL The predecessor does not exist. Otherwise it returns
* the predecessor node.
*/
-RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor(
- const RBTree_Node *node
-)
-{
- return _RBTree_Next( node, RBT_LEFT );
-}
+RBTree_Node *_RBTree_Predecessor( const RBTree_Node *node );
/**
* @brief Returns the successor of a node.
@@ -454,12 +468,7 @@ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor(
*
* @retval NULL The successor does not exist. Otherwise the successor node.
*/
-RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor(
- const RBTree_Node *node
-)
-{
- return _RBTree_Next( node, RBT_RIGHT );
-}
+RBTree_Node *_RBTree_Successor( const RBTree_Node *node );
/**@}*/
diff --git a/cpukit/score/include/rtems/score/rbtreeimpl.h b/cpukit/score/include/rtems/score/rbtreeimpl.h
index 607e7eb..9c748eb 100644
--- a/cpukit/score/include/rtems/score/rbtreeimpl.h
+++ b/cpukit/score/include/rtems/score/rbtreeimpl.h
@@ -62,66 +62,6 @@ void _RBTree_Iterate(
void *visitor_arg
);
-/**
- * @brief Get the direction opposite to @a the_dir.
- */
-RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
- RBTree_Direction the_dir
-)
-{
- return (RBTree_Direction) !((int) the_dir);
-}
-
-/**
- * @brief Returns the direction of the node.
- *
- * @param[in] the_node The node of interest.
- * @param[in] parent The parent of the node. The parent must exist, thus it is
- * invalid to use this function for the root node.
- */
-RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Direction(
- const RBTree_Node *the_node,
- const RBTree_Node *parent
-)
-{
- return (RBTree_Direction) ( the_node != parent->child[ 0 ] );
-}
-
-/**
- * @brief Is this node red.
- *
- * This function returns true if @a the_node is red and false otherwise.
- *
- * @retval true @a the_node is red.
- * @retval false @a the_node in not red.
- */
-RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
- const RBTree_Node *the_node
- )
-{
- return (the_node && the_node->color == RBT_RED);
-}
-
-/**
- * @brief Returns the sibling of the node.
- *
- * @param[in] the_node The node of interest.
- * @param[in] parent The parent of the node. The parent must exist, thus it is
- * invalid to use this function for the root node.
- *
- * @retval NULL No sibling exists.
- * @retval sibling The sibling of the node.
- */
-RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
- const RBTree_Node *the_node,
- const RBTree_Node *parent
-)
-{
- RBTree_Node *left_child = parent->child[ RBT_LEFT ];
-
- return the_node == left_child ? parent->child[ RBT_RIGHT ] : left_child;
-}
-
RTEMS_INLINE_ROUTINE bool _RBTree_Is_equal(
RBTree_Compare_result compare_result
)
@@ -143,64 +83,6 @@ RTEMS_INLINE_ROUTINE bool _RBTree_Is_lesser(
return compare_result < 0;
}
-/**
- * @brief Rotates the node in the specified direction.
- *
- * The node is swapped with its child in the opposite direction if it exists.
- *
- * Sub-tree before rotation:
- * @dot
- * digraph state {
- * parent -> the_node;
- * the_node -> sibling [label="dir"];
- * the_node -> child [label="opp_dir"];
- * child -> grandchild [label="dir"];
- * child -> grandchildsibling [label="opp_dir"];
- * }
- * @enddot
- *
- * Sub-tree after rotation:
- * @dot
- * digraph state {
- * parent -> child;
- * the_node -> sibling [label="dir"];
- * the_node -> grandchild [label="opp_dir"];
- * child -> the_node [label="dir"];
- * child -> grandchildsibling [label="opp_dir"];
- * }
- * @enddot
- *
- * @param[in] the_node The node to rotate.
- * @param[in] dir The rotation direction.
- */
-RTEMS_INLINE_ROUTINE void _RBTree_Rotate(
- RBTree_Node *the_node,
- RBTree_Direction dir
-)
-{
- RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
- RBTree_Node *child = the_node->child[ opp_dir ];
- RBTree_Node *grandchild;
- RBTree_Node *parent;
-
- if ( child == NULL)
- return;
-
- grandchild = child->child[ dir ];
- the_node->child[ opp_dir ] = grandchild;
-
- if ( grandchild != NULL )
- grandchild->parent = the_node;
-
- child->child[ dir ] = the_node;
-
- parent = _RBTree_Parent( the_node );
- parent->child[ _RBTree_Direction( the_node, parent ) ] = child;
-
- child->parent = parent;
- the_node->parent = child;
-}
-
/** @} */
#ifdef __cplusplus
diff --git a/cpukit/score/src/rbtreeextract.c b/cpukit/score/src/rbtreeextract.c
index 1aaba27..4d8a8f8 100644
--- a/cpukit/score/src/rbtreeextract.c
+++ b/cpukit/score/src/rbtreeextract.c
@@ -12,198 +12,14 @@
#include <rtems/score/rbtreeimpl.h>
-/** @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 ];
- }
+RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
- /* 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;
-}
+RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
void _RBTree_Extract(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
- RBTree_Node *leaf, *target;
- RBTree_Color victim_color;
- RBTree_Direction dir;
-
- /* check if min needs to be updated */
- if ( the_node == the_rbtree->first[ RBT_LEFT ] ) {
- RBTree_Node *next;
- next = _RBTree_Successor( the_node );
- the_rbtree->first[ RBT_LEFT ] = next;
- }
-
- /* Check if max needs to be updated. min=max for 1 element trees so
- * do not use else if here. */
- if ( the_node == the_rbtree->first[ RBT_RIGHT ] ) {
- RBTree_Node *previous;
- previous = _RBTree_Predecessor( the_node );
- the_rbtree->first[ RBT_RIGHT ] = previous;
- }
-
- /* if the_node has at most one non-null child then it is safe to proceed
- * check if both children are non-null, if so then we must find a target node
- * either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
- * and replace the_node with the target node. This maintains the binary
- * search tree property, but may violate the red-black properties.
- */
-
- if ( the_node->child[ RBT_LEFT ] && the_node->child[ RBT_RIGHT ] ) {
- target = the_node->child[ RBT_LEFT ]; /* find max in node->child[RBT_LEFT] */
-
- while ( target->child[ RBT_RIGHT ] )
- target = target->child[ RBT_RIGHT ];
-
- /* if the target node has a child, need to move it up the tree into
- * target's position (target is the right child of target->parent)
- * when target vacates it. if there is no child, then target->parent
- * should become NULL. This may cause the coloring to be violated.
- * For now we store the color of the node being deleted in victim_color.
- */
- leaf = target->child[ RBT_LEFT ];
-
- if ( leaf ) {
- leaf->parent = target->parent;
- } else {
- /* fix the tree here if the child is a null leaf. */
- _RBTree_Extract_validate( target );
- }
-
- victim_color = target->color;
- dir = target != target->parent->child[ 0 ];
- target->parent->child[ dir ] = leaf;
-
- /* now replace the_node with target */
- dir = the_node != the_node->parent->child[ 0 ];
- the_node->parent->child[ dir ] = target;
-
- /* set target's new children to the original node's children */
- target->child[ RBT_RIGHT ] = the_node->child[ RBT_RIGHT ];
-
- if ( the_node->child[ RBT_RIGHT ] )
- the_node->child[ RBT_RIGHT ]->parent = target;
-
- target->child[ RBT_LEFT ] = the_node->child[ RBT_LEFT ];
-
- if ( the_node->child[ RBT_LEFT ] )
- the_node->child[ RBT_LEFT ]->parent = target;
-
- /* finally, update the parent node and recolor. target has completely
- * replaced the_node, and target's child has moved up the tree if needed.
- * the_node is no longer part of the tree, although it has valid pointers
- * still.
- */
- target->parent = the_node->parent;
- target->color = the_node->color;
- } else {
- /* the_node has at most 1 non-null child. Move the child in to
- * the_node's location in the tree. This may cause the coloring to be
- * violated. We will fix it later.
- * For now we store the color of the node being deleted in victim_color.
- */
- leaf = the_node->child[ RBT_LEFT ] ?
- the_node->child[ RBT_LEFT ] : the_node->child[ RBT_RIGHT ];
-
- if ( leaf ) {
- leaf->parent = the_node->parent;
- } else {
- /* fix the tree here if the child is a null leaf. */
- _RBTree_Extract_validate( the_node );
- }
-
- victim_color = the_node->color;
-
- /* remove the_node from the tree */
- dir = the_node != the_node->parent->child[ 0 ];
- the_node->parent->child[ dir ] = leaf;
- }
-
- /* fix coloring. leaf has moved up the tree. The color of the deleted
- * node is in victim_color. There are two cases:
- * 1. Deleted a red node, its child must be black. Nothing must be done.
- * 2. Deleted a black node, its child must be red. Paint child black.
- */
- if ( victim_color == RBT_BLACK ) { /* eliminate case 1 */
- if ( leaf ) {
- leaf->color = RBT_BLACK; /* case 2 */
- }
- }
-
- /* set root to black, if it exists */
- if ( the_rbtree->root )
- the_rbtree->root->color = RBT_BLACK;
+ RB_REMOVE( RBTree_Control, the_rbtree, the_node );
}
diff --git a/cpukit/score/src/rbtreefind.c b/cpukit/score/src/rbtreefind.c
index 168a108..f920feb 100644
--- a/cpukit/score/src/rbtreefind.c
+++ b/cpukit/score/src/rbtreefind.c
@@ -26,12 +26,11 @@ RBTree_Node *_RBTree_Find(
bool is_unique
)
{
- RBTree_Node *iter_node = the_rbtree->root;
+ RBTree_Node *iter_node = _RBTree_Root( the_rbtree );
RBTree_Node *found = NULL;
while ( iter_node != NULL ) {
RBTree_Compare_result compare_result = ( *compare )( the_node, iter_node );
- RBTree_Direction dir;
if ( _RBTree_Is_equal( compare_result ) ) {
found = iter_node;
@@ -40,8 +39,11 @@ RBTree_Node *_RBTree_Find(
break;
}
- dir = (RBTree_Direction) _RBTree_Is_greater( compare_result );
- iter_node = iter_node->child[ dir ];
+ if ( _RBTree_Is_greater( compare_result ) ) {
+ iter_node = _RBTree_Right( iter_node );
+ } else {
+ iter_node = _RBTree_Left( iter_node );
+ }
}
return found;
diff --git a/cpukit/score/src/rbtreeinsert.c b/cpukit/score/src/rbtreeinsert.c
index a7be449..629fca7 100644
--- a/cpukit/score/src/rbtreeinsert.c
+++ b/cpukit/score/src/rbtreeinsert.c
@@ -22,68 +22,6 @@ RTEMS_STATIC_ASSERT(
RBTree_Compare_result_int32_t
);
-/** @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_Node *grandparent = _RBTree_Parent( parent );
-
- /* 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 ( parent->color == RBT_RED ) {
- /* The root is black, so the grandparent must exist */
- RBTree_Node *uncle = _RBTree_Sibling( parent, grandparent );
-
- /*
- * If uncle exists and is red, repaint uncle/parent black and grandparent
- * red.
- */
- if ( uncle != NULL && uncle->color == RBT_RED ) {
- parent->color = RBT_BLACK;
- uncle->color = RBT_BLACK;
- grandparent->color = RBT_RED;
- the_node = grandparent;
- parent = _RBTree_Parent( the_node );
- grandparent = _RBTree_Parent( parent );
-
- 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 );
- }
-
- parent->color = RBT_BLACK;
- grandparent->color = 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 )
- the_node->color = RBT_BLACK;
-}
-
RBTree_Node *_RBTree_Insert(
RBTree_Control *the_rbtree,
RBTree_Node *the_node,
@@ -91,52 +29,38 @@ RBTree_Node *_RBTree_Insert(
bool is_unique
)
{
- RBTree_Node *iter_node = the_rbtree->root;
+ RBTree_Node **which = _RBTree_Root_reference( the_rbtree );
+ RBTree_Node *parent = NULL;
- if ( !iter_node ) { /* special case: first node inserted */
- the_node->color = RBT_BLACK;
- the_rbtree->root = the_node;
- the_rbtree->first[ 0 ] = the_rbtree->first[ 1 ] = the_node;
- the_node->parent = (RBTree_Node *) the_rbtree;
- the_node->child[ RBT_LEFT ] = the_node->child[ RBT_RIGHT ] = NULL;
- } else {
- /* typical binary search tree insert, descend tree to leaf and insert */
- while ( iter_node ) {
- RBTree_Compare_result compare_result =
- ( *compare )( the_node, iter_node );
+ while ( *which != NULL ) {
+ RBTree_Compare_result compare_result;
- if ( is_unique && _RBTree_Is_equal( compare_result ) )
- return iter_node;
+ parent = *which;
+ compare_result = ( *compare )( the_node, parent );
- RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
+ if ( is_unique && _RBTree_Is_equal( compare_result ) ) {
+ return parent;
+ }
- if ( !iter_node->child[ dir ] ) {
- the_node->child[ RBT_LEFT ] = the_node->child[ RBT_RIGHT ] = NULL;
- the_node->color = RBT_RED;
- iter_node->child[ dir ] = the_node;
- the_node->parent = iter_node;
- /* update min/max */
- compare_result = ( *compare )(
- the_node,
- _RBTree_First( the_rbtree, dir )
- );
+ if ( _RBTree_Is_lesser( compare_result ) ) {
+ which = _RBTree_Left_reference( parent );
+ } else {
+ which = _RBTree_Right_reference( parent );
+ }
+ }
- if (
- ( dir == RBT_LEFT && _RBTree_Is_lesser( compare_result ) )
- || ( dir == RBT_RIGHT && !_RBTree_Is_lesser( compare_result ) )
- ) {
- the_rbtree->first[ dir ] = the_node;
- }
+ _RBTree_Add_child( the_node, parent, which );
+ _RBTree_Insert_color( the_rbtree, the_node );
- break;
- } else {
- iter_node = iter_node->child[ dir ];
- }
- } /* while(iter_node) */
+ return NULL;
+}
- /* verify red-black properties */
- _RBTree_Validate_insert( the_node );
- }
+RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static )
- return (RBTree_Node *) 0;
+void _RBTree_Insert_color(
+ RBTree_Control *the_rbtree,
+ RBTree_Node *the_node
+)
+{
+ RBTree_Control_RB_INSERT_COLOR( the_rbtree, the_node );
}
diff --git a/cpukit/score/src/rbtreenext.c b/cpukit/score/src/rbtreenext.c
index 2128ae5..7096b4b 100644
--- a/cpukit/score/src/rbtreenext.c
+++ b/cpukit/score/src/rbtreenext.c
@@ -25,39 +25,30 @@
#endif
#include <rtems/score/rbtreeimpl.h>
-#include <rtems/score/isr.h>
+#include <rtems/score/basedefs.h>
-RBTree_Node *_RBTree_Next(
- const RBTree_Node *node,
- RBTree_Direction dir
-)
+RB_GENERATE_MINMAX( RBTree_Control, RBTree_Node, Node, static )
+
+RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static )
+
+RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static )
+
+RBTree_Node *_RBTree_Minimum( const RBTree_Control *tree )
+{
+ return RB_MIN( RBTree_Control, RTEMS_DECONST( RBTree_Control *, tree ) );
+}
+
+RBTree_Node *_RBTree_Maximum( const RBTree_Control *tree )
+{
+ return RB_MAX( RBTree_Control, RTEMS_DECONST( RBTree_Control *, tree ) );
+}
+
+RBTree_Node *_RBTree_Successor( const RBTree_Node *node )
+{
+ return RB_NEXT( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
+}
+
+RBTree_Node *_RBTree_Predecessor( const RBTree_Node *node )
{
- RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
- RBTree_Node *current = node->child[ dir ];
- RBTree_Node *next = NULL;
-
- if ( current != NULL ) {
- next = current;
-
- while ( ( current = current->child[ opp_dir ] ) != NULL ) {
- next = current;
- }
- } else {
- RBTree_Node *parent = node->parent;
-
- if ( parent->parent && node == parent->child[ opp_dir ] ) {
- next = parent;
- } else {
- while ( parent->parent && node == parent->child[ dir ] ) {
- node = parent;
- parent = parent->parent;
- }
-
- if ( parent->parent ) {
- next = parent;
- }
- }
- }
-
- return next;
+ return RB_PREV( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
}
diff --git a/testsuites/sptests/sprbtree01/init.c b/testsuites/sptests/sprbtree01/init.c
index 0fe72a4..c58c6d5 100644
--- a/testsuites/sptests/sprbtree01/init.c
+++ b/testsuites/sptests/sprbtree01/init.c
@@ -35,13 +35,13 @@ typedef struct {
static test_node node_array[100];
-#define RED RBT_RED
+#define RED RB_RED
-#define BLACK RBT_BLACK
+#define BLACK RB_BLACK
static int rb_color( const rtems_rbtree_node *n )
{
- return n->color;
+ return RB_COLOR( n, Node );
}
static rtems_rbtree_compare_result test_compare_function (
@@ -241,7 +241,7 @@ typedef struct {
const rtems_rbtree_node *parent;
const rtems_rbtree_node *left;
const rtems_rbtree_node *right;
- RBTree_Color color;
+ int color;
} test_node_description;
static const test_node_description test_insert_tree_0[] = {
@@ -863,8 +863,8 @@ static const test_node_description random_ops_tree_multiple_3[] = {
};
static const test_node_description random_ops_tree_unique_4[] = {
- { 0, NULL, NULL, TN( 3 ), BLACK },
- { 3, TN( 0 ), NULL, NULL, RED }
+ { 0, TN(3), NULL, NULL, RED },
+ { 3, NULL, TN(0), NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_4[] = {
@@ -911,10 +911,10 @@ static const test_node_description random_ops_tree_multiple_7[] = {
};
static const test_node_description random_ops_tree_unique_8[] = {
- { 0, TN( 1 ), NULL, NULL, RED },
- { 1, TN( 5 ), TN( 0 ), NULL, BLACK },
- { 5, NULL, TN( 1 ), TN( 6 ), BLACK },
- { 6, TN( 5 ), NULL, NULL, BLACK }
+ { 0, TN(1), NULL, NULL, BLACK },
+ { 1, NULL, TN(0), TN(6), BLACK },
+ { 5, TN(6), NULL, NULL, RED },
+ { 6, TN(1), TN(5), NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_8[] = {
@@ -1001,36 +1001,36 @@ static const test_node_description random_ops_tree_multiple_12[] = {
};
static const test_node_description random_ops_tree_unique_13[] = {
- { 0, TN( 1 ), NULL, NULL, RED },
- { 1, TN( 3 ), TN( 0 ), NULL, BLACK },
- { 3, NULL, TN( 1 ), TN( 8 ), BLACK },
- { 4, TN( 5 ), NULL, NULL, RED },
- { 5, TN( 8 ), TN( 4 ), TN( 6 ), BLACK },
- { 6, TN( 5 ), NULL, NULL, RED },
- { 8, TN( 3 ), TN( 5 ), TN( 11 ), RED },
- { 10, TN( 11 ), NULL, NULL, RED },
- { 11, TN( 8 ), TN( 10 ), NULL, BLACK }
+ { 0, TN(1), NULL, NULL, RED },
+ { 1, TN(3), TN(0), NULL, BLACK },
+ { 3, TN(8), TN(1), TN(5), RED },
+ { 4, TN(5), NULL, NULL, RED },
+ { 5, TN(3), TN(4), TN(6), BLACK },
+ { 6, TN(5), NULL, NULL, RED },
+ { 8, NULL, TN(3), TN(11), BLACK },
+ { 10, TN(11), NULL, NULL, RED },
+ { 11, TN(8), TN(10), NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_13[] = {
- { 0, TN( 0 ), NULL, NULL, BLACK },
- { 0, TN( 4 ), TN( 1 ), TN( 3 ), RED },
- { 1, TN( 0 ), NULL, NULL, BLACK },
- { 2, NULL, TN( 0 ), TN( 8 ), BLACK },
- { 2, TN( 6 ), NULL, NULL, RED },
- { 3, TN( 8 ), TN( 5 ), NULL, BLACK },
- { 4, TN( 4 ), TN( 6 ), TN( 11 ), RED },
- { 5, TN( 8 ), NULL, TN( 10 ), BLACK },
- { 5, TN( 11 ), NULL, NULL, RED }
+ { 0, TN(0), NULL, NULL, RED },
+ { 0, TN(3), TN(1), NULL, BLACK },
+ { 1, TN(6), TN(0), TN(4), RED },
+ { 2, TN(3), NULL, TN(5), BLACK },
+ { 2, TN(4), NULL, NULL, RED },
+ { 3, NULL, TN(3), TN(11), BLACK },
+ { 4, TN(11), NULL, NULL, RED },
+ { 5, TN(6), TN(8), TN(10), BLACK },
+ { 5, TN(11), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_unique_14[] = {
- { 3, TN( 6 ), NULL, TN( 5 ), BLACK },
- { 5, TN( 3 ), NULL, NULL, RED },
- { 6, NULL, TN( 3 ), TN( 12 ), BLACK },
- { 8, TN( 12 ), NULL, NULL, BLACK },
- { 12, TN( 6 ), TN( 8 ), TN( 13 ), RED },
- { 13, TN( 12 ), NULL, NULL, BLACK }
+ { 3, TN(5), NULL, NULL, RED },
+ { 5, TN(6), TN(3), NULL, BLACK },
+ { 6, NULL, TN(5), TN(12), BLACK },
+ { 8, TN(12), NULL, NULL, BLACK },
+ { 12, TN(6), TN(8), TN(13), RED },
+ { 13, TN(12), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_14[] = {
@@ -1043,491 +1043,491 @@ static const test_node_description random_ops_tree_multiple_14[] = {
};
static const test_node_description random_ops_tree_unique_15[] = {
- { 0, TN( 2 ), NULL, NULL, BLACK },
- { 2, TN( 9 ), TN( 0 ), TN( 8 ), BLACK },
- { 7, TN( 8 ), NULL, NULL, RED },
- { 8, TN( 2 ), TN( 7 ), NULL, BLACK },
- { 9, NULL, TN( 2 ), TN( 12 ), BLACK },
- { 10, TN( 12 ), NULL, NULL, BLACK },
- { 12, TN( 9 ), TN( 10 ), TN( 13 ), BLACK },
- { 13, TN( 12 ), NULL, TN( 14 ), BLACK },
- { 14, TN( 13 ), NULL, NULL, RED }
+ { 0, TN(2), NULL, NULL, RED },
+ { 2, TN(8), TN(0), TN(7), BLACK },
+ { 7, TN(2), NULL, NULL, RED },
+ { 8, NULL, TN(2), TN(12), BLACK },
+ { 9, TN(12), NULL, TN(10), BLACK },
+ { 10, TN(9), NULL, NULL, RED },
+ { 12, TN(8), TN(9), TN(13), RED },
+ { 13, TN(12), NULL, TN(14), BLACK },
+ { 14, TN(13), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_multiple_15[] = {
- { 0, TN( 2 ), NULL, NULL, RED },
- { 1, TN( 9 ), TN( 0 ), TN( 7 ), BLACK },
- { 3, TN( 2 ), NULL, NULL, RED },
- { 4, NULL, TN( 2 ), TN( 13 ), BLACK },
- { 4, TN( 13 ), NULL, TN( 10 ), BLACK },
- { 5, TN( 8 ), NULL, NULL, RED },
- { 6, TN( 9 ), TN( 8 ), TN( 12 ), RED },
- { 6, TN( 13 ), NULL, TN( 14 ), BLACK },
- { 7, TN( 12 ), NULL, NULL, RED }
+ { 0, TN(2), NULL, NULL, RED },
+ { 1, TN(9), TN(0), TN(7), BLACK },
+ { 3, TN(2), NULL, NULL, RED },
+ { 4, NULL, TN(2), TN(10), BLACK },
+ { 4, TN(10), NULL, NULL, BLACK },
+ { 5, TN(9), TN(8), TN(12), RED },
+ { 6, TN(12), NULL, NULL, RED },
+ { 6, TN(10), TN(13), TN(14), BLACK },
+ { 7, TN(12), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_unique_16[] = {
- { 0, TN( 5 ), NULL, TN( 3 ), BLACK },
- { 3, TN( 0 ), NULL, NULL, RED },
- { 5, NULL, TN( 0 ), TN( 10 ), BLACK },
- { 7, TN( 10 ), NULL, NULL, BLACK },
- { 10, TN( 5 ), TN( 7 ), TN( 12 ), RED },
- { 12, TN( 10 ), NULL, NULL, BLACK }
+ { 0, TN(5), NULL, TN(3), BLACK },
+ { 3, TN(0), NULL, NULL, RED },
+ { 5, TN(10), TN(0), TN(7), RED },
+ { 7, TN(5), NULL, NULL, BLACK },
+ { 10, NULL, TN(5), TN(12), BLACK },
+ { 12, TN(10), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_16[] = {
- { 0, TN( 3 ), NULL, NULL, RED },
- { 1, TN( 7 ), TN( 0 ), TN( 5 ), BLACK },
- { 2, TN( 3 ), NULL, NULL, RED },
- { 3, NULL, TN( 3 ), TN( 12 ), BLACK },
- { 5, TN( 12 ), NULL, NULL, RED },
- { 6, TN( 7 ), TN( 10 ), NULL, BLACK }
+ { 0, TN(5), NULL, TN(3), BLACK },
+ { 1, TN(0), NULL, NULL, RED },
+ { 2, TN(10), TN(0), TN(7), RED },
+ { 3, TN(5), NULL, NULL, BLACK },
+ { 5, NULL, TN(5), TN(12), BLACK },
+ { 6, TN(10), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_unique_17[] = {
- { 0, TN( 1 ), NULL, NULL, BLACK },
- { 1, TN( 5 ), TN( 0 ), TN( 3 ), BLACK },
- { 3, TN( 1 ), NULL, TN( 4 ), BLACK },
- { 4, TN( 3 ), NULL, NULL, RED },
- { 5, NULL, TN( 1 ), TN( 9 ), BLACK },
- { 7, TN( 9 ), NULL, TN( 8 ), BLACK },
- { 8, TN( 7 ), NULL, NULL, RED },
- { 9, TN( 5 ), TN( 7 ), TN( 16 ), BLACK },
- { 16, TN( 9 ), NULL, NULL, BLACK }
+ { 0, TN(1), NULL, NULL, RED },
+ { 1, TN(3), TN(0), NULL, BLACK },
+ { 3, TN(7), TN(1), TN(5), RED },
+ { 4, TN(5), NULL, NULL, RED },
+ { 5, TN(3), TN(4), NULL, BLACK },
+ { 7, NULL, TN(3), TN(9), BLACK },
+ { 8, TN(9), NULL, NULL, BLACK },
+ { 9, TN(7), TN(8), TN(16), RED },
+ { 16, TN(9), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_17[] = {
- { 0, TN( 0 ), NULL, NULL, BLACK },
- { 0, TN( 5 ), TN( 1 ), TN( 3 ), BLACK },
- { 1, TN( 0 ), NULL, NULL, BLACK },
- { 2, NULL, TN( 0 ), TN( 9 ), BLACK },
- { 2, TN( 9 ), NULL, TN( 7 ), BLACK },
- { 3, TN( 4 ), NULL, NULL, RED },
- { 4, TN( 5 ), TN( 4 ), TN( 16 ), BLACK },
- { 4, TN( 16 ), NULL, NULL, RED },
- { 8, TN( 9 ), TN( 8 ), NULL, BLACK }
+ { 0, TN(0), NULL, NULL, RED },
+ { 0, TN(3), TN(1), NULL, BLACK },
+ { 1, TN(7), TN(0), TN(5), RED },
+ { 2, TN(3), NULL, TN(4), BLACK },
+ { 2, TN(5), NULL, NULL, RED },
+ { 3, NULL, TN(3), TN(8), BLACK },
+ { 4, TN(8), NULL, NULL, BLACK },
+ { 4, TN(7), TN(9), TN(16), RED },
+ { 8, TN(8), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_unique_18[] = {
- { 0, TN( 1 ), NULL, NULL, RED },
- { 1, TN( 3 ), TN( 0 ), TN( 2 ), BLACK },
- { 2, TN( 1 ), NULL, NULL, RED },
- { 3, TN( 6 ), TN( 1 ), TN( 4 ), BLACK },
- { 4, TN( 3 ), NULL, TN( 5 ), BLACK },
- { 5, TN( 4 ), NULL, NULL, RED },
- { 6, NULL, TN( 3 ), TN( 14 ), BLACK },
- { 7, TN( 8 ), NULL, NULL, RED },
- { 8, TN( 10 ), TN( 7 ), TN( 9 ), BLACK },
- { 9, TN( 8 ), NULL, NULL, RED },
- { 10, TN( 14 ), TN( 8 ), TN( 12 ), RED },
- { 12, TN( 10 ), NULL, NULL, BLACK },
- { 14, TN( 6 ), TN( 10 ), TN( 17 ), BLACK },
- { 17, TN( 14 ), NULL, NULL, BLACK }
+ { 0, TN(2), NULL, TN(1), BLACK },
+ { 1, TN(0), NULL, NULL, RED },
+ { 2, TN(4), TN(0), TN(3), BLACK },
+ { 3, TN(2), NULL, NULL, BLACK },
+ { 4, NULL, TN(2), TN(12), BLACK },
+ { 5, TN(6), NULL, NULL, RED },
+ { 6, TN(8), TN(5), TN(7), BLACK },
+ { 7, TN(6), NULL, NULL, RED },
+ { 8, TN(12), TN(6), TN(10), RED },
+ { 9, TN(10), NULL, NULL, RED },
+ { 10, TN(8), TN(9), NULL, BLACK },
+ { 12, TN(4), TN(8), TN(17), BLACK },
+ { 14, TN(17), NULL, NULL, RED },
+ { 17, TN(12), TN(14), NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_18[] = {
- { 0, TN( 1 ), NULL, NULL, RED },
- { 0, TN( 2 ), TN( 0 ), TN( 3 ), BLACK },
- { 1, TN( 1 ), NULL, NULL, RED },
- { 1, TN( 6 ), TN( 1 ), TN( 4 ), BLACK },
- { 2, TN( 2 ), NULL, TN( 5 ), BLACK },
- { 2, TN( 4 ), NULL, NULL, RED },
- { 3, NULL, TN( 2 ), TN( 12 ), BLACK },
- { 3, TN( 8 ), NULL, NULL, RED },
- { 4, TN( 9 ), TN( 7 ), NULL, BLACK },
- { 4, TN( 12 ), TN( 8 ), TN( 10 ), RED },
- { 5, TN( 9 ), NULL, NULL, BLACK },
- { 6, TN( 6 ), TN( 9 ), TN( 14 ), BLACK },
- { 7, TN( 12 ), NULL, TN( 17 ), BLACK },
- { 8, TN( 14 ), NULL, NULL, RED }
+ { 0, TN(3), NULL, TN(1), BLACK },
+ { 0, TN(0), NULL, NULL, RED },
+ { 1, TN(4), TN(0), TN(2), BLACK },
+ { 1, TN(3), NULL, NULL, BLACK },
+ { 2, NULL, TN(3), TN(12), BLACK },
+ { 2, TN(6), NULL, NULL, RED },
+ { 3, TN(8), TN(5), TN(7), BLACK },
+ { 3, TN(6), NULL, NULL, RED },
+ { 4, TN(12), TN(6), TN(10), RED },
+ { 4, TN(10), NULL, NULL, RED },
+ { 5, TN(8), TN(9), NULL, BLACK },
+ { 6, TN(4), TN(8), TN(14), BLACK },
+ { 7, TN(12), NULL, TN(17), BLACK },
+ { 8, TN(14), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_unique_19[] = {
- { 1, TN( 2 ), NULL, NULL, RED },
- { 2, TN( 6 ), TN( 1 ), NULL, BLACK },
- { 6, TN( 9 ), TN( 2 ), TN( 8 ), BLACK },
- { 8, TN( 6 ), NULL, NULL, BLACK },
- { 9, NULL, TN( 6 ), TN( 12 ), BLACK },
- { 11, TN( 12 ), NULL, NULL, BLACK },
- { 12, TN( 9 ), TN( 11 ), TN( 16 ), BLACK },
- { 14, TN( 16 ), NULL, NULL, RED },
- { 16, TN( 12 ), TN( 14 ), NULL, BLACK }
+ { 1, TN(2), NULL, NULL, RED },
+ { 2, TN(6), TN(1), NULL, BLACK },
+ { 6, TN(11), TN(2), TN(8), BLACK },
+ { 8, TN(6), NULL, TN(9), BLACK },
+ { 9, TN(8), NULL, NULL, RED },
+ { 11, NULL, TN(6), TN(14), BLACK },
+ { 12, TN(14), NULL, NULL, BLACK },
+ { 14, TN(11), TN(12), TN(16), BLACK },
+ { 16, TN(14), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_19[] = {
- { 0, TN( 2 ), NULL, NULL, RED },
- { 1, TN( 6 ), TN( 1 ), NULL, BLACK },
- { 3, TN( 8 ), TN( 2 ), TN( 9 ), BLACK },
- { 4, TN( 6 ), NULL, NULL, BLACK },
- { 4, NULL, TN( 6 ), TN( 12 ), BLACK },
- { 5, TN( 12 ), NULL, NULL, BLACK },
- { 6, TN( 8 ), TN( 11 ), TN( 16 ), BLACK },
- { 7, TN( 16 ), NULL, NULL, RED },
- { 8, TN( 12 ), TN( 14 ), NULL, BLACK }
+ { 0, TN(2), NULL, NULL, RED },
+ { 1, TN(6), TN(1), NULL, BLACK },
+ { 3, TN(11), TN(2), TN(9), BLACK },
+ { 4, TN(6), NULL, TN(8), BLACK },
+ { 4, TN(9), NULL, NULL, RED },
+ { 5, NULL, TN(6), TN(14), BLACK },
+ { 6, TN(14), NULL, NULL, BLACK },
+ { 7, TN(11), TN(12), TN(16), BLACK },
+ { 8, TN(14), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_unique_20[] = {
- { 0, TN( 3 ), NULL, TN( 1 ), BLACK },
- { 1, TN( 0 ), NULL, NULL, RED },
- { 3, TN( 9 ), TN( 0 ), TN( 4 ), RED },
- { 4, TN( 3 ), NULL, TN( 7 ), BLACK },
- { 7, TN( 4 ), NULL, NULL, RED },
- { 9, NULL, TN( 3 ), TN( 14 ), BLACK },
- { 10, TN( 14 ), NULL, TN( 12 ), BLACK },
- { 12, TN( 10 ), NULL, NULL, RED },
- { 14, TN( 9 ), TN( 10 ), TN( 18 ), RED },
- { 17, TN( 18 ), NULL, NULL, RED },
- { 18, TN( 14 ), TN( 17 ), TN( 19 ), BLACK },
- { 19, TN( 18 ), NULL, NULL, RED }
+ { 0, TN(3), NULL, TN(1), BLACK },
+ { 1, TN(0), NULL, NULL, RED },
+ { 3, TN(9), TN(0), TN(7), BLACK },
+ { 4, TN(7), NULL, NULL, RED },
+ { 7, TN(3), TN(4), NULL, BLACK },
+ { 9, NULL, TN(3), TN(12), BLACK },
+ { 10, TN(12), NULL, NULL, BLACK },
+ { 12, TN(9), TN(10), TN(17), BLACK },
+ { 14, TN(17), NULL, NULL, BLACK },
+ { 17, TN(12), TN(14), TN(18), RED },
+ { 18, TN(17), NULL, TN(19), BLACK },
+ { 19, TN(18), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_multiple_20[] = {
- { 0, TN( 1 ), NULL, NULL, RED },
- { 0, TN( 4 ), TN( 0 ), TN( 3 ), BLACK },
- { 1, TN( 1 ), NULL, NULL, RED },
- { 2, TN( 9 ), TN( 1 ), TN( 7 ), BLACK },
- { 3, TN( 4 ), NULL, NULL, BLACK },
- { 4, NULL, TN( 4 ), TN( 12 ), BLACK },
- { 5, TN( 12 ), NULL, NULL, BLACK },
- { 6, TN( 9 ), TN( 10 ), TN( 17 ), BLACK },
- { 7, TN( 17 ), NULL, NULL, BLACK },
- { 8, TN( 12 ), TN( 14 ), TN( 18 ), RED },
- { 9, TN( 17 ), NULL, TN( 19 ), BLACK },
- { 9, TN( 18 ), NULL, NULL, RED }
+ { 0, TN(3), NULL, TN(1), BLACK },
+ { 0, TN(0), NULL, NULL, RED },
+ { 1, TN(9), TN(0), TN(7), BLACK },
+ { 2, TN(7), NULL, NULL, RED },
+ { 3, TN(3), TN(4), NULL, BLACK },
+ { 4, NULL, TN(3), TN(14), BLACK },
+ { 5, TN(14), NULL, TN(12), BLACK },
+ { 6, TN(10), NULL, NULL, RED },
+ { 7, TN(9), TN(10), TN(18), BLACK },
+ { 8, TN(18), NULL, NULL, RED },
+ { 9, TN(14), TN(17), TN(19), BLACK },
+ { 9, TN(18), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_unique_21[] = {
- { 0, TN( 1 ), NULL, NULL, BLACK },
- { 1, TN( 8 ), TN( 0 ), TN( 4 ), BLACK },
- { 3, TN( 4 ), NULL, NULL, BLACK },
- { 4, TN( 1 ), TN( 3 ), TN( 5 ), RED },
- { 5, TN( 4 ), NULL, NULL, BLACK },
- { 8, NULL, TN( 1 ), TN( 13 ), BLACK },
- { 11, TN( 13 ), NULL, NULL, BLACK },
- { 13, TN( 8 ), TN( 11 ), TN( 16 ), BLACK },
- { 15, TN( 16 ), NULL, NULL, BLACK },
- { 16, TN( 13 ), TN( 15 ), TN( 17 ), RED },
- { 17, TN( 16 ), NULL, NULL, BLACK }
+ { 0, TN(3), NULL, TN(1), BLACK },
+ { 1, TN(0), NULL, NULL, RED },
+ { 3, TN(11), TN(0), TN(5), BLACK },
+ { 4, TN(5), NULL, NULL, BLACK },
+ { 5, TN(3), TN(4), TN(8), RED },
+ { 8, TN(5), NULL, NULL, BLACK },
+ { 11, NULL, TN(3), TN(15), BLACK },
+ { 13, TN(15), NULL, NULL, BLACK },
+ { 15, TN(11), TN(13), TN(17), BLACK },
+ { 16, TN(17), NULL, NULL, RED },
+ { 17, TN(15), TN(16), NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_21[] = {
- { 0, TN( 1 ), NULL, NULL, BLACK },
- { 0, TN( 8 ), TN( 0 ), TN( 4 ), BLACK },
- { 1, TN( 4 ), NULL, NULL, BLACK },
- { 2, TN( 1 ), TN( 3 ), TN( 5 ), RED },
- { 2, TN( 4 ), NULL, NULL, BLACK },
- { 4, NULL, TN( 1 ), TN( 13 ), BLACK },
- { 5, TN( 13 ), NULL, NULL, BLACK },
- { 6, TN( 8 ), TN( 11 ), TN( 17 ), BLACK },
- { 7, TN( 17 ), NULL, NULL, BLACK },
- { 8, TN( 13 ), TN( 15 ), TN( 16 ), RED },
- { 8, TN( 17 ), NULL, NULL, BLACK }
+ { 0, TN(3), NULL, TN(1), BLACK },
+ { 0, TN(0), NULL, NULL, RED },
+ { 1, TN(8), TN(0), TN(4), BLACK },
+ { 2, TN(3), NULL, TN(5), BLACK },
+ { 2, TN(4), NULL, NULL, RED },
+ { 4, NULL, TN(3), TN(13), BLACK },
+ { 5, TN(13), NULL, NULL, BLACK },
+ { 6, TN(8), TN(11), TN(17), BLACK },
+ { 7, TN(17), NULL, NULL, BLACK },
+ { 8, TN(13), TN(15), TN(16), RED },
+ { 8, TN(17), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_unique_22[] = {
- { 1, TN( 3 ), NULL, TN( 2 ), BLACK },
- { 2, TN( 1 ), NULL, NULL, RED },
- { 3, TN( 8 ), TN( 1 ), TN( 4 ), BLACK },
- { 4, TN( 3 ), NULL, TN( 7 ), BLACK },
- { 7, TN( 4 ), NULL, NULL, RED },
- { 8, NULL, TN( 3 ), TN( 14 ), BLACK },
- { 10, TN( 11 ), NULL, NULL, RED },
- { 11, TN( 14 ), TN( 10 ), NULL, BLACK },
- { 14, TN( 8 ), TN( 11 ), TN( 18 ), BLACK },
- { 15, TN( 18 ), NULL, NULL, BLACK },
- { 18, TN( 14 ), TN( 15 ), TN( 21 ), RED },
- { 21, TN( 18 ), NULL, NULL, BLACK }
+ { 1, TN(3), NULL, TN(2), BLACK },
+ { 2, TN(1), NULL, NULL, RED },
+ { 3, TN(8), TN(1), TN(7), BLACK },
+ { 4, TN(7), NULL, NULL, RED },
+ { 7, TN(3), TN(4), NULL, BLACK },
+ { 8, NULL, TN(3), TN(14), BLACK },
+ { 10, TN(11), NULL, NULL, RED },
+ { 11, TN(14), TN(10), NULL, BLACK },
+ { 14, TN(8), TN(11), TN(18), BLACK },
+ { 15, TN(18), NULL, NULL, BLACK },
+ { 18, TN(14), TN(15), TN(21), RED },
+ { 21, TN(18), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_22[] = {
- { 0, TN( 3 ), NULL, NULL, BLACK },
- { 1, TN( 8 ), TN( 1 ), TN( 4 ), BLACK },
- { 1, TN( 4 ), NULL, NULL, BLACK },
- { 2, TN( 3 ), TN( 2 ), TN( 7 ), RED },
- { 3, TN( 4 ), NULL, NULL, BLACK },
- { 4, NULL, TN( 3 ), TN( 14 ), BLACK },
- { 5, TN( 14 ), NULL, TN( 10 ), BLACK },
- { 5, TN( 11 ), NULL, NULL, RED },
- { 7, TN( 8 ), TN( 11 ), TN( 18 ), BLACK },
- { 7, TN( 18 ), NULL, NULL, BLACK },
- { 9, TN( 14 ), TN( 15 ), TN( 21 ), RED },
- { 10, TN( 18 ), NULL, NULL, BLACK }
+ { 0, TN(3), NULL, NULL, BLACK },
+ { 1, TN(8), TN(1), TN(4), BLACK },
+ { 1, TN(4), NULL, NULL, BLACK },
+ { 2, TN(3), TN(2), TN(7), RED },
+ { 3, TN(4), NULL, NULL, BLACK },
+ { 4, NULL, TN(3), TN(14), BLACK },
+ { 5, TN(14), NULL, TN(10), BLACK },
+ { 5, TN(11), NULL, NULL, RED },
+ { 7, TN(8), TN(11), TN(18), BLACK },
+ { 7, TN(18), NULL, NULL, BLACK },
+ { 9, TN(14), TN(15), TN(21), RED },
+ { 10, TN(18), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_unique_23[] = {
- { 0, TN( 2 ), NULL, NULL, BLACK },
- { 2, TN( 8 ), TN( 0 ), TN( 7 ), BLACK },
- { 7, TN( 2 ), NULL, NULL, BLACK },
- { 8, NULL, TN( 2 ), TN( 16 ), BLACK },
- { 11, TN( 12 ), NULL, NULL, BLACK },
- { 12, TN( 16 ), TN( 11 ), TN( 14 ), RED },
- { 13, TN( 14 ), NULL, NULL, RED },
- { 14, TN( 12 ), TN( 13 ), TN( 15 ), BLACK },
- { 15, TN( 14 ), NULL, NULL, RED },
- { 16, TN( 8 ), TN( 12 ), TN( 20 ), BLACK },
- { 17, TN( 20 ), NULL, NULL, RED },
- { 20, TN( 16 ), TN( 17 ), TN( 21 ), BLACK },
- { 21, TN( 20 ), NULL, NULL, RED }
+ { 0, TN(2), NULL, NULL, RED },
+ { 2, TN(8), TN(0), TN(7), BLACK },
+ { 7, TN(2), NULL, NULL, RED },
+ { 8, TN(12), TN(2), TN(11), BLACK },
+ { 11, TN(8), NULL, NULL, BLACK },
+ { 12, NULL, TN(8), TN(17), BLACK },
+ { 13, TN(15), NULL, TN(14), BLACK },
+ { 14, TN(13), NULL, NULL, RED },
+ { 15, TN(17), TN(13), TN(16), RED },
+ { 16, TN(15), NULL, NULL, BLACK },
+ { 17, TN(12), TN(15), TN(20), BLACK },
+ { 20, TN(17), NULL, TN(21), BLACK },
+ { 21, TN(20), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_multiple_23[] = {
- { 0, TN( 2 ), NULL, NULL, BLACK },
- { 1, TN( 8 ), TN( 0 ), TN( 7 ), RED },
- { 3, TN( 2 ), NULL, NULL, BLACK },
- { 4, TN( 12 ), TN( 2 ), TN( 11 ), BLACK },
- { 5, TN( 8 ), NULL, NULL, BLACK },
- { 6, NULL, TN( 8 ), TN( 17 ), BLACK },
- { 6, TN( 15 ), NULL, NULL, BLACK },
- { 7, TN( 17 ), TN( 13 ), TN( 16 ), RED },
- { 7, TN( 16 ), NULL, NULL, RED },
- { 8, TN( 15 ), TN( 14 ), NULL, BLACK },
- { 8, TN( 12 ), TN( 15 ), TN( 20 ), BLACK },
- { 10, TN( 17 ), NULL, TN( 21 ), BLACK },
- { 10, TN( 20 ), NULL, NULL, RED }
+ { 0, TN(2), NULL, NULL, RED },
+ { 1, TN(8), TN(0), TN(7), BLACK },
+ { 3, TN(2), NULL, NULL, RED },
+ { 4, TN(12), TN(2), TN(11), BLACK },
+ { 5, TN(8), NULL, NULL, BLACK },
+ { 6, NULL, TN(8), TN(17), BLACK },
+ { 6, TN(15), NULL, NULL, BLACK },
+ { 7, TN(17), TN(13), TN(16), RED },
+ { 7, TN(16), NULL, NULL, RED },
+ { 8, TN(15), TN(14), NULL, BLACK },
+ { 8, TN(12), TN(15), TN(20), BLACK },
+ { 10, TN(17), NULL, TN(21), BLACK },
+ { 10, TN(20), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_unique_24[] = {
- { 4, TN( 5 ), NULL, NULL, BLACK },
- { 5, TN( 8 ), TN( 4 ), TN( 6 ), RED },
- { 6, TN( 5 ), NULL, NULL, BLACK },
- { 8, TN( 14 ), TN( 5 ), TN( 10 ), BLACK },
- { 10, TN( 8 ), NULL, NULL, BLACK },
- { 14, NULL, TN( 8 ), TN( 20 ), BLACK },
- { 15, TN( 16 ), NULL, NULL, RED },
- { 16, TN( 20 ), TN( 15 ), NULL, BLACK },
- { 20, TN( 14 ), TN( 16 ), TN( 22 ), BLACK },
- { 22, TN( 20 ), NULL, NULL, BLACK }
+ { 4, TN(6), NULL, TN(5), BLACK },
+ { 5, TN(4), NULL, NULL, RED },
+ { 6, TN(14), TN(4), TN(10), BLACK },
+ { 8, TN(10), NULL, NULL, RED },
+ { 10, TN(6), TN(8), NULL, BLACK },
+ { 14, NULL, TN(6), TN(20), BLACK },
+ { 15, TN(16), NULL, NULL, RED },
+ { 16, TN(20), TN(15), NULL, BLACK },
+ { 20, TN(14), TN(16), TN(22), BLACK },
+ { 22, TN(20), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_24[] = {
- { 2, TN( 6 ), NULL, TN( 5 ), BLACK },
- { 2, TN( 4 ), NULL, NULL, RED },
- { 3, TN( 10 ), TN( 4 ), TN( 8 ), BLACK },
- { 4, TN( 6 ), NULL, NULL, BLACK },
- { 5, NULL, TN( 6 ), TN( 16 ), BLACK },
- { 7, TN( 16 ), NULL, TN( 15 ), BLACK },
- { 7, TN( 14 ), NULL, NULL, RED },
- { 8, TN( 10 ), TN( 14 ), TN( 22 ), BLACK },
- { 10, TN( 22 ), NULL, NULL, RED },
- { 11, TN( 16 ), TN( 20 ), NULL, BLACK }
+ { 2, TN(6), NULL, TN(5), BLACK },
+ { 2, TN(4), NULL, NULL, RED },
+ { 3, TN(14), TN(4), TN(10), BLACK },
+ { 4, TN(10), NULL, NULL, RED },
+ { 5, TN(6), TN(8), NULL, BLACK },
+ { 7, NULL, TN(6), TN(20), BLACK },
+ { 7, TN(16), NULL, NULL, RED },
+ { 8, TN(20), TN(15), NULL, BLACK },
+ { 10, TN(14), TN(16), TN(22), BLACK },
+ { 11, TN(20), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_unique_25[] = {
- { 0, TN( 1 ), NULL, NULL, BLACK },
- { 1, TN( 13 ), TN( 0 ), TN( 4 ), BLACK },
- { 3, TN( 4 ), NULL, NULL, BLACK },
- { 4, TN( 1 ), TN( 3 ), TN( 6 ), RED },
- { 5, TN( 6 ), NULL, NULL, RED },
- { 6, TN( 4 ), TN( 5 ), TN( 9 ), BLACK },
- { 9, TN( 6 ), NULL, NULL, RED },
- { 13, NULL, TN( 1 ), TN( 19 ), BLACK },
- { 14, TN( 15 ), NULL, NULL, RED },
- { 15, TN( 16 ), TN( 14 ), NULL, BLACK },
- { 16, TN( 19 ), TN( 15 ), TN( 17 ), RED },
- { 17, TN( 16 ), NULL, NULL, BLACK },
- { 19, TN( 13 ), TN( 16 ), TN( 23 ), BLACK },
- { 23, TN( 19 ), NULL, TN( 24 ), BLACK },
- { 24, TN( 23 ), NULL, NULL, RED }
+ { 0, TN(1), NULL, NULL, RED },
+ { 1, TN(3), TN(0), NULL, BLACK },
+ { 3, TN(13), TN(1), TN(5), BLACK },
+ { 4, TN(5), NULL, NULL, BLACK },
+ { 5, TN(3), TN(4), TN(6), RED },
+ { 6, TN(5), NULL, TN(9), BLACK },
+ { 9, TN(6), NULL, NULL, RED },
+ { 13, NULL, TN(3), TN(19), BLACK },
+ { 14, TN(15), NULL, NULL, RED },
+ { 15, TN(16), TN(14), NULL, BLACK },
+ { 16, TN(19), TN(15), TN(17), RED },
+ { 17, TN(16), NULL, NULL, BLACK },
+ { 19, TN(13), TN(16), TN(23), BLACK },
+ { 23, TN(19), NULL, TN(24), BLACK },
+ { 24, TN(23), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_multiple_25[] = {
- { 0, TN( 1 ), NULL, NULL, BLACK },
- { 0, TN( 5 ), TN( 0 ), TN( 3 ), RED },
- { 1, TN( 1 ), NULL, NULL, BLACK },
- { 2, TN( 13 ), TN( 1 ), TN( 6 ), BLACK },
- { 2, TN( 6 ), NULL, NULL, RED },
- { 3, TN( 5 ), TN( 4 ), TN( 9 ), BLACK },
- { 4, TN( 6 ), NULL, NULL, RED },
- { 6, NULL, TN( 5 ), TN( 19 ), BLACK },
- { 7, TN( 17 ), NULL, TN( 14 ), BLACK },
- { 7, TN( 15 ), NULL, NULL, RED },
- { 8, TN( 19 ), TN( 15 ), TN( 16 ), RED },
- { 8, TN( 17 ), NULL, NULL, BLACK },
- { 9, TN( 13 ), TN( 17 ), TN( 23 ), BLACK },
- { 11, TN( 19 ), NULL, TN( 24 ), BLACK },
- { 12, TN( 23 ), NULL, NULL, RED }
+ { 0, TN(3), NULL, TN(1), BLACK },
+ { 0, TN(0), NULL, NULL, RED },
+ { 1, TN(13), TN(0), TN(4), BLACK },
+ { 2, TN(4), NULL, NULL, BLACK },
+ { 2, TN(3), TN(5), TN(6), RED },
+ { 3, TN(4), NULL, TN(9), BLACK },
+ { 4, TN(6), NULL, NULL, RED },
+ { 6, NULL, TN(3), TN(19), BLACK },
+ { 7, TN(17), NULL, TN(14), BLACK },
+ { 7, TN(15), NULL, NULL, RED },
+ { 8, TN(19), TN(15), TN(16), RED },
+ { 8, TN(17), NULL, NULL, BLACK },
+ { 9, TN(13), TN(17), TN(23), BLACK },
+ { 11, TN(19), NULL, TN(24), BLACK },
+ { 12, TN(23), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_unique_26[] = {
- { 0, TN( 1 ), NULL, NULL, RED },
- { 1, TN( 6 ), TN( 0 ), TN( 3 ), BLACK },
- { 3, TN( 1 ), NULL, NULL, RED },
- { 6, TN( 11 ), TN( 1 ), TN( 9 ), BLACK },
- { 9, TN( 6 ), NULL, TN( 10 ), BLACK },
- { 10, TN( 9 ), NULL, NULL, RED },
- { 11, NULL, TN( 6 ), TN( 14 ), BLACK },
- { 12, TN( 14 ), NULL, TN( 13 ), BLACK },
- { 13, TN( 12 ), NULL, NULL, RED },
- { 14, TN( 11 ), TN( 12 ), TN( 20 ), BLACK },
- { 18, TN( 20 ), NULL, NULL, BLACK },
- { 20, TN( 14 ), TN( 18 ), TN( 23 ), RED },
- { 21, TN( 23 ), NULL, NULL, RED },
- { 23, TN( 20 ), TN( 21 ), NULL, BLACK }
+ { 0, TN(1), NULL, NULL, RED },
+ { 1, TN(3), TN(0), NULL, BLACK },
+ { 3, TN(11), TN(1), TN(9), BLACK },
+ { 6, TN(9), NULL, NULL, RED },
+ { 9, TN(3), TN(6), TN(10), BLACK },
+ { 10, TN(9), NULL, NULL, RED },
+ { 11, NULL, TN(3), TN(14), BLACK },
+ { 12, TN(14), NULL, TN(13), BLACK },
+ { 13, TN(12), NULL, NULL, RED },
+ { 14, TN(11), TN(12), TN(20), BLACK },
+ { 18, TN(20), NULL, NULL, BLACK },
+ { 20, TN(14), TN(18), TN(23), RED },
+ { 21, TN(23), NULL, NULL, RED },
+ { 23, TN(20), TN(21), NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_26[] = {
- { 0, TN( 0 ), NULL, NULL, RED },
- { 0, TN( 6 ), TN( 1 ), TN( 3 ), BLACK },
- { 1, TN( 0 ), NULL, NULL, RED },
- { 3, TN( 12 ), TN( 0 ), TN( 11 ), BLACK },
- { 4, TN( 11 ), NULL, NULL, RED },
- { 5, TN( 6 ), TN( 9 ), TN( 10 ), BLACK },
- { 5, TN( 11 ), NULL, NULL, RED },
- { 6, NULL, TN( 6 ), TN( 18 ), BLACK },
- { 6, TN( 14 ), NULL, NULL, RED },
- { 7, TN( 18 ), TN( 13 ), NULL, BLACK },
- { 9, TN( 12 ), TN( 14 ), TN( 21 ), BLACK },
- { 10, TN( 21 ), NULL, NULL, RED },
- { 10, TN( 18 ), TN( 20 ), TN( 23 ), BLACK },
- { 11, TN( 21 ), NULL, NULL, RED }
+ { 0, TN(3), NULL, TN(0), BLACK },
+ { 0, TN(1), NULL, NULL, RED },
+ { 1, TN(9), TN(1), TN(6), BLACK },
+ { 3, TN(3), NULL, NULL, BLACK },
+ { 4, NULL, TN(3), TN(14), BLACK },
+ { 5, TN(12), NULL, TN(10), BLACK },
+ { 5, TN(11), NULL, NULL, RED },
+ { 6, TN(14), TN(11), TN(13), RED },
+ { 6, TN(12), NULL, NULL, BLACK },
+ { 7, TN(9), TN(12), TN(20), BLACK },
+ { 9, TN(20), NULL, NULL, BLACK },
+ { 10, TN(14), TN(18), TN(23), RED },
+ { 10, TN(23), NULL, NULL, RED },
+ { 11, TN(20), TN(21), NULL, BLACK }
};
static const test_node_description random_ops_tree_unique_27[] = {
- { 3, TN( 8 ), NULL, NULL, BLACK },
- { 8, TN( 19 ), TN( 3 ), TN( 17 ), RED },
- { 12, TN( 17 ), NULL, NULL, RED },
- { 17, TN( 8 ), TN( 12 ), NULL, BLACK },
- { 19, NULL, TN( 8 ), TN( 23 ), BLACK },
- { 20, TN( 23 ), NULL, TN( 21 ), BLACK },
- { 21, TN( 20 ), NULL, NULL, RED },
- { 23, TN( 19 ), TN( 20 ), TN( 25 ), RED },
- { 24, TN( 25 ), NULL, NULL, RED },
- { 25, TN( 23 ), TN( 24 ), TN( 26 ), BLACK },
- { 26, TN( 25 ), NULL, NULL, RED }
+ { 3, TN(8), NULL, NULL, BLACK },
+ { 8, TN(19), TN(3), TN(17), BLACK },
+ { 12, TN(17), NULL, NULL, RED },
+ { 17, TN(8), TN(12), NULL, BLACK },
+ { 19, NULL, TN(8), TN(24), BLACK },
+ { 20, TN(21), NULL, NULL, RED },
+ { 21, TN(24), TN(20), TN(23), BLACK },
+ { 23, TN(21), NULL, NULL, RED },
+ { 24, TN(19), TN(21), TN(25), BLACK },
+ { 25, TN(24), NULL, TN(26), BLACK },
+ { 26, TN(25), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_multiple_27[] = {
- { 1, TN( 8 ), NULL, NULL, BLACK },
- { 4, TN( 19 ), TN( 3 ), TN( 17 ), RED },
- { 6, TN( 17 ), NULL, NULL, RED },
- { 8, TN( 8 ), TN( 12 ), NULL, BLACK },
- { 9, NULL, TN( 8 ), TN( 23 ), BLACK },
- { 10, TN( 23 ), NULL, TN( 21 ), BLACK },
- { 10, TN( 20 ), NULL, NULL, RED },
- { 11, TN( 19 ), TN( 20 ), TN( 24 ), RED },
- { 12, TN( 24 ), NULL, NULL, RED },
- { 12, TN( 23 ), TN( 25 ), TN( 26 ), BLACK },
- { 13, TN( 24 ), NULL, NULL, RED }
+ { 1, TN(8), NULL, NULL, BLACK },
+ { 4, TN(19), TN(3), TN(17), BLACK },
+ { 6, TN(17), NULL, NULL, RED },
+ { 8, TN(8), TN(12), NULL, BLACK },
+ { 9, NULL, TN(8), TN(25), BLACK },
+ { 10, TN(21), NULL, NULL, RED },
+ { 10, TN(25), TN(20), TN(23), BLACK },
+ { 11, TN(21), NULL, NULL, RED },
+ { 12, TN(19), TN(21), TN(24), BLACK },
+ { 12, TN(25), NULL, TN(26), BLACK },
+ { 13, TN(24), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_unique_28[] = {
- { 0, TN( 5 ), NULL, NULL, BLACK },
- { 5, TN( 13 ), TN( 0 ), TN( 7 ), RED },
- { 7, TN( 5 ), NULL, NULL, BLACK },
- { 13, NULL, TN( 5 ), TN( 17 ), BLACK },
- { 15, TN( 17 ), NULL, NULL, BLACK },
- { 17, TN( 13 ), TN( 15 ), TN( 26 ), RED },
- { 21, TN( 26 ), NULL, NULL, RED },
- { 26, TN( 17 ), TN( 21 ), NULL, BLACK }
+ { 0, TN(5), NULL, NULL, BLACK },
+ { 5, TN(13), TN(0), TN(7), RED },
+ { 7, TN(5), NULL, NULL, BLACK },
+ { 13, NULL, TN(5), TN(17), BLACK },
+ { 15, TN(17), NULL, NULL, BLACK },
+ { 17, TN(13), TN(15), TN(26), RED },
+ { 21, TN(26), NULL, NULL, RED },
+ { 26, TN(17), TN(21), NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_28[] = {
- { 0, TN( 5 ), NULL, NULL, RED },
- { 2, TN( 7 ), TN( 0 ), NULL, BLACK },
- { 3, NULL, TN( 5 ), TN( 15 ), BLACK },
- { 6, TN( 15 ), NULL, NULL, BLACK },
- { 7, TN( 7 ), TN( 13 ), TN( 21 ), RED },
- { 8, TN( 21 ), NULL, NULL, RED },
- { 10, TN( 15 ), TN( 17 ), TN( 26 ), BLACK },
- { 13, TN( 21 ), NULL, NULL, RED }
+ { 0, TN(5), NULL, NULL, BLACK },
+ { 2, TN(13), TN(0), TN(7), RED },
+ { 3, TN(5), NULL, NULL, BLACK },
+ { 6, NULL, TN(5), TN(17), BLACK },
+ { 7, TN(17), NULL, NULL, BLACK },
+ { 8, TN(13), TN(15), TN(26), RED },
+ { 10, TN(26), NULL, NULL, RED },
+ { 13, TN(17), TN(21), NULL, BLACK }
};
static const test_node_description random_ops_tree_unique_29[] = {
- { 0, TN( 1 ), NULL, NULL, RED },
- { 1, TN( 4 ), TN( 0 ), TN( 3 ), BLACK },
- { 3, TN( 1 ), NULL, NULL, RED },
- { 4, TN( 11 ), TN( 1 ), TN( 7 ), BLACK },
- { 6, TN( 7 ), NULL, NULL, RED },
- { 7, TN( 4 ), TN( 6 ), TN( 8 ), BLACK },
- { 8, TN( 7 ), NULL, NULL, RED },
- { 11, NULL, TN( 4 ), TN( 13 ), BLACK },
- { 12, TN( 13 ), NULL, NULL, BLACK },
- { 13, TN( 11 ), TN( 12 ), TN( 22 ), BLACK },
- { 14, TN( 17 ), NULL, NULL, RED },
- { 17, TN( 22 ), TN( 14 ), NULL, BLACK },
- { 22, TN( 13 ), TN( 17 ), TN( 25 ), RED },
- { 25, TN( 22 ), NULL, TN( 27 ), BLACK },
- { 27, TN( 25 ), NULL, NULL, RED }
+ { 0, TN(3), NULL, TN(1), BLACK },
+ { 1, TN(0), NULL, NULL, RED },
+ { 3, TN(12), TN(0), TN(6), BLACK },
+ { 4, TN(6), NULL, NULL, BLACK },
+ { 6, TN(3), TN(4), TN(8), RED },
+ { 7, TN(8), NULL, NULL, RED },
+ { 8, TN(6), TN(7), TN(11), BLACK },
+ { 11, TN(8), NULL, NULL, RED },
+ { 12, NULL, TN(3), TN(17), BLACK },
+ { 13, TN(17), NULL, TN(14), BLACK },
+ { 14, TN(13), NULL, NULL, RED },
+ { 17, TN(12), TN(13), TN(25), BLACK },
+ { 22, TN(25), NULL, NULL, RED },
+ { 25, TN(17), TN(22), TN(27), BLACK },
+ { 27, TN(25), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_multiple_29[] = {
- { 0, TN( 3 ), NULL, TN( 1 ), BLACK },
- { 0, TN( 0 ), NULL, NULL, RED },
- { 1, TN( 11 ), TN( 0 ), TN( 6 ), BLACK },
- { 2, TN( 6 ), NULL, NULL, BLACK },
- { 3, TN( 3 ), TN( 4 ), TN( 7 ), RED },
- { 3, TN( 6 ), NULL, TN( 8 ), BLACK },
- { 4, TN( 7 ), NULL, NULL, RED },
- { 5, NULL, TN( 3 ), TN( 12 ), BLACK },
- { 6, TN( 12 ), NULL, NULL, BLACK },
- { 6, TN( 11 ), TN( 13 ), TN( 22 ), BLACK },
- { 7, TN( 17 ), NULL, NULL, RED },
- { 8, TN( 22 ), TN( 14 ), NULL, BLACK },
- { 11, TN( 12 ), TN( 17 ), TN( 25 ), RED },
- { 12, TN( 22 ), NULL, TN( 27 ), BLACK },
- { 13, TN( 25 ), NULL, NULL, RED }
+ { 0, TN(3), NULL, TN(1), BLACK },
+ { 0, TN(0), NULL, NULL, RED },
+ { 1, TN(11), TN(0), TN(6), BLACK },
+ { 2, TN(6), NULL, NULL, BLACK },
+ { 3, TN(3), TN(4), TN(7), RED },
+ { 3, TN(6), NULL, TN(8), BLACK },
+ { 4, TN(7), NULL, NULL, RED },
+ { 5, NULL, TN(3), TN(22), BLACK },
+ { 6, TN(12), NULL, NULL, BLACK },
+ { 6, TN(22), TN(13), TN(17), RED },
+ { 7, TN(17), NULL, NULL, RED },
+ { 8, TN(12), TN(14), NULL, BLACK },
+ { 11, TN(11), TN(12), TN(25), BLACK },
+ { 12, TN(22), NULL, TN(27), BLACK },
+ { 13, TN(25), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_unique_30[] = {
- { 0, TN( 4 ), NULL, NULL, BLACK },
- { 4, TN( 12 ), TN( 0 ), TN( 8 ), RED },
- { 6, TN( 8 ), NULL, NULL, RED },
- { 8, TN( 4 ), TN( 6 ), TN( 9 ), BLACK },
- { 9, TN( 8 ), NULL, NULL, RED },
- { 12, TN( 14 ), TN( 4 ), TN( 13 ), BLACK },
- { 13, TN( 12 ), NULL, NULL, BLACK },
- { 14, NULL, TN( 12 ), TN( 17 ), BLACK },
- { 16, TN( 17 ), NULL, NULL, BLACK },
- { 17, TN( 14 ), TN( 16 ), TN( 20 ), BLACK },
- { 18, TN( 20 ), NULL, NULL, BLACK },
- { 20, TN( 17 ), TN( 18 ), TN( 28 ), RED },
- { 27, TN( 28 ), NULL, NULL, RED },
- { 28, TN( 20 ), TN( 27 ), NULL, BLACK }
+ { 0, TN(4), NULL, NULL, RED },
+ { 4, TN(6), TN(0), NULL, BLACK },
+ { 6, TN(13), TN(4), TN(9), RED },
+ { 8, TN(9), NULL, NULL, RED },
+ { 9, TN(6), TN(8), TN(12), BLACK },
+ { 12, TN(9), NULL, NULL, RED },
+ { 13, NULL, TN(6), TN(18), BLACK },
+ { 14, TN(16), NULL, NULL, RED },
+ { 16, TN(18), TN(14), TN(17), BLACK },
+ { 17, TN(16), NULL, NULL, RED },
+ { 18, TN(13), TN(16), TN(27), RED },
+ { 20, TN(27), NULL, NULL, RED },
+ { 27, TN(18), TN(20), TN(28), BLACK },
+ { 28, TN(27), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_multiple_30[] = {
- { 0, TN( 4 ), NULL, NULL, RED },
- { 2, TN( 6 ), TN( 0 ), NULL, BLACK },
- { 3, TN( 12 ), TN( 4 ), TN( 8 ), RED },
- { 4, TN( 8 ), NULL, NULL, RED },
- { 4, TN( 6 ), TN( 9 ), TN( 13 ), BLACK },
- { 6, TN( 8 ), NULL, NULL, RED },
- { 6, NULL, TN( 6 ), TN( 18 ), BLACK },
- { 7, TN( 17 ), NULL, NULL, RED },
- { 8, TN( 18 ), TN( 14 ), TN( 16 ), BLACK },
- { 8, TN( 17 ), NULL, NULL, RED },
- { 9, TN( 12 ), TN( 17 ), TN( 27 ), RED },
- { 10, TN( 27 ), NULL, NULL, RED },
- { 13, TN( 18 ), TN( 20 ), TN( 28 ), BLACK },
- { 14, TN( 27 ), NULL, NULL, RED }
+ { 0, TN(4), NULL, NULL, BLACK },
+ { 2, TN(13), TN(0), TN(9), RED },
+ { 3, TN(9), NULL, NULL, RED },
+ { 4, TN(4), TN(6), TN(8), BLACK },
+ { 4, TN(9), NULL, NULL, RED },
+ { 6, TN(14), TN(4), TN(12), BLACK },
+ { 6, TN(13), NULL, NULL, BLACK },
+ { 7, NULL, TN(13), TN(18), BLACK },
+ { 8, TN(18), NULL, TN(16), BLACK },
+ { 8, TN(17), NULL, NULL, RED },
+ { 9, TN(14), TN(17), TN(27), BLACK },
+ { 10, TN(27), NULL, NULL, RED },
+ { 13, TN(18), TN(20), TN(28), BLACK },
+ { 14, TN(27), NULL, NULL, RED }
};
static const test_node_description random_ops_tree_unique_31[] = {
- { 0, TN( 2 ), NULL, NULL, RED },
- { 2, TN( 5 ), TN( 0 ), NULL, BLACK },
- { 5, TN( 14 ), TN( 2 ), TN( 9 ), BLACK },
- { 7, TN( 9 ), NULL, NULL, RED },
- { 9, TN( 5 ), TN( 7 ), TN( 11 ), BLACK },
- { 11, TN( 9 ), NULL, NULL, RED },
- { 14, NULL, TN( 5 ), TN( 21 ), BLACK },
- { 16, TN( 21 ), NULL, TN( 18 ), BLACK },
- { 18, TN( 16 ), NULL, NULL, RED },
- { 21, TN( 14 ), TN( 16 ), TN( 30 ), BLACK },
- { 30, TN( 21 ), NULL, NULL, BLACK }
+ { 0, TN(2), NULL, NULL, RED },
+ { 2, TN(5), TN(0), NULL, BLACK },
+ { 5, TN(11), TN(2), TN(9), BLACK },
+ { 7, TN(9), NULL, NULL, RED },
+ { 9, TN(5), TN(7), NULL, BLACK },
+ { 11, NULL, TN(5), TN(21), BLACK },
+ { 14, TN(16), NULL, NULL, RED },
+ { 16, TN(21), TN(14), TN(18), BLACK },
+ { 18, TN(16), NULL, NULL, RED },
+ { 21, TN(11), TN(16), TN(30), BLACK },
+ { 30, TN(21), NULL, NULL, BLACK }
};
static const test_node_description random_ops_tree_multiple_31[] = {
- { 0, TN( 2 ), NULL, NULL, RED },
- { 1, TN( 5 ), TN( 0 ), NULL, BLACK },
- { 2, TN( 11 ), TN( 2 ), TN( 9 ), BLACK },
- { 3, TN( 9 ), NULL, NULL, RED },
- { 4, TN( 5 ), TN( 7 ), NULL, BLACK },
- { 5, NULL, TN( 5 ), TN( 21 ), BLACK },
- { 7, TN( 16 ), NULL, NULL, RED },
- { 8, TN( 21 ), TN( 14 ), TN( 18 ), BLACK },
- { 9, TN( 16 ), NULL, NULL, RED },
- { 10, TN( 11 ), TN( 16 ), TN( 30 ), BLACK },
- { 15, TN( 21 ), NULL, NULL, BLACK }
+ { 0, TN(2), NULL, NULL, RED },
+ { 1, TN(5), TN(0), NULL, BLACK },
+ { 2, TN(11), TN(2), TN(9), BLACK },
+ { 3, TN(9), NULL, NULL, RED },
+ { 4, TN(5), TN(7), NULL, BLACK },
+ { 5, NULL, TN(5), TN(21), BLACK },
+ { 7, TN(16), NULL, NULL, RED },
+ { 8, TN(21), TN(14), TN(18), BLACK },
+ { 9, TN(16), NULL, NULL, RED },
+ { 10, TN(11), TN(16), TN(30), BLACK },
+ { 15, TN(21), NULL, NULL, BLACK }
};
#define RANDOM_OPS_TREE( i ) \
@@ -1698,13 +1698,6 @@ rtems_task Init( rtems_task_argument ignored )
rtems_test_assert( !rtems_rbtree_is_node_off_tree( &node1.Node ) );
- 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(rtems_rbtree_root(&rbtree1)) )
puts( "INIT - FAILED TREE CHECK" );
@@ -2027,10 +2020,8 @@ rtems_task Init( rtems_task_argument ignored )
rtems_test_exit(0);
}
- 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" );
+ if ( rb_color( rtems_rbtree_root(&rbtree1) ) != BLACK )
+ puts ( "INIT - ERROR ON RBTREE ROOT IS BLACK MISMATCH" );
puts( "INIT - Removing 100 nodes" );
--
1.8.4.5
More information about the devel
mailing list