Changeset 062d900 in mainline for uspace/srv/ns


Ignore:
Timestamp:
2012-10-09T11:49:43Z (13 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/.

Location:
uspace/srv/ns
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/ns/service.c

    r87e9392 r062d900  
    4040#include "ns.h"
    4141
    42 #define SERVICE_HASH_TABLE_CHAINS  20
    4342
    4443/** Service hash table item. */
    4544typedef struct {
    46         link_t link;
     45        ht_link_t link;
    4746        sysarg_t service;        /**< Service ID. */
    4847        sysarg_t phone;          /**< Phone registered with the service. */
    … …  
    5049} hashed_service_t;
    5150
    52 /** Compute hash index into service hash table.
    53  *
    54  * @param key Pointer keys. However, only the first key (i.e. service number)
    55  *            is used to compute the hash index.
    56  *
    57  * @return Hash index corresponding to key[0].
    58  *
    59  */
    60 static hash_index_t service_hash(unsigned long key[])
     51
     52static size_t service_key_hash(void *key)
    6153{
    62         assert(key);
    63         return (key[0] % SERVICE_HASH_TABLE_CHAINS);
     54        return *(sysarg_t*)key;
    6455}
    6556
    66 /** Compare a key with hashed item.
    67  *
    68  * This compare function always ignores the third key.
    69  * It exists only to make it possible to remove records
    70  * originating from connection with key[1] in_phone_hash
    71  * value. Note that this is close to being classified
    72  * as a nasty hack.
    73  *
    74  * @param key  Array of keys.
    75  * @param keys Must be lesser or equal to 3.
    76  * @param item Pointer to a hash table item.
    77  *
    78  * @return Non-zero if the key matches the item, zero otherwise.
    79  *
    80  */
    81 static int service_compare(unsigned long key[], hash_count_t keys, link_t *item)
     57static size_t service_hash(const ht_link_t *item)
    8258{
    83         assert(key);
    84         assert(keys <= 3);
    85         assert(item);
    86        
    87         hashed_service_t *hs = hash_table_get_instance(item, hashed_service_t, link);
    88        
    89         if (keys == 2)
    90                 return ((key[0] == hs->service) && (key[1] == hs->in_phone_hash));
    91         else
    92                 return (key[0] == hs->service);
     59        hashed_service_t *hs = hash_table_get_inst(item, hashed_service_t, link);
     60        return hs->service;
    9361}
    9462
    95 /** Perform actions after removal of item from the hash table.
    96  *
    97  * @param item Item that was removed from the hash table.
    98  *
    99  */
    100 static void service_remove(link_t *item)
     63static bool service_key_equal(void *key, const ht_link_t *item)
    10164{
    102         assert(item);
    103         free(hash_table_get_instance(item, hashed_service_t, link));
     65        hashed_service_t *hs = hash_table_get_inst(item, hashed_service_t, link);
     66        return hs->service == *(sysarg_t*)key;
    10467}
    10568
    10669/** Operations for service hash table. */
    107 static hash_table_operations_t service_hash_table_ops = {
     70static hash_table_ops_t service_hash_table_ops = {
    10871        .hash = service_hash,
    109         .compare = service_compare,
    110         .remove_callback = service_remove
     72        .key_hash = service_key_hash,
     73        .key_equal = service_key_equal,
     74        .equal = 0,
     75        .remove_callback = 0
    11176};
    11277
    … …  
    12792int service_init(void)
    12893{
    129         if (!hash_table_create(&service_hash_table, SERVICE_HASH_TABLE_CHAINS,
    130             3, &service_hash_table_ops)) {
     94        if (!hash_table_create(&service_hash_table, 0, 0, &service_hash_table_ops)) {
    13195                printf(NAME ": No memory available for services\n");
    13296                return ENOMEM;
    … …  
    145109                pending_conn_t *pr = list_get_instance(cur, pending_conn_t, link);
    146110               
    147                 unsigned long keys[3] = {
    148                         pr->service,
    149                         0,
    150                         0
    151                 };
    152                
    153                 link_t *link = hash_table_find(&service_hash_table, keys);
     111                ht_link_t *link = hash_table_find(&service_hash_table, &pr->service);
    154112                if (!link)
    155113                        continue;
    156114               
    157                 hashed_service_t *hs = hash_table_get_instance(link, hashed_service_t, link);
     115                hashed_service_t *hs = hash_table_get_inst(link, hashed_service_t, link);
    158116                (void) ipc_forward_fast(pr->callid, hs->phone, pr->arg2,
    159117                    pr->arg3, 0, IPC_FF_NONE);
    … …  
    176134int register_service(sysarg_t service, sysarg_t phone, ipc_call_t *call)
    177135{
    178         unsigned long keys[3] = {
    179                 service,
    180                 call->in_phone_hash,
    181                 0
    182         };
    183        
    184         if (hash_table_find(&service_hash_table, keys))
     136        if (hash_table_find(&service_hash_table, &service))
    185137                return EEXISTS;
    186138       
    … …  
    189141                return ENOMEM;
    190142       
    191         link_initialize(&hs->link);
    192143        hs->service = service;
    193144        hs->phone = phone;
    194145        hs->in_phone_hash = call->in_phone_hash;
    195         hash_table_insert(&service_hash_table, keys, &hs->link);
     146        hash_table_insert(&service_hash_table, &hs->link);
    196147       
    197148        return EOK;
    … …  
    210161{
    211162        sysarg_t retval;
    212         unsigned long keys[3] = {
    213                 service,
    214                 0,
    215                 0
    216         };
    217163       
    218         link_t *link = hash_table_find(&service_hash_table, keys);
     164        ht_link_t *link = hash_table_find(&service_hash_table, &service);
    219165        if (!link) {
    220166                if (IPC_GET_ARG4(*call) & IPC_FLAG_BLOCKING) {
    … …  
    239185        }
    240186       
    241         hashed_service_t *hs = hash_table_get_instance(link, hashed_service_t, link);
     187        hashed_service_t *hs = hash_table_get_inst(link, hashed_service_t, link);
    242188        (void) ipc_forward_fast(callid, hs->phone, IPC_GET_ARG2(*call),
    243189            IPC_GET_ARG3(*call), 0, IPC_FF_NONE);

  • uspace/srv/ns/task.c

    r87e9392 r062d900  
    4343#include "ns.h"
    4444
    45 #define TASK_HASH_TABLE_CHAINS  256
    46 #define P2I_HASH_TABLE_CHAINS   256
    4745
    4846/* TODO:
    … …  
    5553/** Task hash table item. */
    5654typedef struct {
    57         link_t link;
     55        ht_link_t link;
    5856       
    5957        task_id_t id;    /**< Task ID. */
    … …  
    6361} hashed_task_t;
    6462
    65 /** Compute hash index into task hash table.
    66  *
    67  * @param key Pointer keys. However, only the first key (i.e. truncated task
    68  *            number) is used to compute the hash index.
    69  *
    70  * @return Hash index corresponding to key[0].
    71  *
    72  */
    73 static hash_index_t task_hash(unsigned long key[])
    74 {
    75         assert(key);
    76         return (LOWER32(key[0]) % TASK_HASH_TABLE_CHAINS);
    77 }
    78 
    79 /** Compare a key with hashed item.
    80  *
    81  * @param key  Array of keys.
    82  * @param keys Must be less than or equal to 2.
    83  * @param item Pointer to a hash table item.
    84  *
    85  * @return Non-zero if the key matches the item, zero otherwise.
    86  *
    87  */
    88 static int task_compare(unsigned long key[], hash_count_t keys, link_t *item)
    89 {
    90         assert(key);
    91         assert(keys <= 2);
    92         assert(item);
    93        
    94         hashed_task_t *ht = hash_table_get_instance(item, hashed_task_t, link);
    95        
    96         if (keys == 2)
    97                 return ((LOWER32(key[1]) == UPPER32(ht->id))
    98                     && (LOWER32(key[0]) == LOWER32(ht->id)));
    99         else
    100                 return (LOWER32(key[0]) == LOWER32(ht->id));
    101 }
    102 
    103 /** Perform actions after removal of item from the hash table.
    104  *
    105  * @param item Item that was removed from the hash table.
    106  *
    107  */
    108 static void task_remove(link_t *item)
    109 {
    110         assert(item);
    111         free(hash_table_get_instance(item, hashed_task_t, link));
     63
     64static size_t task_key_hash(void *key)
     65{
     66        return *(task_id_t*)key;
     67}
     68
     69static size_t task_hash(const ht_link_t  *item)
     70{
     71        hashed_task_t *ht = hash_table_get_inst(item, hashed_task_t, link);
     72        return ht->id;
     73}
     74
     75static bool task_key_equal(void *key, const ht_link_t *item)
     76{
     77        hashed_task_t *ht = hash_table_get_inst(item, hashed_task_t, link);
     78        return ht->id == *(task_id_t*)key;
     79}
     80
     81/** Perform actions after removal of item from the hash table. */
     82static void task_remove(ht_link_t *item)
     83{
     84        free(hash_table_get_inst(item, hashed_task_t, link));
    11285}
    11386
    11487/** Operations for task hash table. */
    115 static hash_table_operations_t task_hash_table_ops = {
     88static hash_table_ops_t task_hash_table_ops = {
    11689        .hash = task_hash,
    117         .compare = task_compare,
     90        .key_hash = task_key_hash,
     91        .key_equal = task_key_equal,
     92        .equal = 0,
    11893        .remove_callback = task_remove
    11994};
    … …  
    12398
    12499typedef struct {
    125         link_t link;
     100        ht_link_t link;
    126101        sysarg_t in_phone_hash;  /**< Incoming phone hash. */
    127102        task_id_t id;            /**< Task ID. */
    128103} p2i_entry_t;
    129104
    130 /** Compute hash index into task hash table.
    131  *
    132  * @param key Array of keys.
    133  *
    134  * @return Hash index corresponding to key[0].
    135  *
    136  */
    137 static hash_index_t p2i_hash(unsigned long key[])
    138 {
    139         assert(key);
    140         return (key[0] % TASK_HASH_TABLE_CHAINS);
    141 }
    142 
    143 /** Compare a key with hashed item.
    144  *
    145  * @param key  Array of keys.
    146  * @param keys Must be less than or equal to 1.
    147  * @param item Pointer to a hash table item.
    148  *
    149  * @return Non-zero if the key matches the item, zero otherwise.
    150  *
    151  */
    152 static int p2i_compare(unsigned long key[], hash_count_t keys, link_t *item)
    153 {
    154         assert(key);
    155         assert(keys == 1);
     105/* phone-to-id hash table operations */
     106
     107static size_t p2i_key_hash(void *key)
     108{
     109        sysarg_t in_phone_hash = *(sysarg_t*)key;
     110        return in_phone_hash;
     111}
     112
     113static size_t p2i_hash(const ht_link_t *item)
     114{
     115        p2i_entry_t *entry = hash_table_get_inst(item, p2i_entry_t, link);
     116        return entry->in_phone_hash;
     117}
     118
     119static bool p2i_key_equal(void *key, const ht_link_t *item)
     120{
     121        sysarg_t in_phone_hash = *(sysarg_t*)key;
     122        p2i_entry_t *entry = hash_table_get_inst(item, p2i_entry_t, link);
     123       
     124        return (in_phone_hash == entry->in_phone_hash);
     125}
     126
     127/** Perform actions after removal of item from the hash table.
     128 *
     129 * @param item Item that was removed from the hash table.
     130 *
     131 */
     132static void p2i_remove(ht_link_t *item)
     133{
    156134        assert(item);
    157        
    158         p2i_entry_t *entry = hash_table_get_instance(item, p2i_entry_t, link);
    159        
    160         return (key[0] == entry->in_phone_hash);
    161 }
    162 
    163 /** Perform actions after removal of item from the hash table.
    164  *
    165  * @param item Item that was removed from the hash table.
    166  *
    167  */
    168 static void p2i_remove(link_t *item)
    169 {
    170         assert(item);
    171         free(hash_table_get_instance(item, p2i_entry_t, link));
     135        free(hash_table_get_inst(item, p2i_entry_t, link));
    172136}
    173137
    174138/** Operations for task hash table. */
    175 static hash_table_operations_t p2i_ops = {
     139static hash_table_ops_t p2i_ops = {
    176140        .hash = p2i_hash,
    177         .compare = p2i_compare,
     141        .key_hash = p2i_key_hash,
     142        .key_equal = p2i_key_equal,
     143        .equal = 0,
    178144        .remove_callback = p2i_remove
    179145};
    … …  
    193159int task_init(void)
    194160{
    195         if (!hash_table_create(&task_hash_table, TASK_HASH_TABLE_CHAINS,
    196             2, &task_hash_table_ops)) {
     161        if (!hash_table_create(&task_hash_table, 0, 0, &task_hash_table_ops)) {
    197162                printf(NAME ": No memory available for tasks\n");
    198163                return ENOMEM;
    199164        }
    200165       
    201         if (!hash_table_create(&phone_to_id, P2I_HASH_TABLE_CHAINS,
    202             1, &p2i_ops)) {
     166        if (!hash_table_create(&phone_to_id, 0, 0, &p2i_ops)) {
    203167                printf(NAME ": No memory available for tasks\n");
    204168                return ENOMEM;
    … …  
    218182                pending_wait_t *pr = list_get_instance(cur, pending_wait_t, link);
    219183               
    220                 unsigned long keys[2] = {
    221                         LOWER32(pr->id),
    222                         UPPER32(pr->id)
    223                 };
    224                
    225                 link_t *link = hash_table_find(&task_hash_table, keys);
     184                ht_link_t *link = hash_table_find(&task_hash_table, &pr->id);
    226185                if (!link)
    227186                        continue;
    228187               
    229                 hashed_task_t *ht = hash_table_get_instance(link, hashed_task_t, link);
     188                hashed_task_t *ht = hash_table_get_inst(link, hashed_task_t, link);
    230189                if (!ht->finished)
    231190                        continue;
    … …  
    238197                }
    239198               
    240                 hash_table_remove(&task_hash_table, keys, 2);
     199                hash_table_remove(&task_hash_table, &pr->id);
    241200                list_remove(cur);
    242201                free(pr);
    … …  
    250209        task_exit_t texit;
    251210       
    252         unsigned long keys[2] = {
    253                 LOWER32(id),
    254                 UPPER32(id)
    255         };
    256        
    257         link_t *link = hash_table_find(&task_hash_table, keys);
     211        ht_link_t *link = hash_table_find(&task_hash_table, &id);
    258212        hashed_task_t *ht = (link != NULL) ?
    259             hash_table_get_instance(link, hashed_task_t, link) : NULL;
     213            hash_table_get_inst(link, hashed_task_t, link) : NULL;
    260214       
    261215        if (ht == NULL) {
    … …  
    281235        }
    282236       
    283         hash_table_remove(&task_hash_table, keys, 2);
     237        hash_table_remove_item(&task_hash_table, link);
    284238        retval = EOK;
    285239       
    … …  
    293247int ns_task_id_intro(ipc_call_t *call)
    294248{
    295         unsigned long keys[2];
    296249       
    297250        task_id_t id = MERGE_LOUP32(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call));
    298         keys[0] = call->in_phone_hash;
    299        
    300         link_t *link = hash_table_find(&phone_to_id, keys);
     251
     252        ht_link_t *link = hash_table_find(&phone_to_id, &call->in_phone_hash);
    301253        if (link != NULL)
    302254                return EEXISTS;
    … …  
    314266         */
    315267       
    316         link_initialize(&entry->link);
    317268        entry->in_phone_hash = call->in_phone_hash;
    318269        entry->id = id;
    319         hash_table_insert(&phone_to_id, keys, &entry->link);
     270        hash_table_insert(&phone_to_id, &entry->link);
    320271       
    321272        /*
    … …  
    323274         */
    324275       
    325         keys[0] = LOWER32(id);
    326         keys[1] = UPPER32(id);
    327        
    328         link_initialize(&ht->link);
    329276        ht->id = id;
    330277        ht->finished = false;
    331278        ht->have_rval = false;
    332279        ht->retval = -1;
    333         hash_table_insert(&task_hash_table, keys, &ht->link);
     280        hash_table_insert(&task_hash_table, &ht->link);
    334281       
    335282        return EOK;
    … …  
    338285static int get_id_by_phone(sysarg_t phone_hash, task_id_t *id)
    339286{
    340         unsigned long keys[1] = {phone_hash};
    341        
    342         link_t *link = hash_table_find(&phone_to_id, keys);
     287        ht_link_t *link = hash_table_find(&phone_to_id, &phone_hash);
    343288        if (link == NULL)
    344289                return ENOENT;
    345290       
    346         p2i_entry_t *entry = hash_table_get_instance(link, p2i_entry_t, link);
     291        p2i_entry_t *entry = hash_table_get_inst(link, p2i_entry_t, link);
    347292        *id = entry->id;
    348293       
    … …  
    357302                return rc;
    358303       
    359         unsigned long keys[2] = {
    360                 LOWER32(id),
    361                 UPPER32(id)
    362         };
    363        
    364         link_t *link = hash_table_find(&task_hash_table, keys);
     304        ht_link_t *link = hash_table_find(&task_hash_table, &id);
    365305        hashed_task_t *ht = (link != NULL) ?
    366             hash_table_get_instance(link, hashed_task_t, link) : NULL;
     306            hash_table_get_inst(link, hashed_task_t, link) : NULL;
    367307       
    368308        if ((ht == NULL) || (ht->finished))
    … …  
    378318int ns_task_disconnect(ipc_call_t *call)
    379319{
    380         unsigned long keys[2];
    381        
    382320        task_id_t id;
    383321        int rc = get_id_by_phone(call->in_phone_hash, &id);
    … …  
    386324       
    387325        /* Delete from phone-to-id map. */
    388         keys[0] = call->in_phone_hash;
    389         hash_table_remove(&phone_to_id, keys, 1);
     326        hash_table_remove(&phone_to_id, &call->in_phone_hash);
    390327       
    391328        /* Mark task as finished. */
    392         keys[0] = LOWER32(id);
    393         keys[1] = UPPER32(id);
    394        
    395         link_t *link = hash_table_find(&task_hash_table, keys);
    396         hashed_task_t *ht =
    397             hash_table_get_instance(link, hashed_task_t, link);
    398         if (ht == NULL)
     329        ht_link_t *link = hash_table_find(&task_hash_table, &id);
     330        if (link == NULL)
    399331                return EOK;
     332
     333        hashed_task_t *ht = hash_table_get_inst(link, hashed_task_t, link);
    400334       
    401335        ht->finished = true;
Note: See TracChangeset for help on using the changeset viewer.