Changeset bc216a0 in mainline for uspace/srv/devman/devman.c


Ignore:
Timestamp:
2012-08-07T22:13:44Z (12 years ago)
Author:
Adam Hraska <adam.hraska+hos@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
da68871a
Parents:
b17518e
Message:

Refactored any users of hash_table to use opaque void* keys instead of the cumbersome unsigned long[] keys. Switched from the ad hoc computations of hashes of multiple values to hash_combine().

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/devman.c

    rb17518e rbc216a0  
    6666/* hash table operations */
    6767
    68 static size_t devices_key_hash(unsigned long key[])
    69 {
    70         return key[0];
    71 }
    72 
    73 static size_t devman_devices_hash(const link_t *item)
    74 {
    75         dev_node_t *dev = hash_table_get_instance(item, dev_node_t, devman_dev);
    76         unsigned long key = dev->handle;
    77         return devices_key_hash(&key);
    78 }
    79 
    80 static size_t devman_functions_hash(const link_t *item)
    81 {
    82         fun_node_t *fun = hash_table_get_instance(item, fun_node_t, devman_fun);
    83         unsigned long key = fun->handle;
    84         return devices_key_hash(&key);
    85 }
    86 
    87 static size_t loc_functions_hash(const link_t *item)
    88 {
    89         fun_node_t *fun = hash_table_get_instance(item, fun_node_t, loc_fun);
    90         unsigned long key = fun->service_id;
    91         return devices_key_hash(&key);
    92 }
    93 
    94 static bool devman_devices_match(unsigned long key[], size_t keys,
    95     const link_t *item)
    96 {
    97         dev_node_t *dev = hash_table_get_instance(item, dev_node_t, devman_dev);
    98         return (dev->handle == (devman_handle_t) key[0]);
    99 }
    100 
    101 static bool devman_functions_match(unsigned long key[], size_t keys,
    102     const link_t *item)
    103 {
    104         fun_node_t *fun = hash_table_get_instance(item, fun_node_t, devman_fun);
    105         return (fun->handle == (devman_handle_t) key[0]);
    106 }
    107 
    108 static bool loc_functions_match(unsigned long key[], size_t keys,
    109     const link_t *item)
    110 {
    111         fun_node_t *fun = hash_table_get_instance(item, fun_node_t, loc_fun);
    112         return (fun->service_id == (service_id_t) key[0]);
     68static inline size_t handle_key_hash(void *key)
     69{
     70        devman_handle_t handle = *(devman_handle_t*)key;
     71        return handle;
     72}
     73
     74static size_t devman_devices_hash(const ht_link_t *item)
     75{
     76        dev_node_t *dev = hash_table_get_inst(item, dev_node_t, devman_dev);
     77        return handle_key_hash(&dev->handle);
     78}
     79
     80static size_t devman_functions_hash(const ht_link_t *item)
     81{
     82        fun_node_t *fun = hash_table_get_inst(item, fun_node_t, devman_fun);
     83        return handle_key_hash(&fun->handle);
     84}
     85
     86static bool devman_devices_key_equal(void *key, const ht_link_t *item)
     87{
     88        devman_handle_t handle = *(devman_handle_t*)key;
     89        dev_node_t *dev = hash_table_get_inst(item, dev_node_t, devman_dev);
     90        return dev->handle == handle;
     91}
     92
     93static bool devman_functions_key_equal(void *key, const ht_link_t *item)
     94{
     95        devman_handle_t handle = *(devman_handle_t*)key;
     96        fun_node_t *fun = hash_table_get_inst(item, fun_node_t, devman_fun);
     97        return fun->handle == handle;
     98}
     99
     100static inline size_t service_id_key_hash(void *key)
     101{
     102        service_id_t service_id = *(service_id_t*)key;
     103        return service_id;
     104}
     105
     106static size_t loc_functions_hash(const ht_link_t *item)
     107{
     108        fun_node_t *fun = hash_table_get_inst(item, fun_node_t, loc_fun);
     109        return service_id_key_hash(&fun->service_id);
     110}
     111
     112static bool loc_functions_key_equal(void *key, const ht_link_t *item)
     113{
     114        service_id_t service_id = *(service_id_t*)key;
     115        fun_node_t *fun = hash_table_get_inst(item, fun_node_t, loc_fun);
     116        return fun->service_id == service_id;
    113117}
    114118
    … …  
    116120static hash_table_ops_t devman_devices_ops = {
    117121        .hash = devman_devices_hash,
    118         .key_hash = devices_key_hash,
    119         .match = devman_devices_match,
     122        .key_hash = handle_key_hash,
     123        .key_equal = devman_devices_key_equal,
    120124        .equal = 0,
    121125        .remove_callback = 0
    … …  
    124128static hash_table_ops_t devman_functions_ops = {
    125129        .hash = devman_functions_hash,
    126         .key_hash = devices_key_hash,
    127         .match = devman_functions_match,
     130        .key_hash = handle_key_hash,
     131        .key_equal = devman_functions_key_equal,
    128132        .equal = 0,
    129133        .remove_callback = 0
    … …  
    132136static hash_table_ops_t loc_devices_ops = {
    133137        .hash = loc_functions_hash,
    134         .key_hash = devices_key_hash,
    135         .match = loc_functions_match,
     138        .key_hash = service_id_key_hash,
     139        .key_equal = loc_functions_key_equal,
    136140        .equal = 0,
    137141        .remove_callback = 0
    … …  
    9981002        tree->current_handle = 0;
    9991003       
    1000         hash_table_create(&tree->devman_devices, 0, 1, &devman_devices_ops);
    1001         hash_table_create(&tree->devman_functions, 0, 1, &devman_functions_ops);
    1002         hash_table_create(&tree->loc_functions, 0, 1, &loc_devices_ops);
     1004        hash_table_create(&tree->devman_devices, 0, 0, &devman_devices_ops);
     1005        hash_table_create(&tree->devman_functions, 0, 0, &devman_functions_ops);
     1006        hash_table_create(&tree->loc_functions, 0, 0, &loc_devices_ops);
    10031007       
    10041008        fibril_rwlock_initialize(&tree->rwlock);
    … …  
    10341038        list_initialize(&dev->functions);
    10351039        link_initialize(&dev->driver_devices);
    1036         link_initialize(&dev->devman_dev);
    10371040       
    10381041        return dev;
    … …  
    10821085dev_node_t *find_dev_node_no_lock(dev_tree_t *tree, devman_handle_t handle)
    10831086{
    1084         unsigned long key = handle;
    1085         link_t *link;
    1086        
    10871087        assert(fibril_rwlock_is_locked(&tree->rwlock));
    10881088       
    1089         link = hash_table_find(&tree->devman_devices, &key);
     1089        ht_link_t *link = hash_table_find(&tree->devman_devices, &handle);
    10901090        if (link == NULL)
    10911091                return NULL;
    10921092       
    1093         return hash_table_get_instance(link, dev_node_t, devman_dev);
     1093        return hash_table_get_inst(link, dev_node_t, devman_dev);
    10941094}
    10951095
    … …  
    11651165        link_initialize(&fun->dev_functions);
    11661166        list_initialize(&fun->match_ids.ids);
    1167         link_initialize(&fun->devman_fun);
    1168         link_initialize(&fun->loc_fun);
    11691167       
    11701168        return fun;
    … …  
    12151213fun_node_t *find_fun_node_no_lock(dev_tree_t *tree, devman_handle_t handle)
    12161214{
    1217         unsigned long key = handle;
    1218         link_t *link;
    12191215        fun_node_t *fun;
    12201216       
    12211217        assert(fibril_rwlock_is_locked(&tree->rwlock));
    12221218       
    1223         link = hash_table_find(&tree->devman_functions, &key);
     1219        ht_link_t *link = hash_table_find(&tree->devman_functions, &handle);
    12241220        if (link == NULL)
    12251221                return NULL;
    12261222       
    1227         fun = hash_table_get_instance(link, fun_node_t, devman_fun);
     1223        fun = hash_table_get_inst(link, fun_node_t, devman_fun);
    12281224       
    12291225        return fun;
    … …  
    13241320       
    13251321        /* Remove node from the handle-to-node map. */
    1326         unsigned long key = dev->handle;
    1327         hash_table_remove(&tree->devman_devices, &key, 1);
     1322        hash_table_remove(&tree->devman_devices, &dev->handle);
    13281323       
    13291324        /* Unlink from parent function. */
    … …  
    13861381       
    13871382        /* Remove the node from the handle-to-node map. */
    1388         unsigned long key = fun->handle;
    1389         hash_table_remove(&tree->devman_functions, &key, 1);
     1383        hash_table_remove(&tree->devman_functions, &fun->handle);
    13901384       
    13911385        /* Remove the node from the list of its parent's children. */
    … …  
    15001494{
    15011495        fun_node_t *fun = NULL;
    1502         link_t *link;
    1503         unsigned long key = (unsigned long) service_id;
    15041496       
    15051497        fibril_rwlock_read_lock(&tree->rwlock);
    1506         link = hash_table_find(&tree->loc_functions, &key);
     1498        ht_link_t *link = hash_table_find(&tree->loc_functions, &service_id);
    15071499        if (link != NULL) {
    1508                 fun = hash_table_get_instance(link, fun_node_t, loc_fun);
     1500                fun = hash_table_get_inst(link, fun_node_t, loc_fun);
    15091501                fun_add_ref(fun);
    15101502        }
Note: See TracChangeset for help on using the changeset viewer.