From fb7b747f9f2bb3dbc0f8a9c34a65fd299f1ce504 Mon Sep 17 00:00:00 2001 From: Nick Peng Date: Tue, 22 Aug 2023 23:18:31 +0800 Subject: [PATCH] cache: Optimize cache memory usage --- src/dns_cache.c | 21 +++++++++++++++------ src/include/hashtable.h | 39 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+), 6 deletions(-) diff --git a/src/dns_cache.c b/src/dns_cache.c index 0b2f469..73efb4a 100644 --- a/src/dns_cache.c +++ b/src/dns_cache.c @@ -30,7 +30,7 @@ #define DNS_CACHE_HITNUM_STEP_MAX 6 struct dns_cache_head { - DECLARE_HASHTABLE(cache_hash, 16); + struct hash_table cache_hash; struct list_head cache_list; struct list_head inactive_list; atomic_t num; @@ -44,14 +44,22 @@ static struct dns_cache_head dns_cache_head; int dns_cache_init(int size, int enable_inactive, int inactive_list_expired) { + int bits = 0; INIT_LIST_HEAD(&dns_cache_head.cache_list); INIT_LIST_HEAD(&dns_cache_head.inactive_list); - hash_init(dns_cache_head.cache_hash); + + bits = ilog2(size) - 1; + if (bits >= 20) { + bits = 20; + } else if (bits < 12) { + bits = 12; + } + + hash_table_init(dns_cache_head.cache_hash, bits, malloc); atomic_set(&dns_cache_head.num, 0); dns_cache_head.size = size; dns_cache_head.enable_inactive = enable_inactive; dns_cache_head.inactive_list_expired = inactive_list_expired; - pthread_mutex_init(&dns_cache_head.lock, NULL); return 0; @@ -320,7 +328,7 @@ static void _dns_cache_remove_by_domain(struct dns_cache_key *cache_key) key = jhash(&cache_key->query_flag, sizeof(cache_key->query_flag), key); pthread_mutex_lock(&dns_cache_head.lock); - hash_for_each_possible(dns_cache_head.cache_hash, dns_cache, node, key) + hash_table_for_each_possible(dns_cache_head.cache_hash, dns_cache, node, key) { if (dns_cache->info.qtype != cache_key->qtype) { continue; @@ -373,7 +381,7 @@ static int _dns_cache_insert(struct dns_cache_info *info, struct dns_cache_data dns_cache->del_pending = 0; dns_cache->cache_data = cache_data; pthread_mutex_lock(&dns_cache_head.lock); - hash_add(dns_cache_head.cache_hash, &dns_cache->node, key); + hash_table_add(dns_cache_head.cache_hash, &dns_cache->node, key); list_add_tail(&dns_cache->list, head); INIT_LIST_HEAD(&dns_cache->check_list); @@ -450,7 +458,7 @@ struct dns_cache *dns_cache_lookup(struct dns_cache_key *cache_key) time(&now); /* find cache */ pthread_mutex_lock(&dns_cache_head.lock); - hash_for_each_possible(dns_cache_head.cache_hash, dns_cache, node, key) + hash_table_for_each_possible(dns_cache_head.cache_hash, dns_cache, node, key) { if (dns_cache->info.qtype != cache_key->qtype) { continue; @@ -963,6 +971,7 @@ void dns_cache_destroy(void) pthread_mutex_unlock(&dns_cache_head.lock); pthread_mutex_destroy(&dns_cache_head.lock); + hash_table_free(dns_cache_head.cache_hash, free); } const char *dns_cache_file_version(void) diff --git a/src/include/hashtable.h b/src/include/hashtable.h index a3d5e60..9b31a2a 100644 --- a/src/include/hashtable.h +++ b/src/include/hashtable.h @@ -29,6 +29,11 @@ #define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0])) #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr)) +struct hash_table { + struct hlist_head *table; + unsigned int size; +}; + #define DEFINE_HASHTABLE(name, bits) \ struct hlist_head name[1 << (bits)] = \ { [0 ... ((1 << (bits)) - 1)] = HLIST_HEAD_INIT } @@ -38,6 +43,8 @@ #define HASH_SIZE(name) (ARRAY_SIZE(name)) #define HASH_BITS(name) ilog2(HASH_SIZE(name)) +#define HASH_TABLE_SIZE(name) (1 << ((name).size)) +#define HASH_TABLE_BITS(name) ((name).size) /* Use hash_32 when possible to allow for fast 32bit hashing in 64bit kernels. */ #define hash_min(val, bits) \ @@ -63,6 +70,16 @@ static inline void __hash_init(struct hlist_head *ht, unsigned int sz) */ #define hash_init(hashtable) __hash_init(hashtable, HASH_SIZE(hashtable)) +#define hash_table_init(hashtable, bits, malloc_func) \ + (hashtable).size = bits; \ + (hashtable).table = malloc_func(sizeof(struct hlist_head) * HASH_TABLE_SIZE((hashtable))); \ + __hash_init((hashtable).table, HASH_TABLE_SIZE((hashtable))) + +#define hash_table_free(hashtable, free_func) \ + free_func((hashtable).table); \ + (hashtable).table = NULL; \ + (hashtable).size = 0; + /** * hash_add - add an object to a hashtable * @hashtable: hashtable to add to @@ -72,6 +89,9 @@ static inline void __hash_init(struct hlist_head *ht, unsigned int sz) #define hash_add(hashtable, node, key) \ hlist_add_head(node, &hashtable[hash_min(key, HASH_BITS(hashtable))]) +#define hash_table_add(hashtable, node, key) \ + hlist_add_head(node, &(hashtable).table[hash_min(key, HASH_TABLE_BITS(hashtable))]) + /** * hash_hashed - check whether an object is in any hashtable * @node: the &struct hlist_node of the object to be checked @@ -101,6 +121,8 @@ static inline bool __hash_empty(struct hlist_head *ht, unsigned int sz) */ #define hash_empty(hashtable) __hash_empty(hashtable, HASH_SIZE(hashtable)) +#define hash_table_empty(hashtable) __hash_empty((hashtable).table, HASH_TABLE_SIZE(hashtable)) + /** * hash_del - remove an object from a hashtable * @node: &struct hlist_node of the object to remove @@ -122,6 +144,11 @@ static inline void hash_del(struct hlist_node *node) (bkt)++)\ hlist_for_each_entry(obj, &name[bkt], member) +#define hash_table_for_each(name, bkt, obj, member) \ + for ((bkt) = 0, obj = NULL; obj == NULL && (bkt) < (HASH_TABLE_SIZE(name));\ + (bkt)++)\ + hlist_for_each_entry(obj, &((name).table)[bkt], member) + /** * hash_for_each_safe - iterate over a hashtable safe against removal of * hash entry @@ -136,6 +163,11 @@ static inline void hash_del(struct hlist_node *node) (bkt)++)\ hlist_for_each_entry_safe(obj, tmp, &name[bkt], member) +#define hash_table_for_each_safe(name, bkt, tmp, obj, member) \ + for ((bkt) = 0, obj = NULL; obj == NULL && (bkt) < (HASH_TABLE_SIZE(name));\ + (bkt)++)\ + hlist_for_each_entry_safe(obj, tmp, &((name).table)[bkt], member) + /** * hash_for_each_possible - iterate over all possible objects hashing to the * same bucket @@ -147,6 +179,9 @@ static inline void hash_del(struct hlist_node *node) #define hash_for_each_possible(name, obj, member, key) \ hlist_for_each_entry(obj, &name[hash_min(key, HASH_BITS(name))], member) +#define hash_table_for_each_possible(name, obj, member, key) \ + hlist_for_each_entry(obj, &((name).table)[hash_min(key, HASH_TABLE_BITS(name))], member) + /** * hash_for_each_possible_safe - iterate over all possible objects hashing to the * same bucket safe against removals @@ -160,4 +195,8 @@ static inline void hash_del(struct hlist_node *node) hlist_for_each_entry_safe(obj, tmp,\ &name[hash_min(key, HASH_BITS(name))], member) +#define hash_table_for_each_possible_safe(name, obj, tmp, member, key) \ + hlist_for_each_entry_safe(obj, tmp,\ + &((name).table)[hash_min(key, HASH_TABLE_BITS(name))], member) + #endif