Ticket #1886: rbtree_duplicate_key3.diff

cpukit/sapi/include/rtems/rbtree.h

@@ -43 +43 @@
 typedef RBTree_Control rtems_rbtree_control;
 
 /**
+ * @typedef rtems_rbtree_compare_function
+ *
+ * This type defines function pointers for user-provided comparison
+ * function. The function compares two nodes in order to determine
+ * the order in a red-black tree.
+ */
+typedef RBTree_Compare_function rtems_rbtree_compare_function;
+
+/**
+ * @typedef rtems_rbtree_unique
+ *
+ * This enum type defines whether the tree can contain nodes with
+ * duplicate keys.
+ */
+typedef enum {
+  /** The tree is not unique, insertion of duplicate keys is performed
+   *  in a FIFO manner. */
+  RTEMS_RBTREE_DUPLICATE = false,
+  /** The tree is unique, insertion of duplicate key is refused. */
+  RTEMS_RBTREE_UNIQUE    = true
+} rtems_rbtree_unique;
+
+/**
  *  @brief RBTree initializer for an empty rbtree with designator @a name.
  */
 #define RTEMS_RBTREE_INITIALIZER_EMPTY(name) \

cpukit/sapi/inline/rtems/rbtree.inl

@@ -35 +35 @@
  *  @a starting_address.  Each node is of @a node_size bytes.
  */
 RTEMS_INLINE_ROUTINE void rtems_rbtree_initialize(
-  rtems_rbtree_control *the_rbtree,
-  void                 *compare_function,
-  void                 *starting_address,
-  size_t                number_nodes,
-  size_t                node_size
+  rtems_rbtree_control          *the_rbtree,
+  rtems_rbtree_compare_function  compare_function,
+  void                          *starting_address,
+  size_t                         number_nodes,
+  size_t                         node_size,
+  rtems_rbtree_unique            is_unique
 )
 {
   _RBTree_Initialize( the_rbtree, compare_function, starting_address,
-    number_nodes, node_size);
+    number_nodes, node_size, is_unique);
 }
 
 /**
@@ -52 +53 @@
  *  This routine initializes @a the_rbtree to contain zero nodes.
  */
 RTEMS_INLINE_ROUTINE void rtems_rbtree_initialize_empty(
-  rtems_rbtree_control *the_rbtree,
-  void                 *compare_function
+  rtems_rbtree_control          *the_rbtree,
+  rtems_rbtree_compare_function  compare_function,
+  rtems_rbtree_unique            is_unique
 )
 {
-  _RBTree_Initialize_empty( the_rbtree, compare_function );
+  _RBTree_Initialize_empty( the_rbtree, compare_function, is_unique );
 }
 
 /**
@@ -257 +259 @@
  *  This function returns a pointer to the node having key equal to the key
  *  of @a the_node if it exists within @a the_rbtree, and NULL if not.
  *  @a the_node has to be made up before a search.
+ *
+ *  @note If the tree is not unique and contains duplicate keys, the set
+ *        of duplicate keys acts as FIFO.
  */
 RTEMS_INLINE_ROUTINE rtems_rbtree_node* rtems_rbtree_find(
   rtems_rbtree_control *the_rbtree,
@@ -382 +387 @@
  *
  *  This routine inserts @a the_node on @a the_rbtree.
  *  It disables interrupts to ensure the atomicity of the insert operation.
+ *
+ *  @retval 0 Successfully inserted.
+ *  @retval -1 NULL @a the_node.
+ *  @retval RBTree_Node* if one with equal key to the key of @a the_node exists
+ *          in an unique @a the_rbtree.
  */
-RTEMS_INLINE_ROUTINE void rtems_rbtree_insert(
+RTEMS_INLINE_ROUTINE rtems_rbtree_node *rtems_rbtree_insert(
   rtems_rbtree_control *the_rbtree,
   rtems_rbtree_node *the_node
 )
 {
-  _RBTree_Insert( the_rbtree, the_node );
+  return _RBTree_Insert( the_rbtree, the_node );
+}
+
+/** @brief Determines whether the tree is unique
+ */
+RTEMS_INLINE_ROUTINE rtems_rbtree_unique rtems_rbtree_is_unique(
+    rtems_rbtree_control *the_rbtree
+)
+{
+  return( _RBTree_Is_unique(the_rbtree) );
 }
 
 #endif

cpukit/score/include/rtems/score/rbtree.h

@@ -100 +100 @@
 } RBTree_Direction;
 
 /**
+ * This type defines function pointers for user-provided comparison
+ * function. The function compares two nodes in order to determine
+ * the order in a red-black tree.
+ */
+typedef int (*RBTree_Compare_function)(
+    RBTree_Node *node1,
+    RBTree_Node *node2
+);
+
+/**
  *  @struct RBTree_Control
  *
  * This is used to manage a RBT.  A rbtree consists of a tree of zero or more
@@ -126 +136 @@
   /** This points to the min and max nodes of this RBT. */
   RBTree_Node *first[2];
   /**
-   * Comparison function pointer. Keys to compare has to be found
+   * Comparison function pointer. Keys to compare have to be found
    * inside to maintain generality. It has to return 1 if first node
    * has higher key than second, -1 if lower, 0 if equal.
    */
-  int (*compare_function) (RBTree_Node*, RBTree_Node*);
+  RBTree_Compare_function compare_function;
+  /** Determines whether the tree accepts duplicate keys. */
+  bool is_unique;
 } RBTree_Control;
 
 /**
@@ -142 +154 @@
   .root = NULL, \
   .first[0] = NULL, \
   .first[1] = NULL, \
-  .compare_function = NULL \
+  .compare_function = NULL, \
+  .is_unique = 0 \
 }
 
 /**
@@ -176 +189 @@
  *  @a starting_address.  Each node is of @a node_size bytes.
  */
 void _RBTree_Initialize(
-  RBTree_Control *the_rbtree,
-  void           *compare_function,
-  void           *starting_address,
-  size_t          number_nodes,
-  size_t          node_size
+  RBTree_Control          *the_rbtree,
+  RBTree_Compare_function  compare_function,
+  void                    *starting_address,
+  size_t                   number_nodes,
+  size_t                   node_size,
+  bool                     is_unique
 );
 
 /**
@@ -247 +261 @@
  *
  *  @retval 0 Successfully inserted.
  *  @retval -1 NULL @a the_node.
- *  @retval RBTree_Node* if one with equal value to @a the_node->value exists
- *          in @a the_rbtree.
+ *  @retval RBTree_Node* if one with equal value to @a the_node 's key exists
+ *          in an unique @a the_rbtree.
  *
  *  @note It does NOT disable interrupts to ensure the atomicity
  *        of the extract operation.
@@ -263 +277 @@
  *
  *  This routine inserts @a the_node on the tree @a the_rbtree.
  *
+ *  @retval 0 Successfully inserted.
+ *  @retval -1 NULL @a the_node.
+ *  @retval RBTree_Node* if one with equal value to @a the_node 's key exists
+ *          in an unique @a the_rbtree.
+ *
  *  @note It disables interrupts to ensure the atomicity
  *  of the extract operation.
  */
