git.m6w6.name Git - m6w6/libmemcached/blob - libmemcached/analyze.c

   1 #include "common.h"
   2
   3 static void calc_largest_consumption(memcached_analysis_st *result,
   4                                      const uint32_t server_num,
   5                                      const uint64_t nbytes)
   6 {
   7   if (result->most_used_bytes < nbytes)
   8   {
   9     result->most_used_bytes= nbytes;
  10     result->most_consumed_server= server_num;
  11   }
  12 }
  13
  14 static void calc_oldest_node(memcached_analysis_st *result,
  15                                      const uint32_t server_num,
  16                                      const uint32_t uptime)
  17 {
  18   if (result->longest_uptime < uptime)
  19   {
  20     result->longest_uptime= uptime;
  21     result->oldest_server= server_num;
  22   }
  23 }
  24
  25 static void calc_least_free_node(memcached_analysis_st *result,
  26                                  const uint32_t server_num,
  27                                  const uint64_t max_allowed_bytes,
  28                                  const uint64_t used_bytes)
  29 {
  30   uint64_t remaining_bytes= max_allowed_bytes - used_bytes;
  31
  32   if (result->least_remaining_bytes == 0 ||
  33       remaining_bytes < result->least_remaining_bytes)
  34   {
  35     result->least_remaining_bytes= remaining_bytes;
  36     result->least_free_server= server_num;
  37   }
  38 }
  39
  40 static void calc_average_item_size(memcached_analysis_st *result,
  41                                    const uint64_t total_items,
  42                                    const uint64_t total_bytes)
  43 {
  44   if (total_items > 0 && total_bytes > 0)
  45     result->average_item_size= (uint32_t) (total_bytes / total_items);
  46 }
  47
  48 static void calc_hit_ratio(memcached_analysis_st *result,
  49                            const uint64_t total_get_hits,
  50                            const uint64_t total_get_cmds)
  51 {
  52   if (total_get_hits == 0 || total_get_cmds == 0)
  53   {
  54     result->pool_hit_ratio= 0;
  55     return;
  56   }
  57
  58   double temp= (double) (total_get_hits/total_get_cmds);
  59   result->pool_hit_ratio= temp * 100;
  60 }
  61
  62 memcached_analysis_st *memcached_analyze(memcached_st *memc,
  63                                          memcached_stat_st *memc_stat,
  64                                          memcached_return_t *error)
  65 {
  66   uint64_t total_items= 0, total_bytes= 0;
  67   uint64_t total_get_cmds= 0, total_get_hits= 0;
  68   uint32_t server_count, x;
  69   memcached_analysis_st *result;
  70
  71   *error= MEMCACHED_SUCCESS;
  72   server_count= memcached_server_count(memc);
  73   result= (memcached_analysis_st*)calloc(memc->number_of_hosts,
  74                                          sizeof(memcached_analysis_st));
  75
  76   if (!result)
  77   {
  78     *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
  79     return NULL;
  80   }
  81
  82   result->root= memc;
  83
  84   for (x= 0; x < server_count; x++)
  85   {
  86     calc_largest_consumption(result, x, memc_stat[x].bytes);
  87     calc_oldest_node(result, x, memc_stat[x].uptime);
  88     calc_least_free_node(result, x,
  89                          memc_stat[x].limit_maxbytes,
  90                          memc_stat[x].bytes);
  91
  92     total_get_hits+= memc_stat[x].get_hits;
  93     total_get_cmds+= memc_stat[x].cmd_get;
  94     total_items+= memc_stat[x].curr_items;
  95     total_bytes+= memc_stat[x].bytes;
  96   }
  97
  98   calc_average_item_size(result, total_items, total_bytes);
  99   calc_hit_ratio(result, total_get_hits, total_get_cmds);
 100
 101   return result;
 102 }
 103
 104 void memcached_analyze_free(memcached_analysis_st *ptr)
 105 {
 106   free(ptr);
 107 }