Changeset 543

Show
Ignore:
Timestamp:
12/27/06 18:28:52 (2 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r541 r543  
     12006-12-27  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     2 
     3        * cherokee/access.c (cherokee_access_add_domain): Updated to fit 
     4        the latest resolv cache changes. 
     5 
     6        * cherokee/source.c (cherokee_source_connect): Now it uses the 
     7        resolv cache rather that a plain call to 
     8        cherokee_socket_gethostbyname(). It speeds up *cgi connections 
     9        about a 15-20%. 
     10 
     11        * cherokee/resolv_cache.h, cherokee/resolv_cache.c: Many changes 
     12        along the code: fixes and improvements. Added a new method as 
     13        well. 
     14 
     15        * cherokee/common-internal.h (CHEROKEE_RWLOCK_T, 
     16        CHEROKEE_MUTEX_T): Added new macros. 
     17 
    1182006-12-26  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    219 

  • cherokee/trunk/cherokee/access.c

    r533 r543  
    339339        if (unlikely(ret!=ret_ok)) return ret; 
    340340 
    341         ret = cherokee_resolv_cache_resolve (resolv, domain, &ip); 
     341        ret = cherokee_resolv_cache_get_ipstr (resolv, domain, &ip); 
    342342        if (unlikely(ret!=ret_ok)) return ret; 
    343343 

  • cherokee/trunk/cherokee/common-internal.h

    r333 r543  
    8383 
    8484#ifdef HAVE_PTHREAD 
     85# define CHEROKEE_MUTEX_T(n)          pthread_mutex_t n 
     86# define CHEROKEE_RWLOCK_T(n)         pthread_rwlock_t n 
     87 
    8588# define CHEROKEE_MUTEX_LOCK(m)       pthread_mutex_lock(m) 
    8689# define CHEROKEE_MUTEX_UNLOCK(m)     pthread_mutex_unlock(m) 
    …… 
    97100# define CHEROKEE_RWLOCK_DESTROY(m)   pthread_rwlock_destroy(m) 
    98101#else 
     102# define CHEROKEE_MUTEX_T(n)           
     103# define CHEROKEE_RWLOCK_T(n)          
     104 
    99105# define CHEROKEE_MUTEX_LOCK(m) 
    100106# define CHEROKEE_MUTEX_UNLOCK(m) 

  • cherokee/trunk/cherokee/resolv_cache.c

    r269 r543  
    3737 
    3838 
     39typedef struct { 
     40        struct in_addr    addr; 
     41        cherokee_buffer_t ip_str; 
     42} cherokee_resolv_cache_entry_t; 
     43 
    3944struct cherokee_resolv_cache { 
    40            cherokee_table_t table; 
    41  
    42 #ifdef HAVE_PTHREAD 
    43            pthread_rwlock_t lock; 
    44 #endif 
     45        cherokee_table_t table; 
     46        CHEROKEE_RWLOCK_T(lock); 
    4547}; 
    4648 
    47  
    4849static cherokee_resolv_cache_t *__global_resolv = NULL; 
    4950 
    5051 
     52/* Entries 
     53 */ 
     54static ret_t  
     55entry_new (cherokee_resolv_cache_entry_t **entry) 
     56{ 
     57        CHEROKEE_NEW_STRUCT(n, resolv_cache_entry); 
     58         
     59        cherokee_buffer_init (&n->ip_str); 
     60        memset (&n->addr, 0, sizeof(n->addr)); 
     61 
     62        *entry = n; 
     63        return ret_ok; 
     64} 
     65 
     66 
     67static void 
     68entry_free (void *entry) 
     69{ 
     70        cherokee_resolv_cache_entry_t *e = entry; 
     71 
     72        cherokee_buffer_mrproper (&e->ip_str); 
     73        free(entry); 
     74} 
     75 
     76 
     77static ret_t 
     78entry_fill_up (cherokee_resolv_cache_entry_t *entry, const char *domain) 
     79{ 
     80        ret_t  ret; 
     81        char  *tmp; 
     82 
     83        ret = cherokee_gethostbyname (domain, &entry->addr);  
     84        if (unlikely (ret != ret_ok)) return ret; 
     85 
     86        tmp = inet_ntoa (entry->addr); 
     87        if (tmp == NULL) return ret; 
     88         
     89        cherokee_buffer_add (&entry->ip_str, tmp, strlen(tmp)); 
     90        return ret_ok; 
     91} 
     92 
     93 
     94 
     95/* Table 
     96 */ 
    5197ret_t  
    5298cherokee_resolv_cache_init (cherokee_resolv_cache_t *resolv) 
    5399{ 
    54            ret_t ret; 
    55  
    56            ret = cherokee_table_init (&resolv->table); 
    57            if (unlikely (ret != ret_ok)) return ret; 
    58  
    59            CHEROKEE_RWLOCK_INIT (&resolv->lock, NULL); 
    60  
    61            return ret_ok; 
     100        ret_t ret; 
     101 
     102        ret = cherokee_table_init (&resolv->table); 
     103        if (unlikely (ret != ret_ok)) return ret; 
     104 
     105        CHEROKEE_RWLOCK_INIT (&resolv->lock, NULL); 
     106        return ret_ok; 
    62107} 
    63108 
    …… 
    66111cherokee_resolv_cache_mrproper (cherokee_resolv_cache_t *resolv) 
    67112{ 
    68            cherokee_table_mrproper (&resolv->table); 
    69            CHEROKEE_RWLOCK_DESTROY (&resolv->lock); 
    70  
    71            return ret_ok; 
     113        cherokee_table_mrproper (&resolv->table); 
     114        CHEROKEE_RWLOCK_DESTROY (&resolv->lock); 
     115 
     116        return ret_ok; 
    72117} 
    73118 
    …… 
    76121cherokee_resolv_cache_get_default (cherokee_resolv_cache_t **resolv) 
    77122{ 
    78         if (__global_resolv != NULL) { 
    79                 *resolv = __global_resolv; 
    80                 return ret_ok; 
    81         } 
    82          
    83         *resolv = (cherokee_resolv_cache_t *) malloc (sizeof(cherokee_resolv_cache_t)); 
    84         return cherokee_resolv_cache_init (*resolv); 
     123        ret_t                    ret; 
     124        cherokee_resolv_cache_t *n; 
     125         
     126        if (unlikely (__global_resolv == NULL)) { 
     127                n = (cherokee_resolv_cache_t *) malloc (sizeof(cherokee_resolv_cache_t)); 
     128                if (n == NULL) return ret_nomem; 
     129 
     130                ret = cherokee_resolv_cache_init (n); 
     131                if (ret != ret_ok) return ret; 
     132 
     133                __global_resolv = n; 
     134        } 
     135 
     136        *resolv = __global_resolv; 
     137        return ret_ok; 
     138} 
     139 
     140 
     141ret_t  
     142cherokee_resolv_cache_clean (cherokee_resolv_cache_t *resolv) 
     143{ 
     144        CHEROKEE_RWLOCK_WRITER (&resolv->lock); 
     145        cherokee_table_clean2 (&resolv->table, entry_free); 
     146        CHEROKEE_RWLOCK_UNLOCK (&resolv->lock); 
     147 
     148        return ret_ok; 
    85149} 
    86150 
    87151 
    88152static ret_t 
    89 resolve (const char *domain, const char **ip) 
    90 { 
    91         ret_t           ret; 
    92         char           *tmp; 
    93         struct in_addr  addr; 
    94          
    95         ret = cherokee_gethostbyname (domain, &addr);  
    96         if (unlikely (ret != ret_ok)) return ret; 
    97  
    98         tmp = inet_ntoa (addr); 
    99         *ip = strdup (tmp); 
    100  
    101         return ret_ok; 
    102 } 
    103  
    104  
    105 ret_t  
    106 cherokee_resolv_cache_resolve (cherokee_resolv_cache_t *resolv, const char *domain, const char **ip) 
    107 { 
    108            ret_t ret; 
    109  
    110            /* Look for the name in the cache 
    111             */ 
    112            CHEROKEE_RWLOCK_WRITER (&resolv->lock); 
    113            ret = cherokee_table_get (&resolv->table, (char *)domain, (void **)ip); 
    114            CHEROKEE_RWLOCK_UNLOCK (&resolv->lock); 
    115            if (ret == ret_ok) return ret_ok; 
    116  
    117            /* Damn it! It isn't there.. 
    118             */ 
    119            ret = resolve (domain, ip); 
    120            if (ret != ret_ok) return ret; 
    121  
    122            CHEROKEE_RWLOCK_WRITER (&resolv->lock); 
    123            ret = cherokee_table_add (&resolv->table, (char *)domain, (void **)*ip); 
    124            CHEROKEE_RWLOCK_UNLOCK (&resolv->lock); 
    125  
    126            return ret; 
    127 } 
    128  
    129  
    130 ret_t  
    131 cherokee_resolv_cache_clean (cherokee_resolv_cache_t *resolv) 
    132 { 
    133            CHEROKEE_RWLOCK_WRITER (&resolv->lock); 
    134            cherokee_table_clean2 (&resolv->table, free); 
    135            CHEROKEE_RWLOCK_UNLOCK (&resolv->lock); 
    136  
    137            return ret_ok; 
    138 } 
     153table_add_new_entry (cherokee_resolv_cache_t *resolv, const char *domain, cherokee_resolv_cache_entry_t **entry) 
     154{ 
     155        ret_t                          ret; 
     156        cherokee_resolv_cache_entry_t *n; 
     157 
     158        /* Instance the entry 
     159         */ 
     160        ret = entry_new (&n); 
     161        if (unlikely (ret != ret))  
     162                return ret; 
     163 
     164        /* Fill it up 
     165         */ 
     166        ret = entry_fill_up (n, domain); 
     167        if (unlikely (ret != ret)) { 
     168                entry_free (n); 
     169                return ret; 
     170        } 
     171         
     172        /* Add it to the table 
     173         */ 
     174        CHEROKEE_RWLOCK_WRITER (&resolv->lock); 
     175        ret = cherokee_table_add (&resolv->table, (char *)domain, (void **)n); 
     176        CHEROKEE_RWLOCK_UNLOCK (&resolv->lock); 
     177 
     178        *entry = n; 
     179        return ret_ok; 
     180} 
     181 
     182 
     183ret_t  
     184cherokee_resolv_cache_get_ipstr (cherokee_resolv_cache_t *resolv, const char *domain, const char **ip) 
     185{ 
     186        ret_t                          ret; 
     187        cherokee_resolv_cache_entry_t *entry = NULL; 
     188 
     189        /* Look for the name in the cache 
     190         */ 
     191        CHEROKEE_RWLOCK_WRITER (&resolv->lock); 
     192        ret = cherokee_table_get (&resolv->table, (char *)domain, (void **)&entry); 
     193        CHEROKEE_RWLOCK_UNLOCK (&resolv->lock); 
     194 
     195        if (ret != ret_ok) { 
     196                /* Bad luck: it wasn't cached 
     197                 */ 
     198                ret = table_add_new_entry (resolv, domain, &entry); 
     199                if (ret != ret_ok) return ret; 
     200        } 
     201 
     202        /* Return the ip string 
     203         */ 
     204        *ip = entry->ip_str.buf; 
     205        return ret_ok; 
     206} 
     207 
     208 
     209ret_t  
     210cherokee_resolv_cache_get_host (cherokee_resolv_cache_t *resolv, const char *domain, cherokee_socket_t *sock) 
     211{ 
     212        ret_t                          ret; 
     213        cherokee_resolv_cache_entry_t *entry = NULL; 
     214 
     215        /* Look for the name in the cache 
     216         */ 
     217        CHEROKEE_RWLOCK_WRITER (&resolv->lock); 
     218        ret = cherokee_table_get (&resolv->table, (char *)domain, (void **)&entry); 
     219        CHEROKEE_RWLOCK_UNLOCK (&resolv->lock); 
     220 
     221        if (ret != ret_ok) { 
     222                /* Bad luck: it wasn't cached 
     223                 */ 
     224                ret = table_add_new_entry (resolv, domain, &entry); 
     225                if (ret != ret_ok) return ret; 
     226        } 
     227 
     228        /* Copy the address 
     229         */ 
     230        memcpy (&SOCKET_SIN_ADDR(sock), &entry->addr, sizeof(entry->addr)); 
     231        return ret_ok; 
     232} 

  • cherokee/trunk/cherokee/resolv_cache.h

    r122 r543  
    3131 
    3232#include <cherokee/common.h> 
     33#include <cherokee/socket.h> 
    3334 
    3435 
    …… 
    4142ret_t cherokee_resolv_cache_get_default (cherokee_resolv_cache_t **resolv); 
    4243 
    43 ret_t cherokee_resolv_cache_init     (cherokee_resolv_cache_t *resolv); 
    44 ret_t cherokee_resolv_cache_mrproper (cherokee_resolv_cache_t *resolv); 
     44ret_t cherokee_resolv_cache_init      (cherokee_resolv_cache_t *resolv); 
     45ret_t cherokee_resolv_cache_mrproper  (cherokee_resolv_cache_t *resolv); 
     46ret_t cherokee_resolv_cache_clean     (cherokee_resolv_cache_t *resolv); 
    4547 
    46 ret_t cherokee_resolv_cache_resolve  (cherokee_resolv_cache_t *resolv,  const char *domain, const char **ip); 
    47 ret_t cherokee_resolv_cache_clean    (cherokee_resolv_cache_t *resolv); 
    48  
     48ret_t cherokee_resolv_cache_get_ipstr (cherokee_resolv_cache_t *resolv,  const char *domain, const char **ip); 
     49ret_t cherokee_resolv_cache_get_host  (cherokee_resolv_cache_t *resolv,  const char *domain, cherokee_socket_t *sock); 
    4950 
    5051CHEROKEE_END_DECLS 

  • cherokee/trunk/cherokee/source.c

    r529 r543  
    2626#include "source.h" 
    2727#include "config_node.h" 
     28#include "resolv_cache.h" 
    2829#include "util.h" 
    2930 
    …… 
    6869cherokee_source_connect (cherokee_source_t *src, cherokee_socket_t *sock) 
    6970{ 
    70         ret_t ret; 
     71        ret_t                    ret; 
     72        cherokee_resolv_cache_t *resolv; 
     73 
     74        ret = cherokee_resolv_cache_get_default (&resolv); 
     75        if (unlikely (ret!=ret_ok)) return ret; 
    7176 
    7277        /* UNIX socket 
    …… 
    7681                if (ret != ret_ok) return ret; 
    7782                 
    78                 ret = cherokee_socket_gethostbyname (sock, &src->unix_socket); 
     83                ret = cherokee_resolv_cache_get_host (resolv, src->unix_socket.buf, sock); 
    7984                if (ret != ret_ok) return ret; 
    8085 
    …… 
    8792        if (ret != ret_ok) return ret; 
    8893         
    89         ret = cherokee_socket_gethostbyname (sock, &src->host); 
     94        ret = cherokee_resolv_cache_get_host (resolv, src->host.buf, sock); 
    9095        if (ret != ret_ok) return ret; 
    9196         

  • cherokee/trunk/qa/run-tests.py

    r525 r543  
    184184        if valgrind: 
    185185#           os.execl (VALGRIND_PATH, "valgrind", "--tool=helgrind", server, "-C", cfg_file) 
    186 #           os.execl (VALGRIND_PATH, "valgrind", "--tool=callgrind", server, "-C", cfg_file) 
    187186#           os.execl (VALGRIND_PATH, "valgrind", "--tool=cachegrind", server, "-C", cfg_file) 
    188             os.execl (VALGRIND_PATH, "valgrind", "--leak-check=full", "--num-callers=20", "-v", server, "-C", cfg_file) 
     187#           os.execl (VALGRIND_PATH, "valgrind", "--leak-check=full", "--num-callers=20", "-v", server, "-C", cfg_file) 
    189188#           os.execl (VALGRIND_PATH, "valgrind", "--leak-check=full", "--num-callers=40", "-v", "--leak-resolution=high", server, "-C", cfg_file) 
     189            os.execl (VALGRIND_PATH, "valgrind", "--tool=callgrind", "--dump-instr=yes", "--trace-jump=yes", "-v", server, "-C", cfg_file) 
    190190        elif strace: 
    191191            os.execl (STRACE_PATH, "strace", server, "-C", cfg_file)