-void _RBTree_Insert(
+RBTree_Node *_RBTree_Insert(
   RBTree_Control *the_rbtree,
   RBTree_Node *the_node
 );

cpukit/score/inline/rtems/score/rbtree.inl

@@ -235 +235 @@
  *  This routine initializes @a the_rbtree to contain zero nodes.
  */
 RTEMS_INLINE_ROUTINE void _RBTree_Initialize_empty(
-    RBTree_Control *the_rbtree,
-    void           *compare_function
+    RBTree_Control          *the_rbtree,
+    RBTree_Compare_function  compare_function,
+    bool                     is_unique
     )
 {
   the_rbtree->permanent_null   = NULL;
@@ -244 +245 @@
   the_rbtree->first[0]         = NULL;
   the_rbtree->first[1]         = NULL;
   the_rbtree->compare_function = compare_function;
+  the_rbtree->is_unique        = is_unique;
 }
 
 /** @brief Return a pointer to node's grandparent
@@ -317 +319 @@
  *  This function returns a pointer to the node in @a the_rbtree 
  *  having key equal to key of  @a the_node if it exists,
  *  and NULL if not. @a the_node has to be made up before a search.
+ *
+ *  @note If the tree is not unique and contains duplicate keys, the set
+ *        of duplicate keys acts as FIFO.
  */
 RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
     RBTree_Control *the_rbtree,
@@ -324 +329 @@
     )
 {
   RBTree_Node* iter_node = the_rbtree->root;
+  RBTree_Node* found = NULL;
   int compare_result;
   while (iter_node) {
     compare_result = the_rbtree->compare_function(the_node, iter_node);
     if (compare_result == 0) {
-        return(iter_node);
+      found = iter_node;
+      if ( the_rbtree->is_unique )
+        break;
     }
 
-    RBTree_Direction dir = (compare_result != -1);
+    RBTree_Direction dir = (compare_result == 1);
     iter_node = iter_node->child[dir];
   } /* while(iter_node) */
 
-  return 0;
+  return found;
 }
 
 /** @brief Find the nodes in-order predecessor
@@ -428 +436 @@
   RBTree_Node *c;
   if (the_node == NULL) return;
   if (the_node->child[(1-dir)] == NULL) return;
-  
 
   c = the_node->child[(1-dir)];
   the_node->child[(1-dir)] = c->child[dir];
@@ -443 +450 @@
   c->parent = the_node->parent;
   the_node->parent = c;
 }
+
+/** @brief Determines whether the tree is unique
+ */
+RTEMS_INLINE_ROUTINE bool _RBTree_Is_unique(
+    RBTree_Control *the_rbtree
+)
+{
+  return( the_rbtree && the_rbtree->is_unique );
+}
 /**@}*/
 
 #endif

