Changeset 062d900 in mainline for uspace/lib/c/generic/async.c

Timestamp:

2012-10-09T11:49:43Z (12 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

4e00f87

Parents:

87e9392

git-author:

Adam Hraska <adam.hraska+hos@…> (2012-10-09 11:49:43)

git-committer:

Jakub Jermar <jakub@…> (2012-10-09 11:49:43)

Message:

Cherrypick userspace hash table changes from lp:~adam-hraska+lp/helenos/rcu/.

File:

• uspace/lib/c/generic/async.c (modified) (13 diffs)

uspace/lib/c/generic/async.c

@@ -116 +116 @@
 #include "private/libc.h"
 
-#define CLIENT_HASH_TABLE_BUCKETS  32
-#define CONN_HASH_TABLE_BUCKETS    32
 
 /** Session data */
@@ -205 +203 @@
 /* Client connection data */
 typedef struct {
-        link_t link;
+        ht_link_t link;
         
         task_id_t in_task_id;
@@ -217 +215 @@
         
         /** Hash table link. */
-        link_t link;
+        ht_link_t link;
         
         /** Incoming client task ID. */
@@ -393 +391 @@
 static LIST_INITIALIZE(timeout_list);
 
-static hash_index_t client_hash(unsigned long key[])
-{
-        assert(key);
-        
-        return (((key[0]) >> 4) % CLIENT_HASH_TABLE_BUCKETS);
-}
-
-static int client_compare(unsigned long key[], hash_count_t keys, link_t *item)
-{
-        assert(key);
-        assert(keys == 2);
-        assert(item);
-        
-        client_t *client = hash_table_get_instance(item, client_t, link);
-        return (key[0] == LOWER32(client->in_task_id) &&
-            (key[1] == UPPER32(client->in_task_id)));
-}
-
-static void client_remove(link_t *item)
-{
-}
+static size_t client_key_hash(void *k)
+{
+        task_id_t key = *(task_id_t*)k;
+        return key;
+}
+
+static size_t client_hash(const ht_link_t *item)
+{
+        client_t *client = hash_table_get_inst(item, client_t, link);
+        return client_key_hash(&client->in_task_id);
+}
+
+static bool client_key_equal(void *k, const ht_link_t *item)
+{
+        task_id_t key = *(task_id_t*)k;
+        client_t *client = hash_table_get_inst(item, client_t, link);
+        return key == client->in_task_id;
+}
+
 
 /** Operations for the client hash table. */
-static hash_table_operations_t client_hash_table_ops = {
+static hash_table_ops_t client_hash_table_ops = {
         .hash = client_hash,
-        .compare = client_compare,
-        .remove_callback = client_remove
+        .key_hash = client_key_hash,
+        .key_equal = client_key_equal,
+        .equal = 0,
+        .remove_callback = 0
 };
 
@@ -429 +427 @@
  *
  */
-static hash_index_t conn_hash(unsigned long key[])
-{
-        assert(key);
-        
-        return (((key[0]) >> 4) % CONN_HASH_TABLE_BUCKETS);
-}
-
-/** Compare hash table item with a key.
- *
- * @param key  Array containing the source phone hash as the only item.
- * @param keys Expected 1 but ignored.
- * @param item Connection hash table item.
- *
- * @return True on match, false otherwise.
- *
- */
-static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item)
-{
-        assert(key);
-        assert(item);
-        
-        connection_t *conn = hash_table_get_instance(item, connection_t, link);
-        return (key[0] == conn->in_phone_hash);
-}
-
-static void conn_remove(link_t *item)
-{
-}
+static size_t conn_key_hash(void *key)
+{
+        sysarg_t in_phone_hash  = *(sysarg_t*)key;
+        return in_phone_hash ;
+}
+
+static size_t conn_hash(const ht_link_t *item)
+{
+        connection_t *conn = hash_table_get_inst(item, connection_t, link);
+        return conn_key_hash(&conn->in_phone_hash);
+}
+
+static bool conn_key_equal(void *key, const ht_link_t *item)
+{
+        sysarg_t in_phone_hash = *(sysarg_t*)key;
+        connection_t *conn = hash_table_get_inst(item, connection_t, link);
+        return (in_phone_hash == conn->in_phone_hash);
+}
+
 
 /** Operations for the connection hash table. */
-static hash_table_operations_t conn_hash_table_ops = {
+static hash_table_ops_t conn_hash_table_ops = {
         .hash = conn_hash,
-        .compare = conn_compare,
-        .remove_callback = conn_remove
+        .key_hash = conn_key_hash,
+        .key_equal = conn_key_equal,
+        .equal = 0,
+        .remove_callback = 0
 };
 
@@ -510 +501 @@
         futex_down(&async_futex);
         
-        unsigned long key = call->in_phone_hash;
-        link_t *hlp = hash_table_find(&conn_hash_table, &key);
+        ht_link_t *hlp = hash_table_find(&conn_hash_table, &call->in_phone_hash);
         
         if (!hlp) {
@@ -518 +508 @@
         }
         
-        connection_t *conn = hash_table_get_instance(hlp, connection_t, link);
+        connection_t *conn = hash_table_get_inst(hlp, connection_t, link);
         
         msg_t *msg = malloc(sizeof(*msg));
@@ -698 +688 @@
 static client_t *async_client_get(task_id_t client_id, bool create)
 {
-        unsigned long key[2] = {
-                LOWER32(client_id),
-                UPPER32(client_id),
-        };
         client_t *client = NULL;
 
         futex_down(&async_futex);
-        link_t *lnk = hash_table_find(&client_hash_table, key);
+        ht_link_t *lnk = hash_table_find(&client_hash_table, &client_id);
         if (lnk) {
-                client = hash_table_get_instance(lnk, client_t, link);
+                client = hash_table_get_inst(lnk, client_t, link);
                 atomic_inc(&client->refcnt);
         } else if (create) {
@@ -716 +702 @@
                 
                         atomic_set(&client->refcnt, 1);
-                        hash_table_insert(&client_hash_table, key, &client->link);
+                        hash_table_insert(&client_hash_table, &client->link);
                 }
         }
@@ -727 +713 @@
 {
         bool destroy;
-        unsigned long key[2] = {
-                LOWER32(client->in_task_id),
-                UPPER32(client->in_task_id)
-        };
-        
+
         futex_down(&async_futex);
         
         if (atomic_predec(&client->refcnt) == 0) {
-                hash_table_remove(&client_hash_table, key, 2);
+                hash_table_remove(&client_hash_table, &client->in_task_id);
                 destroy = true;
         } else
@@ -831 +813 @@
          */
         futex_down(&async_futex);
-        unsigned long key = fibril_connection->in_phone_hash;
-        hash_table_remove(&conn_hash_table, &key, 1);
+        hash_table_remove(&conn_hash_table, &fibril_connection->in_phone_hash);
         futex_up(&async_futex);
         
@@ -916 +897 @@
         
         /* Add connection to the connection hash table */
-        unsigned long key = conn->in_phone_hash;
         
         futex_down(&async_futex);
-        hash_table_insert(&conn_hash_table, &key, &conn->link);
+        hash_table_insert(&conn_hash_table, &conn->link);
         futex_up(&async_futex);
         
@@ -1111 +1091 @@
 void __async_init(void)
 {
-        if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS,
-            2, &client_hash_table_ops))
+        if (!hash_table_create(&client_hash_table, 0, 0, &client_hash_table_ops))
                 abort();
         
-        if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS,
-            1, &conn_hash_table_ops))
+        if (!hash_table_create(&conn_hash_table, 0, 0, &conn_hash_table_ops))
                 abort();