Changes in uspace/lib/c/generic/async.c [4e00f87:45cbcaf4] in mainline

File:

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

uspace/lib/c/generic/async.c

@@ -114 +114 @@
 #include <stdlib.h>
 #include <macros.h>
-#include "private/libc.h"
-
+
+#define CLIENT_HASH_TABLE_BUCKETS  32
+#define CONN_HASH_TABLE_BUCKETS    32
 
 /** Session data */
@@ -203 +204 @@
 /* Client connection data */
 typedef struct {
-        ht_link_t link;
+        link_t link;
         
         task_id_t in_task_id;
@@ -215 +216 @@
         
         /** Hash table link. */
-        ht_link_t link;
+        link_t link;
         
         /** Incoming client task ID. */
@@ -391 +392 @@
 static LIST_INITIALIZE(timeout_list);
 
-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;
-}
-
+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)
+{
+}
 
 /** Operations for the client hash table. */
-static hash_table_ops_t client_hash_table_ops = {
+static hash_table_operations_t client_hash_table_ops = {
         .hash = client_hash,
-        .key_hash = client_key_hash,
-        .key_equal = client_key_equal,
-        .equal = NULL,
-        .remove_callback = NULL
+        .compare = client_compare,
+        .remove_callback = client_remove
 };
 
@@ -427 +428 @@
  *
  */
-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);
-}
-
+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)
+{
+}
 
 /** Operations for the connection hash table. */
-static hash_table_ops_t conn_hash_table_ops = {
+static hash_table_operations_t conn_hash_table_ops = {
         .hash = conn_hash,
-        .key_hash = conn_key_hash,
-        .key_equal = conn_key_equal,
-        .equal = NULL,
-        .remove_callback = NULL
+        .compare = conn_compare,
+        .remove_callback = conn_remove
 };
 
@@ -501 +509 @@
         futex_down(&async_futex);
         
-        ht_link_t *hlp = hash_table_find(&conn_hash_table, &call->in_phone_hash);
+        unsigned long key = call->in_phone_hash;
+        link_t *hlp = hash_table_find(&conn_hash_table, &key);
         
         if (!hlp) {
@@ -508 +517 @@
         }
         
-        connection_t *conn = hash_table_get_inst(hlp, connection_t, link);
+        connection_t *conn = hash_table_get_instance(hlp, connection_t, link);
         
         msg_t *msg = malloc(sizeof(*msg));
@@ -688 +697 @@
 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);
-        ht_link_t *lnk = hash_table_find(&client_hash_table, &client_id);
+        link_t *lnk = hash_table_find(&client_hash_table, key);
         if (lnk) {
-                client = hash_table_get_inst(lnk, client_t, link);
+                client = hash_table_get_instance(lnk, client_t, link);
                 atomic_inc(&client->refcnt);
         } else if (create) {
@@ -702 +715 @@
                 
                         atomic_set(&client->refcnt, 1);
-                        hash_table_insert(&client_hash_table, &client->link);
+                        hash_table_insert(&client_hash_table, key, &client->link);
                 }
         }
@@ -713 +726 @@
 {
         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, &client->in_task_id);
+                hash_table_remove(&client_hash_table, key, 2);
                 destroy = true;
         } else
@@ -813 +830 @@
          */
         futex_down(&async_futex);
-        hash_table_remove(&conn_hash_table, &fibril_connection->in_phone_hash);
+        unsigned long key = fibril_connection->in_phone_hash;
+        hash_table_remove(&conn_hash_table, &key, 1);
         futex_up(&async_futex);
         
@@ -897 +915 @@
         
         /* Add connection to the connection hash table */
+        unsigned long key = conn->in_phone_hash;
         
         futex_down(&async_futex);
-        hash_table_insert(&conn_hash_table, &conn->link);
+        hash_table_insert(&conn_hash_table, &key, &conn->link);
         futex_up(&async_futex);
         
@@ -1091 +1110 @@
 void __async_init(void)
 {
-        if (!hash_table_create(&client_hash_table, 0, 0, &client_hash_table_ops))
+        if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS,
+            2, &client_hash_table_ops))
                 abort();
         
-        if (!hash_table_create(&conn_hash_table, 0, 0, &conn_hash_table_ops))
+        if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS,
+            1, &conn_hash_table_ops))
                 abort();
         
@@ -2145 +2166 @@
 int async_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
 {
-        return ipc_answer_3(callid, EOK, (sysarg_t) src, (sysarg_t) flags,
-            (sysarg_t) __entry);
+        return ipc_share_in_finalize(callid, src, flags);
 }
 
@@ -2213 +2233 @@
 int async_share_out_finalize(ipc_callid_t callid, void **dst)
 {
-        return ipc_answer_2(callid, EOK, (sysarg_t) __entry, (sysarg_t) dst);
+        return ipc_share_out_finalize(callid, dst);
 }
 
@@ -2297 +2317 @@
 int async_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
 {
-        return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) size);
+        return ipc_data_read_finalize(callid, src, size);
 }
 
@@ -2400 +2420 @@
 int async_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
 {
-        return ipc_answer_2(callid, EOK, (sysarg_t) dst, (sysarg_t) size);
+        return ipc_data_write_finalize(callid, dst, size);
 }