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     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;
  69
  70   if (not memc or not memc_stat)
  71   {
  72     return NULL;
  73   }
  74
  75   *error= MEMCACHED_SUCCESS;
  76   server_count= memcached_server_count(memc);
  77   memcached_analysis_st *result= (memcached_analysis_st*)calloc(memcached_server_count(memc),
  78                                                                 sizeof(memcached_analysis_st));
  79
  80   if (not result)
  81   {
  82     *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
  83     return NULL;
  84   }
  85
  86   result->root= memc;
  87
  88   for (uint32_t x= 0; x < server_count; x++)
  89   {
  90     calc_largest_consumption(result, x, memc_stat[x].bytes);
  91     calc_oldest_node(result, x, memc_stat[x].uptime);
  92     calc_least_free_node(result, x,
  93                          memc_stat[x].limit_maxbytes,
  94                          memc_stat[x].bytes);
  95
  96     total_get_hits+= memc_stat[x].get_hits;
  97     total_get_cmds+= memc_stat[x].cmd_get;
  98     total_items+= memc_stat[x].curr_items;
  99     total_bytes+= memc_stat[x].bytes;
 100   }
 101
 102   calc_average_item_size(result, total_items, total_bytes);
 103   calc_hit_ratio(result, total_get_hits, total_get_cmds);
 104
 105   return result;
 106 }
 107
 108 void memcached_analyze_free(memcached_analysis_st *ptr)
 109 {
 110   free(ptr);
 111 }