cpukit/score/src/rbtree.c

@@ -32 +32 @@
  */
 
 void _RBTree_Initialize(
-  RBTree_Control *the_rbtree,
-  void           *compare_function,
-  void           *starting_address,
-  size_t         number_nodes,
-  size_t         node_size
+  RBTree_Control          *the_rbtree,
+  RBTree_Compare_function  compare_function,
+  void                    *starting_address,
+  size_t                   number_nodes,
+  size_t                   node_size,
+  bool                     is_unique
 )
 {
   size_t      count;
@@ -46 +47 @@
   if (!the_rbtree) return;
 
   /* could do sanity checks here */
-  _RBTree_Initialize_empty(the_rbtree, compare_function);
+  _RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
 
   count = number_nodes;
   next  = starting_address;

cpukit/score/src/rbtreeinsert.c

@@ -72 +72 @@
  *  @retval 0 Successfully inserted.
  *  @retval -1 NULL @a the_node.
  *  @retval RBTree_Node* if one with equal key to the key of @a the_node exists
- *          in @a the_rbtree.
+ *          in an unique @a the_rbtree.
  *
  *  @note It does NOT disable interrupts to ensure the atomicity
  *        of the extract operation.
@@ -97 +97 @@
     /* typical binary search tree insert, descend tree to leaf and insert */
     while (iter_node) {
       compare_result = the_rbtree->compare_function(the_node, iter_node);
-      if ( !compare_result ) return iter_node;
+      if ( the_rbtree->is_unique && !compare_result )
+        return iter_node;
       RBTree_Direction dir = (compare_result != -1);
       if (!iter_node->child[dir]) {
         the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
@@ -138 +139 @@
  *    only case
  */
 
-void _RBTree_Insert(
+RBTree_Node *_RBTree_Insert(
   RBTree_Control *tree,
   RBTree_Node *node
 )
@@ -146 +147 @@
   ISR_Level level;
 
   _ISR_Disable( level );
-    _RBTree_Insert_unprotected( tree, node );
+    return _RBTree_Insert_unprotected( tree, node );
   _ISR_Enable( level );
 }

testsuites/sptests/sprbtree01/init.c

@@ -100 +100 @@
   puts( "\n\n*** TEST OF RTEMS RBTREE API ***" );
 
   puts( "Init - Initialize rbtree empty" );
-  rtems_rbtree_initialize_empty( &rbtree1, &test_compare_function );
-  
+  rtems_rbtree_initialize_empty( &rbtree1, &test_compare_function,
+                                 RTEMS_RBTREE_UNIQUE );
+
+  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;
@@ -111 +117 @@
   rtems_rbtree_insert( &rbtree1, &node1.Node );
   rtems_rbtree_insert( &rbtree1, &node2.Node );
 
-  p = _RBTree_Insert_unprotected( &rbtree1, NULL );
+  p = rtems_rbtree_insert( &rbtree1, NULL );
   if (p != (void *)(-1))
     puts( "INIT - FAILED NULL NODE INSERT" );
 
@@ -149 +155 @@
   puts("INIT - Verify rtems_rbtree_insert with the same value twice");
   node2.key = node1.key;
   rtems_rbtree_insert(&rbtree1, &node1.Node);
-  rtems_rbtree_insert(&rbtree1, &node2.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);
@@ -527 +537 @@
     node_array[i].key = i;
   }
   rtems_rbtree_initialize( &rbtree1, &test_compare_function,
-                           &node_array[0].Node, 100, sizeof(test_node));
+                           &node_array[0].Node, 100,
+                           sizeof(test_node), RTEMS_RBTREE_UNIQUE );
 
   puts( "INIT - Removing 100 nodes" );
 
@@ -553 +564 @@
     rtems_test_exit(0);
   }
 
+  /* Initialize the tree for duplicate keys */
+  puts( "Init - Initialize duplicate rbtree empty" );
+  rtems_rbtree_initialize_empty( &rbtree1, &test_compare_function,
+                                 RTEMS_RBTREE_DUPLICATE );
+
+  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);
 }

testsuites/sptests/sprbtree01/sprbtree01.scn

@@ -24 +24 @@
 INIT - Removing 20 nodes
 INIT - Verify rtems_rbtree_initialize with 100 nodes value [0,99]
 INIT - Removing 100 nodes
+Init - Initialize duplicate rbtree empty
+INIT - Verify rtems_rbtree_insert with 100 nodes value [0,99]
+INIT - Verify rtems_rbtree_find in a duplicate tree
+INIT - Removing 100 nodes
+INIT - Verify rtems_rbtree_insert with 100 nodes value [99,0]
+INIT - Verify rtems_rbtree_find in a duplicate tree
+INIT - Removing 100 nodes
 *** END OF RTEMS RBTREE API TEST ***