couchbase-memcached 1.2.8

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

@@ -0,0 +1,94 @@
+/*
+ * File:   ms_task.h
+ * Author: Mingqiang Zhuang
+ *
+ * Created on February 10, 2009
+ *
+ * (c) Copyright 2009, Schooner Information Technology, Inc.
+ * http://www.schoonerinfotech.com/
+ *
+ */
+#ifndef MS_TASK_H
+#define MS_TASK_H
+
+#include <sys/types.h>
+#include <stdint.h>
+#if !defined(__cplusplus)
+# include <stdbool.h>
+#endif
+#include <time.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define UNIT_ITEMS_COUNT     1024               /* each window unit has 1024 items */
+#define KEY_PREFIX_SIZE      (sizeof(uint64_t)) /* key prefix length: 8 bytes */
+#define INVALID_OFFSET       (-1)               /* invalid offset in the character table */
+#define FIXED_EXPIRE_TIME    60                 /* default expire time is 60s */
+#define EXPIRE_TIME_ERROR    5                  /* default expire time error is 5s */
+
+/* information of a task item(object) */
+typedef struct task_item
+{
+  uint64_t key_prefix;                  /* prefix of the key, 8 bytes, binary */
+  int key_size;                         /* key size */
+  int key_suffix_offset;                /* suffix offset in the global character table */
+
+  int value_size;                       /* data size */
+  int value_offset;                     /* data offset in the global character table */
+
+  time_t client_time;                   /* the current client time */
+  int exp_time;                         /* expire time */
+} ms_task_item_t;
+
+/* task item for multi-get */
+typedef struct mlget_task_item
+{
+  ms_task_item_t *item;                 /* task item */
+  bool verify;                          /* whether verify data or not */
+  bool finish_verify;                   /* whether finish data verify or not */
+  bool get_miss;                        /* whether get miss or not */
+} ms_mlget_task_item_t;
+
+/* information of multi-get task */
+typedef struct mlget_task
+{
+  ms_mlget_task_item_t *mlget_item;        /* multi-get task array */
+  int mlget_num;                           /* how many tasks in mlget_task array */
+  int value_index;                         /* the nth value received by the connect, for multi-get */
+} ms_mlget_task_t;
+
+/* structure used to store the state of the running task */
+typedef struct task
+{
+  int cmd;                              /* command name */
+  bool verify;                          /* whether verify data or not */
+  bool finish_verify;                   /* whether finish data verify or not */
+  bool get_miss;                        /* whether get miss or not */
+  ms_task_item_t *item;                 /* task item */
+
+  /* counter for command distribution adjustment */
+  uint64_t get_opt;                     /* number of total get operations */
+  uint64_t set_opt;                     /* number of total set operations, no including warmup set count */
+  int cycle_undo_get;                   /* number of undo get in an adjustment cycle */
+  int cycle_undo_set;                   /* number of undo set in an adjustment cycle */
+  uint64_t verified_get;                /* number of total verified get operations */
+  uint64_t overwrite_set;               /* number of total overwrite set operations */
+} ms_task_t;
+
+struct conn;
+
+/* the state machine call the function to execute task.*/
+int ms_exec_task(struct conn *c);
+
+
+/* calculate the difference value of two time points */
+int64_t ms_time_diff(struct timeval *start_time, struct timeval *end_time);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of MS_TASK_H */

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

