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

   1 #include <libmemcached/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   {
  46     result->average_item_size= (uint32_t) (total_bytes / total_items);
  47   }
  48 }
  49
  50 static void calc_hit_ratio(memcached_analysis_st *result,
  51                            const uint64_t total_get_hits,
  52                            const uint64_t total_get_cmds)
  53 {
  54   if (total_get_hits == 0 || total_get_cmds == 0)
  55   {
  56     result->pool_hit_ratio= 0;
  57     return;
  58   }
  59
  60   double temp= double(total_get_hits) / total_get_cmds;
  61   result->pool_hit_ratio= temp * 100;
  62 }
  63
  64 memcached_analysis_st *memcached_analyze(memcached_st *memc,
  65                                          memcached_stat_st *memc_stat,
  66                                          memcached_return_t *error)
  67 {
  68   uint64_t total_items= 0, total_bytes= 0;
  69   uint64_t total_get_cmds= 0, total_get_hits= 0;
  70
  71   if (memc == NULL or memc_stat == NULL)
  72   {
  73     return NULL;
  74   }
  75
  76   memcached_return_t not_used;
  77   if (error == NULL)
  78   {
  79     error= &not_used;
  80   }
  81
  82   *error= MEMCACHED_SUCCESS;
  83   uint32_t server_count= memcached_server_count(memc);
  84   memcached_analysis_st *result= (memcached_analysis_st*)libmemcached_xcalloc(memc,
  85                                                                               memcached_server_count(memc),
  86                                                                               memcached_analysis_st);
  87
  88   if (result == NULL)
  89   {
  90     *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
  91     return NULL;
  92   }
  93
  94   result->root= memc;
  95
  96   for (uint32_t x= 0; x < server_count; x++)
  97   {
  98     calc_largest_consumption(result, x, memc_stat[x].bytes);
  99     calc_oldest_node(result, x, memc_stat[x].uptime);
 100     calc_least_free_node(result, x,
 101                          memc_stat[x].limit_maxbytes,
 102                          memc_stat[x].bytes);
 103
 104     total_get_hits+= memc_stat[x].get_hits;
 105     total_get_cmds+= memc_stat[x].cmd_get;
 106     total_items+= memc_stat[x].curr_items;
 107     total_bytes+= memc_stat[x].bytes;
 108   }
 109
 110   calc_average_item_size(result, total_items, total_bytes);
 111   calc_hit_ratio(result, total_get_hits, total_get_cmds);
 112
 113   return result;
 114 }
 115
 116 void memcached_analyze_free(memcached_analysis_st *ptr)
 117 {
 118   libmemcached_free(ptr->root, ptr);
 119 }