Changeset 062d900 in mainline for uspace/app/trace


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/app/trace
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/trace/ipcp.c

    r87e9392 r062d900  
    3838#include <sys/typefmt.h>
    3939#include <abi/ipc/methods.h>
     40#include <macros.h>
    4041#include "ipc_desc.h"
    4142#include "proto.h"
    … …  
    5253        ipc_callid_t call_hash;
    5354
    54         link_t link;
     55        ht_link_t link;
    5556} pending_call_t;
    5657
    … …  
    6465int have_conn[MAX_PHONE];
    6566
    66 #define PCALL_TABLE_CHAINS 32
    67 hash_table_t pending_calls;
     67static hash_table_t pending_calls;
    6868
    6969/*
    … …  
    7373proto_t *proto_unknown;         /**< Protocol with no known methods. */
    7474
    75 static hash_index_t pending_call_hash(unsigned long key[]);
    76 static int pending_call_compare(unsigned long key[], hash_count_t keys,
    77     link_t *item);
    78 static void pending_call_remove_callback(link_t *item);
    79 
    80 hash_table_operations_t pending_call_ops = {
     75
     76static size_t pending_call_key_hash(void *key)
     77{
     78        ipc_callid_t *call_id = (ipc_callid_t *)key;
     79        return *call_id;
     80}
     81
     82static size_t pending_call_hash(const ht_link_t *item)
     83{
     84        pending_call_t *hs = hash_table_get_inst(item, pending_call_t, link);
     85        return hs->call_hash;
     86}
     87
     88static bool pending_call_key_equal(void *key, const ht_link_t *item)
     89{
     90        ipc_callid_t *call_id = (ipc_callid_t *)key;
     91        pending_call_t *hs = hash_table_get_inst(item, pending_call_t, link);
     92
     93        return *call_id == hs->call_hash;
     94}
     95
     96static hash_table_ops_t pending_call_ops = {
    8197        .hash = pending_call_hash,
    82         .compare = pending_call_compare,
    83         .remove_callback = pending_call_remove_callback
     98        .key_hash = pending_call_key_hash,
     99        .key_equal = pending_call_key_equal,
     100        .equal = 0,
     101        .remove_callback = 0
    84102};
    85 
    86 
    87 static hash_index_t pending_call_hash(unsigned long key[])
    88 {
    89 //      printf("pending_call_hash\n");
    90         return key[0] % PCALL_TABLE_CHAINS;
    91 }
    92 
    93 static int pending_call_compare(unsigned long key[], hash_count_t keys,
    94     link_t *item)
    95 {
    96         pending_call_t *hs;
    97 
    98 //      printf("pending_call_compare\n");
    99         hs = hash_table_get_instance(item, pending_call_t, link);
    100 
    101         // FIXME: this will fail if sizeof(long) < sizeof(void *).
    102         return key[0] == hs->call_hash;
    103 }
    104 
    105 static void pending_call_remove_callback(link_t *item)
    106 {
    107 //      printf("pending_call_remove_callback\n");
    108 }
    109103
    110104
    … …  
    177171        }
    178172
    179         hash_table_create(&pending_calls, PCALL_TABLE_CHAINS, 1, &pending_call_ops);
     173        bool ok = hash_table_create(&pending_calls, 0, 0, &pending_call_ops);
     174        assert(ok);
    180175}
    181176
    … …  
    190185        pending_call_t *pcall;
    191186        proto_t *proto;
    192         unsigned long key[1];
    193187        oper_t *oper;
    194188        sysarg_t *args;
    … …  
    254248        pcall->oper = oper;
    255249
    256         key[0] = hash;
    257 
    258         hash_table_insert(&pending_calls, key, &pcall->link);
     250        hash_table_insert(&pending_calls, &pcall->link);
    259251}
    260252
    … …  
    334326void ipcp_call_in(ipc_call_t *call, ipc_callid_t hash)
    335327{
    336         link_t *item;
     328        ht_link_t *item;
    337329        pending_call_t *pcall;
    338         unsigned long key[1];
    339330       
    340331        if ((hash & IPC_CALLID_ANSWERED) == 0 && hash != IPCP_CALLID_SYNC) {
    … …  
    347338       
    348339        hash = hash & ~IPC_CALLID_ANSWERED;
    349         key[0] = hash;
    350        
    351         item = hash_table_find(&pending_calls, key);
     340       
     341        item = hash_table_find(&pending_calls, &hash);
    352342        if (item == NULL)
    353343                return; /* No matching question found */
    … …  
    357347         */
    358348       
    359         pcall = hash_table_get_instance(item, pending_call_t, link);
    360         hash_table_remove(&pending_calls, key, 1);
     349        pcall = hash_table_get_inst(item, pending_call_t, link);
     350        hash_table_remove(&pending_calls, &hash);
    361351       
    362352        parse_answer(hash, pcall, call);

  • uspace/app/trace/proto.c

    r87e9392 r062d900  
    4040#include "proto.h"
    4141
    42 #define SRV_PROTO_TABLE_CHAINS 32
    43 #define METHOD_OPER_TABLE_CHAINS 32
    44 
    45 hash_table_t srv_proto;
     42
     43/* Maps service number to protocol */
     44static hash_table_t srv_proto;
    4645
    4746typedef struct {
    48         unsigned srv;
     47        int srv;
    4948        proto_t *proto;
    50         link_t link;
     49        ht_link_t link;
    5150} srv_proto_t;
    5251
    5352typedef struct {
    54         sysarg_t method;
     53        int method;
    5554        oper_t *oper;
    56         link_t link;
     55        ht_link_t link;
    5756} method_oper_t;
    5857
    59 static hash_index_t srv_proto_hash(unsigned long key[]);
    60 static int srv_proto_compare(unsigned long key[], hash_count_t keys,
    61     link_t *item);
    62 static void srv_proto_remove_callback(link_t *item);
    63 
    64 hash_table_operations_t srv_proto_ops = {
     58/* Hash table operations. */
     59
     60static size_t srv_proto_key_hash(void *key)
     61{
     62        return *(int *)key;
     63}
     64
     65static size_t srv_proto_hash(const ht_link_t *item)
     66{
     67        srv_proto_t *sp = hash_table_get_inst(item, srv_proto_t, link);
     68        return sp->srv;
     69}
     70
     71static bool srv_proto_key_equal(void *key, const ht_link_t *item)
     72{
     73        srv_proto_t *sp = hash_table_get_inst(item, srv_proto_t, link);
     74        return sp->srv == *(int *)key;
     75}
     76
     77static hash_table_ops_t srv_proto_ops = {
    6578        .hash = srv_proto_hash,
    66         .compare = srv_proto_compare,
    67         .remove_callback = srv_proto_remove_callback
     79        .key_hash = srv_proto_key_hash,
     80        .key_equal = srv_proto_key_equal,
     81        .equal = 0,
     82        .remove_callback = 0
    6883};
    6984
    70 static hash_index_t method_oper_hash(unsigned long key[]);
    71 static int method_oper_compare(unsigned long key[], hash_count_t keys,
    72     link_t *item);
    73 static void method_oper_remove_callback(link_t *item);
    74 
    75 hash_table_operations_t method_oper_ops = {
     85
     86static size_t method_oper_key_hash(void *key)
     87{
     88        return *(int *)key;
     89}
     90
     91static size_t method_oper_hash(const ht_link_t *item)
     92{
     93        method_oper_t *mo = hash_table_get_inst(item, method_oper_t, link);
     94        return mo->method;
     95}
     96
     97static bool method_oper_key_equal(void *key, const ht_link_t *item)
     98{
     99        method_oper_t *mo = hash_table_get_inst(item, method_oper_t, link);
     100        return mo->method == *(int *)key;
     101}
     102
     103static hash_table_ops_t method_oper_ops = {
    76104        .hash = method_oper_hash,
    77         .compare = method_oper_compare,
    78         .remove_callback = method_oper_remove_callback
     105        .key_hash = method_oper_key_hash,
     106        .key_equal = method_oper_key_equal,
     107        .equal = 0,
     108        .remove_callback = 0
    79109};
    80110
    81 static hash_index_t srv_proto_hash(unsigned long key[])
    82 {
    83         return key[0] % SRV_PROTO_TABLE_CHAINS;
    84 }
    85 
    86 static int srv_proto_compare(unsigned long key[], hash_count_t keys,
    87     link_t *item)
     111
     112void proto_init(void)
     113{
     114        /* todo: check return value. */
     115        bool ok = hash_table_create(&srv_proto, 0, 0, &srv_proto_ops);
     116        assert(ok);
     117}
     118
     119void proto_cleanup(void)
     120{
     121        hash_table_destroy(&srv_proto);
     122}
     123
     124void proto_register(int srv, proto_t *proto)
    88125{
    89126        srv_proto_t *sp;
    90 
    91         sp = hash_table_get_instance(item, srv_proto_t, link);
    92 
    93         return key[0] == sp->srv;
    94 }
    95 
    96 static void srv_proto_remove_callback(link_t *item)
    97 {
    98 }
    99 
    100 static hash_index_t method_oper_hash(unsigned long key[])
    101 {
    102         return key[0] % METHOD_OPER_TABLE_CHAINS;
    103 }
    104 
    105 static int method_oper_compare(unsigned long key[], hash_count_t keys,
    106     link_t *item)
    107 {
    108         method_oper_t *mo;
    109 
    110         mo = hash_table_get_instance(item, method_oper_t, link);
    111 
    112         return key[0] == mo->method;
    113 }
    114 
    115 static void method_oper_remove_callback(link_t *item)
    116 {
    117 }
    118 
    119 
    120 void proto_init(void)
    121 {
    122         hash_table_create(&srv_proto, SRV_PROTO_TABLE_CHAINS, 1,
    123             &srv_proto_ops);
    124 }
    125 
    126 void proto_cleanup(void)
    127 {
    128         hash_table_destroy(&srv_proto);
    129 }
    130 
    131 void proto_register(int srv, proto_t *proto)
    132 {
    133         srv_proto_t *sp;
    134         unsigned long key;
    135127
    136128        sp = malloc(sizeof(srv_proto_t));
    137129        sp->srv = srv;
    138130        sp->proto = proto;
    139         key = srv;
    140 
    141         hash_table_insert(&srv_proto, &key, &sp->link);
     131
     132        hash_table_insert(&srv_proto, &sp->link);
    142133}
    143134
    144135proto_t *proto_get_by_srv(int srv)
    145136{
    146         unsigned long key;
    147         link_t *item;
    148         srv_proto_t *sp;
    149 
    150         key = srv;
    151         item = hash_table_find(&srv_proto, &key);
     137        ht_link_t *item = hash_table_find(&srv_proto, &srv);
    152138        if (item == NULL) return NULL;
    153139
    154         sp = hash_table_get_instance(item, srv_proto_t, link);
     140        srv_proto_t *sp = hash_table_get_inst(item, srv_proto_t, link);
    155141        return sp->proto;
    156142}
    … …  
    159145{
    160146        proto->name = name;
    161         hash_table_create(&proto->method_oper, SRV_PROTO_TABLE_CHAINS, 1,
    162             &method_oper_ops);
     147        /* todo: check return value. */
     148        bool ok = hash_table_create(&proto->method_oper, 0, 0, &method_oper_ops);
     149        assert(ok);
    163150}
    164151
    … …  
    181168{
    182169        method_oper_t *mo;
    183         unsigned long key;
    184170
    185171        mo = malloc(sizeof(method_oper_t));
    186172        mo->method = method;
    187173        mo->oper = oper;
    188         key = method;
    189 
    190         hash_table_insert(&proto->method_oper, &key, &mo->link);       
     174
     175        hash_table_insert(&proto->method_oper, &mo->link);     
    191176}
    192177
    193178oper_t *proto_get_oper(proto_t *proto, int method)
    194179{
    195         unsigned long key;
    196         link_t *item;
    197         method_oper_t *mo;
    198 
    199         key = method;
    200         item = hash_table_find(&proto->method_oper, &key);
     180        ht_link_t *item = hash_table_find(&proto->method_oper, &method);
    201181        if (item == NULL) return NULL;
    202182
    203         mo = hash_table_get_instance(item, method_oper_t, link);
     183        method_oper_t *mo = hash_table_get_inst(item, method_oper_t, link);
    204184        return mo->oper;
    205185}

  • uspace/app/trace/proto.h

    r87e9392 r062d900  
    6262} proto_t;
    6363
    64 /* Maps service number to protocol */
    65 extern hash_table_t srv_proto;
    6664
    6765extern void proto_init(void);
Note: See TracChangeset for help on using the changeset viewer.