Changeset c28413a9 in mainline for kernel/generic/src/adt/cht.c

Timestamp:

2012-11-20T18:50:04Z (12 years ago)

Author:

Adam Hraska <adam.hraska+hos@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

ba368a6

Parents:

669f3d32

Message:

cht: Added cht_create_simple(). cht_create() can now block until memory is available.

File:

• kernel/generic/src/adt/cht.c (modified) (8 diffs)

kernel/generic/src/adt/cht.c

@@ -408 +408 @@
 
 static size_t size_to_order(size_t bucket_cnt, size_t min_order);
-static cht_buckets_t *alloc_buckets(size_t order, bool set_invalid);
+static cht_buckets_t *alloc_buckets(size_t order, bool set_invalid, 
+        bool can_block);
 static inline cht_link_t *find_lazy(cht_t *h, void *key);
 static cht_link_t *search_bucket(cht_t *h, marked_ptr_t head, void *key, 
@@ -478 +479 @@
 static void cas_order_barrier(void);
 
+static void dummy_remove_callback(cht_link_t *item)
+{
+        /* empty */
+}
+
+/** Creates a concurrent hash table.
+ * 
+ * @param h         Valid pointer to a cht_t instance.
+ * @param op        Item specific operations. All operations are compulsory.
+ * @return True if successfully created the table. False otherwise.
+ */
+bool cht_create_simple(cht_t *h, cht_ops_t *op)
+{
+        return cht_create(h, 0, 0, 0, false, op); 
+}
+
 /** Creates a concurrent hash table.
  * 
@@ -490 +507 @@
  * @param max_load  Maximum average number of items per bucket that allowed
  *                  before the table grows.
+ * @param can_block If true creating the table blocks until enough memory
+ *                  is available (possibly indefinitely). Otherwise, 
+ *                  table creation does not block and returns immediately
+ *                  even if not enough memory is available. 
  * @param op        Item specific operations. All operations are compulsory.
  * @return True if successfully created the table. False otherwise.
  */
 bool cht_create(cht_t *h, size_t init_size, size_t min_size, size_t max_load, 
-        cht_ops_t *op)
+        bool can_block, cht_ops_t *op)
 {
         ASSERT(h);
@@ -509 +530 @@
         size_t order = size_to_order(init_size, min_order);
         
-        h->b = alloc_buckets(order, false);
+        h->b = alloc_buckets(order, false, can_block);
         
         if (!h->b)
@@ -520 +541 @@
         atomic_set(&h->item_cnt, 0);
         atomic_set(&h->resize_reqs, 0);
+        
+        if (NULL == op->remove_callback) {
+                h->op->remove_callback = dummy_remove_callback;
+        }
+        
         /* 
          * Cached item hashes are stored in item->rcu_link.func. Once the item
@@ -539 +565 @@
  * @param set_invalid Bucket heads are marked invalid if true; otherwise
  *                    they are marked N_NORMAL.
+ * @param can_block   If true memory allocation blocks until enough memory
+ *                    is available (possibly indefinitely). Otherwise, 
+ *                    memory allocation does not block. 
  * @return Newly allocated and initialized buckets or NULL if not enough memory.
  */
-static cht_buckets_t *alloc_buckets(size_t order, bool set_invalid)
+static cht_buckets_t *alloc_buckets(size_t order, bool set_invalid, bool can_block)
 {
         size_t bucket_cnt = (1 << order);
         size_t bytes = 
                 sizeof(cht_buckets_t) + (bucket_cnt - 1) * sizeof(marked_ptr_t);
-        cht_buckets_t *b = malloc(bytes, FRAME_ATOMIC);
+        cht_buckets_t *b = malloc(bytes, can_block ? 0 : FRAME_ATOMIC);
         
         if (!b)
@@ -2145 +2174 @@
                 return;
         
-        h->new_b = alloc_buckets(h->b->order + 1, true);
+        h->new_b = alloc_buckets(h->b->order + 1, true, false);
 
         /* Failed to alloc a new table - try next time the resizer is run. */
@@ -2231 +2260 @@
                 return;
         
-        h->new_b = alloc_buckets(h->b->order - 1, true);
+        h->new_b = alloc_buckets(h->b->order - 1, true, false);
 
         /* Failed to alloc a new table - try next time the resizer is run. */