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

File:

• uspace/lib/c/generic/async.c (modified) (18 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 */
@@ -203 +205 @@
 /* Client connection data */
 typedef struct {
-        ht_link_t link;
+        link_t link;
         
         task_id_t in_task_id;
@@ -215 +217 @@
         
         /** Hash table link. */
-        ht_link_t link;
+        link_t link;
         
         /** Incoming client task ID. */
@@ -391 +393 @@
 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 +429 @@
  *
  */
-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 +510 @@
         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 +518 @@
         }
         
-        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));
@@ -628 +638 @@
         
         if (usecs) {
-                getuptime(&conn->wdata.to_event.expires);
+                gettimeofday(&conn->wdata.to_event.expires, NULL);
                 tv_add(&conn->wdata.to_event.expires, usecs);
         } else
@@ -688 +698 @@
 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 +716 @@
                 
                         atomic_set(&client->refcnt, 1);
-                        hash_table_insert(&client_hash_table, &client->link);
+                        hash_table_insert(&client_hash_table, key, &client->link);
                 }
         }
@@ -713 +727 @@
 {
         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 +831 @@
          */
         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 +916 @@
         
         /* 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);
         
@@ -947 +967 @@
 {
         struct timeval tv;
-        getuptime(&tv);
+        gettimeofday(&tv, NULL);
         
         futex_down(&async_futex);
@@ -1004 +1024 @@
                         
                         struct timeval tv;
-                        getuptime(&tv);
+                        gettimeofday(&tv, NULL);
                         
                         if (tv_gteq(&tv, &waiter->to_event.expires)) {
@@ -1091 +1111 @@
 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();
         
@@ -1309 +1331 @@
                 timeout = 0;
 
-        getuptime(&msg->wdata.to_event.expires);
+        gettimeofday(&msg->wdata.to_event.expires, NULL);
         tv_add(&msg->wdata.to_event.expires, timeout);
         
@@ -1391 +1413 @@
         msg->wdata.fid = fibril_get_id();
         
-        getuptime(&msg->wdata.to_event.expires);
+        gettimeofday(&msg->wdata.to_event.expires, NULL);
         tv_add(&msg->wdata.to_event.expires, timeout);