couchbase-memcached 1.2.8

data/ext/libmemcached-0.50/clients/ms_setting.h

@@ -0,0 +1,181 @@
+/*
+ * File:   ms_setting.h
+ * Author: Mingqiang Zhuang
+ *
+ * Created on February 10, 2009
+ *
+ * (c) Copyright 2009, Schooner Information Technology, Inc.
+ * http://www.schoonerinfotech.com/
+ *
+ */
+#ifndef MS_SETTING_H
+#define MS_SETTING_H
+
+#include "ms_memslap.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MCD_SRVS_NUM_INIT         8
+#define MCD_HOST_LENGTH           64
+#define KEY_RANGE_COUNT_INIT      8
+#define VALUE_RANGE_COUNT_INIT    8
+#define PROP_ERROR                0.001
+
+#define MIN_KEY_SIZE              16
+#define MAX_KEY_SIZE              250
+#define MAX_VALUE_SIZE            (1024 * 1024)
+
+/* the content of the configuration file for memslap running without configuration file */
+#define DEFAULT_CONGIF_STR \
+  "key\n"                  \
+  "64 64 1\n"              \
+  "value\n"                \
+  "1024 1024 1\n"          \
+  "cmd\n"                  \
+  "0 0.1\n"                \
+  "1 0.9"
+
+/* Used to parse the value length return by server and path string */
+typedef struct token_s
+{
+  char *value;
+  size_t length;
+} token_t;
+
+#define MAX_TOKENS    10
+
+/* server information */
+typedef struct mcd_sever
+{
+  char srv_host_name[MCD_HOST_LENGTH];              /* host name of server */
+  int srv_port;                                     /* server port */
+
+  /* for calculating how long the server disconnects */
+  volatile uint32_t disconn_cnt;                    /* number of disconnections count */
+  volatile uint32_t reconn_cnt;                     /* number of reconnections count */
+  struct timeval disconn_time;                      /* start time of disconnection */
+  struct timeval reconn_time;                       /* end time of reconnection */
+} ms_mcd_server_t;
+
+/* information of an item distribution including key and value */
+typedef struct distr
+{
+  size_t key_size;                  /* size of key */
+  int key_offset;                   /* offset of one key in character block */
+  size_t value_size;                /* size of value */
+} ms_distr_t;
+
+/* information of key distribution */
+typedef struct key_distr
+{
+  size_t start_len;                 /* start of the key length range */
+  size_t end_len;                   /* end of the key length range */
+  double key_prop;                  /* key proportion */
+} ms_key_distr_t;
+
+/* information of value distribution */
+typedef struct value_distr
+{
+  size_t start_len;                 /* start of the value length range */
+  size_t end_len;                   /* end of the value length range */
+  double value_prop;                /* value proportion */
+} ms_value_distr_t;
+
+/* memcached command types */
+typedef enum cmd_type
+{
+  CMD_SET,
+  CMD_GET,
+  CMD_NULL
+} ms_cmd_type_t;
+
+/* types in the configuration file */
+typedef enum conf_type
+{
+  CONF_KEY,
+  CONF_VALUE,
+  CONF_CMD,
+  CONF_NULL
+} ms_conf_type_t;
+
+/* information of command distribution */
+typedef struct cmd_distr
+{
+  ms_cmd_type_t cmd_type;               /* command type */
+  double cmd_prop;                      /* proportion of the command */
+} ms_cmd_distr_t;
+
+/* global setting structure */
+typedef struct setting
+{
+  uint32_t ncpu;                             /* cpu count of this system */
+  uint32_t nthreads;                         /* total thread count, must equal or less than cpu cores */
+  uint32_t nconns;                      /* total conn count, must multiply by total thread count */
+  int64_t exec_num;                     /* total execute number */
+  int run_time;                         /* total run time */
+
+  uint32_t char_blk_size;               /* global character block size */
+  char *char_block;                     /* global character block with random character */
+  ms_distr_t *distr;                    /* distribution from configure file */
+
+  char *srv_str;                        /* string includes servers information */
+  char *cfg_file;                       /* configure file name */
+
+  ms_mcd_server_t *servers;             /* servers array */
+  uint32_t total_srv_cnt;                    /* total servers count of the servers array */
+  uint32_t srv_cnt;                          /* servers count */
+
+  ms_key_distr_t *key_distr;            /* array of key distribution */
+  int total_key_rng_cnt;                /* total key range count of the array */
+  int key_rng_cnt;                      /* actual key range count */
+
+  ms_value_distr_t *value_distr;        /* array of value distribution */
+  int total_val_rng_cnt;                /* total value range count of the array */
+  int val_rng_cnt;                      /* actual value range count */
+
+  ms_cmd_distr_t cmd_distr[CMD_NULL];   /* total we have CMD_NULL commands */
+  int cmd_used_count;                   /* supported command count */
+
+  size_t fixed_value_size;              /* fixed value size */
+  size_t avg_val_size;                  /* average value size */
+  size_t avg_key_size;                  /* average value size */
+
+  double verify_percent;                /* percent of data verification */
+  double exp_ver_per;                   /* percent of data verification with expire time */
+  double overwrite_percent;             /* percent of overwrite */
+  int mult_key_num;                     /* number of keys used by multi-get once */
+  size_t win_size;                      /* item window size per connection */
+  bool udp;                             /* whether or not use UDP */
+  int stat_freq;                        /* statistic frequency second */
+  bool reconnect;                       /* whether it reconnect when connection close */
+  bool verbose;                         /* whether it outputs detailed information when verification */
+  bool facebook_test;                   /* facebook test, TCP set and multi-get with UDP */
+  uint32_t sock_per_conn;                    /* number of socks per connection structure */
+  bool binary_prot;                     /* whether it use binary protocol */
+  int expected_tps;                     /* expected throughput */
+  uint32_t rep_write_srv;                    /* which servers are used to do replication writing */
+} ms_setting_st;
+
+extern ms_setting_st ms_setting;
+
+/* previous part of initialization of setting structure */
+void ms_setting_init_pre(void);
+
+
+/* post part of initialization of setting structure */
+void ms_setting_init_post(void);
+
+
+/* clean up the global setting structure */
+void ms_setting_cleanup(void);
+
+
+#define UNUSED_ARGUMENT(x)    (void)x
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of MS_SETTING_H */