@@ -0,0 +1,351 @@
+/*
+ * File:   ms_thread.c
+ * Author: Mingqiang Zhuang
+ *
+ * Created on February 10, 2009
+ *
+ * (c) Copyright 2009, Schooner Information Technology, Inc.
+ * http://www.schoonerinfotech.com/
+ *
+ */
+
+#include "config.h"
+
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+#include "ms_thread.h"
+#include "ms_setting.h"
+#include "ms_atomic.h"
+
+/* global variable */
+pthread_key_t ms_thread_key;
+
+/* array of thread context structure, each thread has a thread context structure */
+static ms_thread_ctx_t *ms_thread_ctx;
+
+/* functions */
+static void ms_set_current_time(void);
+static void ms_check_sock_timeout(void);
+static void ms_clock_handler(const int fd, const short which, void *arg);
+static uint32_t ms_set_thread_cpu_affinity(uint32_t cpu);
+static int ms_setup_thread(ms_thread_ctx_t *thread_ctx);
+static void *ms_worker_libevent(void *arg);
+static void ms_create_worker(void *(*func)(void *), void *arg);
+
+
+/**
+ *  time-sensitive callers can call it by hand with this,
+ *  outside the normal ever-1-second timer
+ */
+static void ms_set_current_time()
+{
+  struct timeval timer;
+  ms_thread_t *ms_thread= pthread_getspecific(ms_thread_key);
+
+  gettimeofday(&timer, NULL);
+  ms_thread->curr_time= (rel_time_t)timer.tv_sec;
+} /* ms_set_current_time */
+
+
+/**
+ *  used to check whether UDP of command are waiting timeout
+ *  by the ever-1-second timer
+ */
+static void ms_check_sock_timeout(void)
+{
+  ms_thread_t *ms_thread= pthread_getspecific(ms_thread_key);
+  ms_conn_t *c= NULL;
+  int time_diff= 0;
+
+  for (uint32_t i= 0; i < ms_thread->thread_ctx->nconns; i++)
+  {
+    c= &ms_thread->conn[i];
+
+    if (c->udp)
+    {
+      time_diff= (int)(ms_thread->curr_time - (rel_time_t)c->start_time.tv_sec);
+
+      /* wait time out */
+      if (time_diff > SOCK_WAIT_TIMEOUT)
+      {
+        /* calculate dropped packets count */
+        if (c->recvpkt > 0)
+        {
+          atomic_add_size(&ms_stats.pkt_drop, c->packets - c->recvpkt);
+        }
+
+        atomic_add_size(&ms_stats.udp_timeout, 1);
+        ms_reset_conn(c, true);
+      }
+    }
+  }
+} /* ms_check_sock_timeout */
+
+
+/* if disconnect, the ever-1-second timer will call this function to reconnect */
+static void ms_reconn_thread_socks(void)
+{
+  ms_thread_t *ms_thread= pthread_getspecific(ms_thread_key);
+  for (uint32_t i= 0; i < ms_thread->thread_ctx->nconns; i++)
+  {
+    ms_reconn_socks(&ms_thread->conn[i]);
+  }
+} /* ms_reconn_thread_socks */
+
+
+/**
+ * the handler of the ever-1-second timer
+ *
+ * @param fd, the descriptors of the socket
+ * @param which, event flags
+ * @param arg, argument
+ */
+static void ms_clock_handler(const int fd, const short which, void *arg)
+{
+  ms_thread_t *ms_thread= pthread_getspecific(ms_thread_key);
+  struct timeval t=
+  {
+    .tv_sec= 1, .tv_usec= 0
+  };
+
+  UNUSED_ARGUMENT(fd);
+  UNUSED_ARGUMENT(which);
+  UNUSED_ARGUMENT(arg);
+
+  ms_set_current_time();
+
+  if (ms_thread->initialized)
+  {
+    /* only delete the event if it's actually there. */
+    evtimer_del(&ms_thread->clock_event);
+    ms_check_sock_timeout();
+  }
+  else
+  {
+    ms_thread->initialized= true;
+  }
+
+  ms_reconn_thread_socks();
+
+  evtimer_set(&ms_thread->clock_event, ms_clock_handler, 0);
+  event_base_set(ms_thread->base, &ms_thread->clock_event);
+  evtimer_add(&ms_thread->clock_event, &t);
+} /* ms_clock_handler */
+
+
+/**
+ * used to bind thread to CPU if the system supports
+ *
+ * @param cpu, cpu index
+ *
+ * @return if success, return EXIT_SUCCESS, else return -1
+ */
+static uint32_t ms_set_thread_cpu_affinity(uint32_t cpu)
+{
+  uint32_t ret= 0;
+
+#ifdef HAVE_CPU_SET_T
+  cpu_set_t cpu_set;
+  CPU_ZERO(&cpu_set);
+  CPU_SET(cpu, &cpu_set);
+
+  if (sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set) == -1)
+  {
+    fprintf(stderr, "WARNING: Could not set CPU Affinity, continuing...\n");
+    ret= 1;
+  }
+#else
+  UNUSED_ARGUMENT(cpu);
+#endif
+
+  return ret;
+} /* ms_set_thread_cpu_affinity */
+
+
+/**
+ * Set up a thread's information.
+ *
+ * @param thread_ctx, pointer of the thread context structure
+ *
+ * @return if success, return EXIT_SUCCESS, else return -1
+ */
+static int ms_setup_thread(ms_thread_ctx_t *thread_ctx)
+{
+
+  ms_thread_t *ms_thread= (ms_thread_t *)calloc(sizeof(*ms_thread), 1);
+  pthread_setspecific(ms_thread_key, (void *)ms_thread);
+
+  ms_thread->thread_ctx= thread_ctx;
+  ms_thread->nactive_conn= thread_ctx->nconns;
+  ms_thread->initialized= false;
+  static volatile uint32_t cnt= 0;
+
+  gettimeofday(&ms_thread->startup_time, NULL);
+
+  ms_thread->base= event_init();
+  if (ms_thread->base == NULL)
+  {
+    if (atomic_add_32_nv(&cnt, 1) == 0)
+    {
+      fprintf(stderr, "Can't allocate event base.\n");
+    }
+
+    return -1;
+  }
+
+  ms_thread->conn=
+    (ms_conn_t *)malloc((size_t)thread_ctx->nconns * sizeof(ms_conn_t));
+  if (ms_thread->conn == NULL)
+  {
+    if (atomic_add_32_nv(&cnt, 1) == 0)
+    {
+      fprintf(
+        stderr,
+        "Can't allocate concurrency structure for thread descriptors.");
+    }
+
+    return -1;
+  }
+  memset(ms_thread->conn, 0, (size_t)thread_ctx->nconns * sizeof(ms_conn_t));
+
+  for (uint32_t i= 0; i < thread_ctx->nconns; i++)
+  {
+    ms_thread->conn[i].conn_idx= i;
+    if (ms_setup_conn(&ms_thread->conn[i]) != 0)
+    {
+      /* only output this error once */
+      if (atomic_add_32_nv(&cnt, 1) == 0)
+      {
+        fprintf(stderr, "Initializing connection failed.\n");
+      }
+
+      return -1;
+    }
+  }
+
+  return EXIT_SUCCESS;
+} /* ms_setup_thread */
+
+
+/**
+ * Worker thread: main event loop
+ *
+ * @param arg, the pointer of argument
+ *
+ * @return void*
+ */
+static void *ms_worker_libevent(void *arg)
+{
+  ms_thread_t *ms_thread= NULL;
+  ms_thread_ctx_t *thread_ctx= (ms_thread_ctx_t *)arg;
+
+  /**
+   * If system has more than one cpu and supports set cpu
+   * affinity, try to bind each thread to a cpu core;
+   */
+  if (ms_setting.ncpu > 1)
+  {
+    ms_set_thread_cpu_affinity(thread_ctx->thd_idx % ms_setting.ncpu);
+  }
+
+  if (ms_setup_thread(thread_ctx) != 0)
+  {
+    exit(1);
+  }
+
+  /* each thread with a timer */
+  ms_clock_handler(0, 0, 0);
+
+  pthread_mutex_lock(&ms_global.init_lock.lock);
+  ms_global.init_lock.count++;
+  pthread_cond_signal(&ms_global.init_lock.cond);
+  pthread_mutex_unlock(&ms_global.init_lock.lock);
+
+  ms_thread= pthread_getspecific(ms_thread_key);
+  event_base_loop(ms_thread->base, 0);
+
+  return NULL;
+} /* ms_worker_libevent */
+
+
+/**
+ * Creates a worker thread.
+ *
+ * @param func, the callback function
+ * @param arg, the argument to pass to the callback function
+ */
+static void ms_create_worker(void *(*func)(void *), void *arg)
+{
+  pthread_t thread;
+  pthread_attr_t attr;
+  int ret;
+
+  pthread_attr_init(&attr);
+
+  if ((ret= pthread_create(&thread, &attr, func, arg)) != 0)
+  {
+    fprintf(stderr, "Can't create thread: %s.\n", strerror(ret));
+    exit(1);
+  }
+} /* ms_create_worker */
+
+
+/* initialize threads */
+void ms_thread_init()
+{
+  ms_thread_ctx=
+    (ms_thread_ctx_t *)malloc(
+      sizeof(ms_thread_ctx_t) * (size_t)ms_setting.nthreads);
+  if (ms_thread_ctx == NULL)
+  {
+    fprintf(stderr, "Can't allocate thread descriptors.");
+    exit(1);
+  }
+
+  for (uint32_t i= 0; i < ms_setting.nthreads; i++)
+  {
+    ms_thread_ctx[i].thd_idx= i;
+    ms_thread_ctx[i].nconns= ms_setting.nconns / ms_setting.nthreads;
+
+    /**
+     *  If only one server, all the connections in all threads
+     *  connects the same server. For support multi-servers, simple
+     *  distribute thread to server.
+     */
+    ms_thread_ctx[i].srv_idx= i % ms_setting.srv_cnt;
+    ms_thread_ctx[i].tps_perconn= ms_setting.expected_tps
+                                  / (int)ms_setting.nconns;
+    ms_thread_ctx[i].exec_num_perconn= ms_setting.exec_num
+                                       / ms_setting.nconns;
+  }
+
+  if (pthread_key_create(&ms_thread_key, NULL))
+  {
+    fprintf(stderr, "Can't create pthread keys. Major malfunction!\n");
+    exit(1);
+  }
+  /* Create threads after we've done all the epoll setup. */
+  for (uint32_t i= 0; i < ms_setting.nthreads; i++)
+  {
+    ms_create_worker(ms_worker_libevent, (void *)&ms_thread_ctx[i]);
+  }
+} /* ms_thread_init */
+
+
+/* cleanup some resource of threads when all the threads exit */
+void ms_thread_cleanup()
+{
+  if (ms_thread_ctx != NULL)
+  {
+    free(ms_thread_ctx);
+  }
+  pthread_key_delete(ms_thread_key);
+} /* ms_thread_cleanup */

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

