Changeset 38fc00b in mainline for uspace/srv/fs/udf/udf_idx.c

Timestamp:

2012-10-09T20:42:32Z (12 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

97b199b1

Parents:

4e00f87

Message:

Convert UDF to use the new hash table.

File:

• uspace/srv/fs/udf/udf_idx.c (modified) (5 diffs)

uspace/srv/fs/udf/udf_idx.c

@@ -42 +42 @@
 #include <malloc.h>
 #include <adt/hash_table.h>
+#include <adt/hash.h>
 #include <adt/list.h>
+#include <bool.h>
 #include "udf_idx.h"
 #include "udf.h"
 
-#define UDF_IDX_KEYS  2
-#define UDF_IDX_KEY   1
-
-#define UDF_IDX_SERVICE_ID_KEY  0
-#define UDF_IDX_BUCKETS         1024
-
 static FIBRIL_MUTEX_INITIALIZE(udf_idx_lock);
 
 static hash_table_t udf_idx;
 
-/** Calculate value of hash by key
- *
- * @param Key for calculation of function
- *
- * @return Value of hash function
- *
- */
-static hash_index_t udf_idx_hash(unsigned long key[])
-{
-        /* TODO: This is very simple and probably can be improved */
-        return key[UDF_IDX_KEY] % UDF_IDX_BUCKETS;
-}
-
-/** Compare two items of hash table
- *
- * @param key  Key of hash table item. Include several items.
- * @param keys Number of parts of key.
- * @param item Item of hash table
- *
- * @return True if input value of key equivalent key of node from hash table
- *
- */
-static int udf_idx_compare(unsigned long key[], hash_count_t keys, link_t *item)
-{
-        assert(keys > 0);
-        
-        udf_node_t *node = hash_table_get_instance(item, udf_node_t, link);
-        
-        if (node->instance->service_id !=
-            ((service_id_t) key[UDF_IDX_SERVICE_ID_KEY]))
-                return false;
-        
-        assert(keys == 2);
-        return (node->index == key[UDF_IDX_KEY]);
-}
-
-/** Remove callback
- *
- */
-static void udf_idx_remove_cb(link_t *link)
-{
-        /* We don't use remove callback for this hash table */
-}
-
-static hash_table_operations_t udf_idx_ops = {
+typedef struct {
+        service_id_t service_id;
+        fs_index_t index;
+} udf_ht_key_t; 
+
+static size_t udf_idx_hash(const ht_link_t *item)
+{
+        udf_node_t *node = hash_table_get_inst(item, udf_node_t, link);
+        return hash_combine(node->instance->service_id, node->index);
+}
+
+static size_t udf_idx_key_hash(void *k)
+{
+        udf_ht_key_t *key = (udf_ht_key_t *) k;
+        return hash_combine(key->service_id, key->index);
+}
+
+static bool udf_idx_key_equal(void *k, const ht_link_t *item)
+{
+        udf_ht_key_t *key = (udf_ht_key_t *) k;
+        udf_node_t *node = hash_table_get_inst(item, udf_node_t, link);
+
+        return (key->service_id == node->instance->service_id) &&
+            (key->index == node->index);
+}
+
+static hash_table_ops_t udf_idx_ops = {
         .hash = udf_idx_hash,
-        .compare = udf_idx_compare,
-        .remove_callback = udf_idx_remove_cb,
+        .key_hash = udf_idx_key_hash,
+        .key_equal = udf_idx_key_equal,
+        .equal = NULL,
+        .remove_callback = NULL 
 };
 
@@ -113 +93 @@
 int udf_idx_init(void)
 {
-        if (!hash_table_create(&udf_idx, UDF_IDX_BUCKETS, UDF_IDX_KEYS,
-            &udf_idx_ops))
+        if (!hash_table_create(&udf_idx, 0, 0, &udf_idx_ops))
                 return ENOMEM;
         
@@ -143 +122 @@
 {
         fibril_mutex_lock(&udf_idx_lock);
-        
-        unsigned long key[] = {
-                [UDF_IDX_SERVICE_ID_KEY] = instance->service_id,
-                [UDF_IDX_KEY] = index
+
+        udf_ht_key_t key = {
+                .service_id = instance->service_id,
+                .index = index
         };
         
-        link_t *already_open = hash_table_find(&udf_idx, key);
+        ht_link_t *already_open = hash_table_find(&udf_idx, &key);
         if (already_open) {
-                udf_node_t *node = hash_table_get_instance(already_open,
+                udf_node_t *node = hash_table_get_inst(already_open,
                     udf_node_t, link);
                 node->ref_cnt++;
@@ -202 +181 @@
         
         fibril_mutex_initialize(&udf_node->lock);
-        link_initialize(&udf_node->link);
         fs_node->data = udf_node;
         
-        unsigned long key[] = {
-                [UDF_IDX_SERVICE_ID_KEY] = instance->service_id,
-                [UDF_IDX_KEY] = index
-        };
-        
-        hash_table_insert(&udf_idx, key, &udf_node->link);
+        hash_table_insert(&udf_idx, &udf_node->link);
         instance->open_nodes_count++;
         
@@ -232 +205 @@
         fibril_mutex_lock(&udf_idx_lock);
         
-        unsigned long key[] = {
-                [UDF_IDX_SERVICE_ID_KEY] = node->instance->service_id,
-                [UDF_IDX_KEY] = node->index
-        };
-        
-        hash_table_remove(&udf_idx, key, UDF_IDX_KEYS);
+        hash_table_remove_item(&udf_idx, &node->link);
         
         assert(node->instance->open_nodes_count > 0);