data/ext/libmemcached-0.50/clients/ms_sigsegv.c

@@ -0,0 +1,126 @@
+/*
+ * File:   ms_sigsegv.c
+ * Author: Mingqiang Zhuang
+ *
+ * Created on March 15, 2009
+ *
+ * (c) Copyright 2009, Schooner Information Technology, Inc.
+ * http://www.schoonerinfotech.com/
+ *
+ * Rewrite of stack dump:
+ *  Copyright (C) 2009 Sun Microsystems
+ *  Author Trond Norbye
+ */
+
+#include "config.h"
+
+#include <memory.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <signal.h>
+#include <pthread.h>
+
+#include "ms_memslap.h"
+#include "ms_setting.h"
+
+/* prototypes */
+int ms_setup_sigsegv(void);
+int ms_setup_sigpipe(void);
+int ms_setup_sigint(void);
+
+
+/* signal seg reaches, this function will run */
+static void ms_signal_segv(int signum, siginfo_t *info, void *ptr)
+{
+  UNUSED_ARGUMENT(signum);
+  UNUSED_ARGUMENT(info);
+  UNUSED_ARGUMENT(ptr);
+
+  pthread_mutex_lock(&ms_global.quit_mutex);
+  fprintf(stderr, "Segmentation fault occurred.\nStack trace:\n");
+  pandora_print_callstack(stderr);
+  fprintf(stderr, "End of stack trace\n");
+  pthread_mutex_unlock(&ms_global.quit_mutex);
+  abort();
+}
+
+/* signal int reaches, this function will run */
+static void ms_signal_int(int signum, siginfo_t *info, void *ptr)
+{
+  UNUSED_ARGUMENT(signum);
+  UNUSED_ARGUMENT(info);
+  UNUSED_ARGUMENT(ptr);
+
+  pthread_mutex_lock(&ms_global.quit_mutex);
+  fprintf(stderr, "SIGINT handled.\n");
+  pthread_mutex_unlock(&ms_global.quit_mutex);
+  exit(1);
+} /* ms_signal_int */
+
+
+/**
+ * redirect signal seg
+ *
+ * @return if success, return EXIT_SUCCESS, else return -1
+ */
+int ms_setup_sigsegv(void)
+{
+  struct sigaction action;
+
+  memset(&action, 0, sizeof(action));
+  action.sa_sigaction= ms_signal_segv;
+  action.sa_flags= SA_SIGINFO;
+  if (sigaction(SIGSEGV, &action, NULL) < 0)
+  {
+    perror("sigaction");
+    return EXIT_SUCCESS;
+  }
+
+  return -1;
+} /* ms_setup_sigsegv */
+
+
+/**
+ * redirect signal pipe
+ *
+ * @return if success, return EXIT_SUCCESS, else return -1
+ */
+int ms_setup_sigpipe(void)
+{
+  /* ignore the SIGPIPE signal */
+  signal(SIGPIPE, SIG_IGN);
+
+  return -1;
+} /* ms_setup_sigpipe */
+
+
+/**
+ * redirect signal int
+ *
+ * @return if success, return EXIT_SUCCESS, else return -1
+ */
+int ms_setup_sigint(void)
+{
+  struct sigaction action_3;
+
+  memset(&action_3, 0, sizeof(action_3));
+  action_3.sa_sigaction= ms_signal_int;
+  action_3.sa_flags= SA_SIGINFO;
+  if (sigaction(SIGINT, &action_3, NULL) < 0)
+  {
+    perror("sigaction");
+    return EXIT_SUCCESS;
+  }
+
+  return -1;
+} /* ms_setup_sigint */
+
+
+#ifndef SIGSEGV_NO_AUTO_INIT
+static void __attribute((constructor)) ms_init(void)
+{
+  ms_setup_sigsegv();
+  ms_setup_sigpipe();
+  ms_setup_sigint();
+}
+#endif