@@ -0,0 +1,78 @@
+/*
+ * File:   ms_thread.h
+ * Author: Mingqiang Zhuang
+ *
+ * Created on February 10, 2009
+ *
+ * (c) Copyright 2009, Schooner Information Technology, Inc.
+ * http://www.schoonerinfotech.com/
+ *
+ */
+
+/**
+ * Asynchronous memslap has the similar implementation of
+ * multi-threads with memcached. Asynchronous memslap creates
+ * one or more self-governed threads; each thread is bound with
+ * one CPU core if the system supports setting CPU core
+ * affinity. And every thread has private variables. There is
+ * less communication or some shared resources among all the
+ * threads. It can improve the performance because there are
+ * fewer locks and competition. In addition, each thread has a
+ * libevent to manage the events of network. Each thread has one
+ * or more self-governed concurrencies; each concurrency has one
+ * or more socket connections. All the concurrencies don't
+ * communicate with each other even though they are in the same
+ * thread.
+ */
+#ifndef MS_THREAD_H
+#define MS_THREAD_H
+
+#include <sched.h>
+#include "ms_conn.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Time relative to server start. Smaller than time_t on 64-bit systems. */
+typedef unsigned int   rel_time_t;
+
+/* Used to store the context of each thread */
+typedef struct thread_ctx
+{
+  uint32_t thd_idx;                          /* the thread index */
+  uint32_t nconns;                           /* how many connections included by the thread */
+  uint32_t srv_idx;                          /* index of the thread */
+  int tps_perconn;                      /* expected throughput per connection */
+  int64_t exec_num_perconn;             /* execute number per connection */
+} ms_thread_ctx_t;
+
+/* Used to store the private variables of each thread */
+typedef struct thread
+{
+  ms_conn_t *conn;                      /* conn array to store all the conn in the thread */
+  uint32_t nactive_conn;                     /* how many connects are active */
+
+  ms_thread_ctx_t *thread_ctx;          /* thread context from the caller */
+  struct event_base *base;              /* libevent handler created by this thread */
+
+  rel_time_t curr_time;                 /* current time */
+  struct event clock_event;             /* clock event to time each one second */
+  bool initialized;                     /* whether clock_event has been initialized */
+
+  struct timeval startup_time;          /* start time of the thread */
+} ms_thread_t;
+
+/* initialize threads */
+void ms_thread_init(void);
+
+
+/* cleanup some resource of threads when all the threads exit */
+void ms_thread_cleanup(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of MS_THREAD_H */