data/ext/libmemcached-0.50/clients/ms_sigsegv.h

@@ -0,0 +1,34 @@
+/*
+ * File:   ms_sigsegv.h
+ * Author: Mingqiang Zhuang
+ *
+ * Created on March 15, 2009
+ *
+ * (c) Copyright 2009, Schooner Information Technology, Inc.
+ * http://www.schoonerinfotech.com/
+ *
+ */
+#ifndef MS_SIGSEGV_H
+#define MS_SIGSEGV_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* redirect signal seg */
+int ms_setup_sigsegv(void);
+
+
+/* redirect signal pipe */
+int ms_setup_sigpipe(void);
+
+
+/* redirect signal int */
+int ms_setup_sigint(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of MS_SIGSEGV_H */

data/ext/libmemcached-0.50/clients/ms_stats.c

@@ -0,0 +1,307 @@
+/*
+ * File:   ms_stats.h
+ * Author: Mingqiang Zhuang
+ *
+ * Created on March 25, 2009
+ *
+ * (c) Copyright 2009, Schooner Information Technology, Inc.
+ * http://www.schoonerinfotech.com/
+ *
+ */
+
+#include "config.h"
+
+#include <inttypes.h>
+#include "ms_stats.h"
+
+#define array_size(x)    (sizeof(x) / sizeof((x)[0]))
+
+static int ms_local_log2(uint64_t value);
+static uint64_t ms_get_events(ms_stat_t *stat);
+
+
+/**
+ * get the index of local log2 array
+ *
+ * @param value
+ *
+ * @return return the index of local log2 array
+ */
+static int ms_local_log2(uint64_t value)
+{
+  int result= 0;
+
+  while (result <= 63 && ((uint64_t)1 << result) < value)
+  {
+    result++;
+  }
+
+  return result;
+} /* ms_local_log2 */
+
+
+/**
+ * initialize statistic structure
+ *
+ * @param stat, pointer of the statistic structure
+ * @param name, name of the statistic
+ */
+void ms_init_stats(ms_stat_t *stat, const char *name)
+{
+  memset(stat, 0, sizeof(*stat));
+
+  stat->name= (char *)name;
+  stat->min_time= (uint64_t)-1;
+  stat->max_time= 0;
+  stat->period_min_time= (uint64_t)-1;
+  stat->period_max_time= 0;
+  stat->log_product= 0;
+  stat->total_time= 0;
+  stat->pre_total_time= 0;
+  stat->squares= 0;
+  stat->pre_squares= 0;
+  stat->pre_events= 0;
+  stat->pre_log_product= 0;
+  stat->get_miss= 0;
+  stat->pre_get_miss= 0;
+} /* ms_init_stats */
+
+
+/**
+ * record one event
+ *
+ * @param stat, pointer of the statistic structure
+ * @param total_time, response time of the command
+ * @param get_miss, whether it gets miss
+ */
+void ms_record_event(ms_stat_t *stat, uint64_t total_time, int get_miss)
+{
+  stat->total_time+= total_time;
+
+  if (total_time < stat->min_time)
+  {
+    stat->min_time= total_time;
+  }
+
+  if (total_time > stat->max_time)
+  {
+    stat->max_time= total_time;
+  }
+
+  if (total_time < stat->period_min_time)
+  {
+    stat->period_min_time= total_time;
+  }
+
+  if (total_time > stat->period_max_time)
+  {
+    stat->period_max_time= total_time;
+  }
+
+  if (get_miss)
+  {
+    stat->get_miss++;
+  }
+
+  stat->dist[ms_local_log2(total_time)]++;
+  stat->squares+= (double)(total_time * total_time);
+
+  if (total_time != 0)
+  {
+    stat->log_product+= log((double)total_time);
+  }
+} /* ms_record_event */
+
+
+/**
+ * get the events count
+ *
+ * @param stat, pointer of the statistic structure
+ *
+ * @return total events recorded
+ */
+static uint64_t ms_get_events(ms_stat_t *stat)
+{
+  uint64_t events= 0;
+
+  for (uint32_t i= 0; i < array_size(stat->dist); i++)
+  {
+    events+= stat->dist[i];
+  }
+
+  return events;
+} /* ms_get_events */
+
+
+/**
+ * dump the statistics
+ *
+ * @param stat, pointer of the statistic structure
+ */
+void ms_dump_stats(ms_stat_t *stat)
+{
+  uint64_t events= 0;
+  int max_non_zero= 0;
+  int min_non_zero= 0;
+  double average= 0;
+
+  for (uint32_t i= 0; i < array_size(stat->dist); i++)
+  {
+    events+= stat->dist[i];
+    if (stat->dist[i] != 0)
+    {
+      max_non_zero= (int)i;
+    }
+  }
+
+  if (events == 0)
+  {
+    return;
+  }
+  average= (double)(stat->total_time / events);
+
+  printf("%s Statistics (%lld events)\n", stat->name, (long long)events);
+  printf("   Min:  %8lld\n", (long long)stat->min_time);
+  printf("   Max:  %8lld\n", (long long)stat->max_time);
+  printf("   Avg:  %8lld\n", (long long)(stat->total_time / events));
+  printf("   Geo:  %8.2lf\n", exp(stat->log_product / (double)events));
+
+  if (events > 1)
+  {
+    printf("   Std:  %8.2lf\n",
+           sqrt((stat->squares - (double)events * average
+                 * average) / ((double)events - 1)));
+  }
+  printf("   Log2 Dist:");
+
+  for (int i= 0; i <= max_non_zero - 4; i+= 4)
+  {
+    if ((stat->dist[i + 0] != 0)
+        || (stat->dist[i + 1] != 0)
+        || (stat->dist[i + 2] != 0)
+        || (stat->dist[i + 3] != 0))
+    {
+      min_non_zero= i;
+      break;
+    }
+  }
+
+  for (int i= min_non_zero; i <= max_non_zero; i++)
+  {
+    if ((i % 4) == 0)
+    {
+      printf("\n      %2d:", (int)i);
+    }
+    printf("   %6" PRIu64 , stat->dist[i]);
+  }
+
+  printf("\n\n");
+} /* ms_dump_stats */
+
+
+/**
+ * dump the format statistics
+ *
+ * @param stat, pointer of the statistic structure
+ * @param run_time, the total run time
+ * @param freq, statistic frequency
+ * @param obj_size, average object size
+ */
+void ms_dump_format_stats(ms_stat_t *stat,
+                          int run_time,
+                          int freq,
+                          int obj_size)
+{
+  uint64_t events= 0;
+  double global_average= 0;
+  uint64_t global_tps= 0;
+  double global_rate= 0;
+  double global_std= 0;
+  double global_log= 0;
+
+  uint64_t diff_time= 0;
+  uint64_t diff_events= 0;
+  double diff_squares= 0;
+  double diff_log_product= 0;
+  double period_average= 0;
+  uint64_t period_tps= 0;
+  double period_rate= 0;
+  double period_std= 0;
+  double period_log= 0;
+
+  if ((events= ms_get_events(stat)) == 0)
+  {
+    return;
+  }
+
+  global_average= (double)(stat->total_time / events);
+  global_tps= events / (uint64_t)run_time;
+  global_rate= (double)events * obj_size / 1024 / 1024 / run_time;
+  global_std= sqrt((stat->squares - (double)events * global_average
+                    * global_average) / (double)(events - 1));
+  global_log= exp(stat->log_product / (double)events);
+
+  diff_time= stat->total_time - stat->pre_total_time;
+  diff_events= events - stat->pre_events;
+  if (diff_events >= 1)
+  {
+    period_average= (double)(diff_time / diff_events);
+    period_tps= diff_events / (uint64_t)freq;
+    period_rate= (double)diff_events * obj_size / 1024 / 1024 / freq;
+    diff_squares= (double)stat->squares - (double)stat->pre_squares;
+    period_std= sqrt((diff_squares - (double)diff_events * period_average
+                      * period_average) / (double)(diff_events - 1));
+    diff_log_product= stat->log_product - stat->pre_log_product;
+    period_log= exp(diff_log_product / (double)diff_events);
+  }
+
+  printf("%s Statistics\n", stat->name);
+  printf("%-8s %-8s %-12s %-12s %-10s %-10s %-8s %-10s %-10s %-10s %-10s\n",
+         "Type",
+         "Time(s)",
+         "Ops",
+         "TPS(ops/s)",
+         "Net(M/s)",
+         "Get_miss",
+         "Min(us)",
+         "Max(us)",
+         "Avg(us)",
+         "Std_dev",
+         "Geo_dist");
+
+  printf(
+    "%-8s %-8d %-12llu %-12lld %-10.1f %-10lld %-8lld %-10lld %-10lld %-10.2f %.2f\n",
+    "Period",
+    freq,
+    (long long)diff_events,
+    (long long)period_tps,
+    global_rate,
+    (long long)(stat->get_miss - stat->pre_get_miss),
+    (long long)stat->period_min_time,
+    (long long)stat->period_max_time,
+    (long long)period_average,
+    period_std,
+    period_log);
+
+  printf(
+    "%-8s %-8d %-12llu %-12lld %-10.1f %-10lld %-8lld %-10lld %-10lld %-10.2f %.2f\n\n",
+    "Global",
+    run_time,
+    (long long)events,
+    (long long)global_tps,
+    period_rate,
+    (long long)stat->get_miss,
+    (long long)stat->min_time,
+    (long long)stat->max_time,
+    (long long)global_average,
+    global_std,
+    global_log);
+
+  stat->pre_events= events;
+  stat->pre_squares= (uint64_t)stat->squares;
+  stat->pre_total_time= stat->total_time;
+  stat->pre_log_product= stat->log_product;
+  stat->period_min_time= (uint64_t)-1;
+  stat->period_max_time= 0;
+  stat->pre_get_miss= stat->get_miss;
+} /* ms_dump_format_stats */