couchbase-memcached 1.2.8

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

@@ -0,0 +1,45 @@
+/* LibMemcached
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ *
+ * Summary:
+ *
+ */
+
+#ifndef __CLIENT_OPTIONS_H__
+#define __CLIENT_OPTIONS_H__
+
+typedef struct memcached_help_text_st memcached_help_text_st;
+
+typedef enum {
+  OPT_SERVERS= 's',
+  OPT_VERSION= 'V',
+  OPT_HELP= 'h',
+  OPT_VERBOSE= 'v',
+  OPT_DEBUG= 'd',
+  OPT_ANALYZE= 'a',
+  OPT_FLAG= 257,
+  OPT_EXPIRE,
+  OPT_SET,
+  OPT_REPLACE,
+  OPT_ADD,
+  OPT_SLAP_EXECUTE_NUMBER,
+  OPT_SLAP_INITIAL_LOAD,
+  OPT_SLAP_TEST,
+  OPT_SLAP_CONCURRENCY,
+  OPT_SLAP_NON_BLOCK,
+  OPT_SLAP_TCP_NODELAY,
+  OPT_FLUSH,
+  OPT_HASH,
+  OPT_BINARY,
+  OPT_UDP,
+  OPT_USERNAME,
+  OPT_PASSWD,
+  OPT_STAT_ARGS,
+  OPT_FILE= 'f'
+} memcached_options;
+
+#endif /* CLIENT_OPTIONS */

data/ext/libmemcached-0.50/clients/execute.cc

@@ -0,0 +1,131 @@
+/* LibMemcached
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ *
+ * Summary:
+ *
+ */
+
+/*
+  Execute a memcached_set() a set of pairs.
+  Return the number of rows set.
+*/
+
+#include "config.h"
+#include "execute.h"
+
+unsigned int execute_set(memcached_st *memc, pairs_st *pairs, unsigned int number_of)
+{
+  memcached_return_t rc;
+  unsigned int x;
+  unsigned int pairs_sent;
+
+  for (x= 0, pairs_sent= 0; x < number_of; x++)
+  {
+    rc= memcached_set(memc, pairs[x].key, pairs[x].key_length,
+                      pairs[x].value, pairs[x].value_length,
+                      0, 0);
+    if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
+      fprintf(stderr, "Failured on insert of %.*s\n",
+              (unsigned int)pairs[x].key_length, pairs[x].key);
+    else
+      pairs_sent++;
+  }
+
+  return pairs_sent;
+}
+
+/*
+  Execute a memcached_get() on a set of pairs.
+  Return the number of rows retrieved.
+*/
+unsigned int execute_get(memcached_st *memc, pairs_st *pairs, unsigned int number_of)
+{
+  memcached_return_t rc;
+  unsigned int x;
+  unsigned int retrieved;
+
+
+  for (retrieved= 0,x= 0; x < number_of; x++)
+  {
+    char *value;
+    size_t value_length;
+    uint32_t flags;
+    unsigned int fetch_key;
+
+    fetch_key= (unsigned int)((unsigned int)random() % number_of);
+
+    value= memcached_get(memc, pairs[fetch_key].key, pairs[fetch_key].key_length,
+                         &value_length, &flags, &rc);
+
+    if (rc != MEMCACHED_SUCCESS)
+      fprintf(stderr, "Failured on read of %.*s\n",
+              (unsigned int)pairs[fetch_key].key_length, pairs[fetch_key].key);
+    else
+      retrieved++;
+
+    free(value);
+  }
+
+  return retrieved;
+}
+
+/**
+ * Callback function to count the number of results
+ */
+static memcached_return_t callback_counter(const memcached_st *ptr,
+                                           memcached_result_st *result,
+                                           void *context)
+{
+  (void)ptr;
+  (void)result;
+  unsigned int *counter= (unsigned int *)context;
+  *counter= *counter + 1;
+
+  return MEMCACHED_SUCCESS;
+}
+
+/**
+ * Try to run a large mget to get all of the keys
+ * @param memc memcached handle
+ * @param keys the keys to get
+ * @param key_length the length of the keys
+ * @param number_of the number of keys to try to get
+ * @return the number of keys received
+ */
+unsigned int execute_mget(memcached_st *memc,
+                          const char * const *keys,
+                          size_t *key_length,
+                          unsigned int number_of)
+{
+  unsigned int retrieved= 0;
+  memcached_execute_fn callbacks[]= { callback_counter };
+  memcached_return_t rc;
+  rc= memcached_mget_execute(memc, keys, key_length,
+                             (size_t)number_of, callbacks, &retrieved, 1);
+
+  if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND ||
+          rc == MEMCACHED_BUFFERED || rc == MEMCACHED_END)
+  {
+    rc= memcached_fetch_execute(memc, callbacks, (void *)&retrieved, 1);
+    if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_NOTFOUND && rc != MEMCACHED_END)
+    {
+      fprintf(stderr, "Failed to execute mget: %s\n",
+              memcached_strerror(memc, rc));
+      memcached_quit(memc);
+      return 0;
+    }
+  }
+  else
+  {
+    fprintf(stderr, "Failed to execute mget: %s\n",
+            memcached_strerror(memc, rc));
+    memcached_quit(memc);
+    return 0;
+  }
+
+  return retrieved;
+}

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

@@ -0,0 +1,30 @@
+/* LibMemcached
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ *
+ * Summary:
+ *
+ */
+
+#pragma once 
+
+#include <stdio.h>
+
+#include "libmemcached/memcached.h"
+#include "clients/generator.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+unsigned int execute_set(memcached_st *memc, pairs_st *pairs, unsigned int number_of);
+unsigned int execute_get(memcached_st *memc, pairs_st *pairs, unsigned int number_of);
+unsigned int execute_mget(memcached_st *memc, const char * const *keys, size_t *key_length,
+                          unsigned int number_of);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

data/ext/libmemcached-0.50/clients/generator.cc

@@ -0,0 +1,96 @@
+/* LibMemcached
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ *
+ * Summary:
+ *
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "generator.h"
+
+/* Use this for string generation */
+static const char ALPHANUMERICS[]=
+  "0123456789ABCDEFGHIJKLMNOPQRSTWXYZabcdefghijklmnopqrstuvwxyz";
+
+#define ALPHANUMERICS_SIZE (sizeof(ALPHANUMERICS)-1)
+
+static size_t get_alpha_num(void)
+{
+  return (size_t)random() % ALPHANUMERICS_SIZE;
+}
+
+static void get_random_string(char *buffer, size_t size)
+{
+  char *buffer_ptr= buffer;
+
+  while (--size)
+    *buffer_ptr++= ALPHANUMERICS[get_alpha_num()];
+  *buffer_ptr++= ALPHANUMERICS[get_alpha_num()];
+}
+
+void pairs_free(pairs_st *pairs)
+{
+  uint32_t x;
+
+  if (! pairs)
+    return;
+
+  /* We free until we hit the null pair we stores during creation */
+  for (x= 0; pairs[x].key; x++)
+  {
+    free(pairs[x].key);
+    if (pairs[x].value)
+      free(pairs[x].value);
+  }
+
+  free(pairs);
+}
+
+pairs_st *pairs_generate(uint64_t number_of, size_t value_length)
+{
+  unsigned int x;
+  pairs_st *pairs;
+
+  pairs= (pairs_st*)calloc((size_t)number_of + 1, sizeof(pairs_st));
+
+  if (!pairs)
+    goto error;
+
+  for (x= 0; x < number_of; x++)
+  {
+    pairs[x].key= (char *)calloc(100, sizeof(char));
+    if (!pairs[x].key)
+      goto error;
+    get_random_string(pairs[x].key, 100);
+    pairs[x].key_length= 100;
+
+    if (value_length)
+    {
+      pairs[x].value= (char *)calloc(value_length, sizeof(char));
+      if (!pairs[x].value)
+        goto error;
+      get_random_string(pairs[x].value, value_length);
+      pairs[x].value_length= value_length;
+    }
+    else
+    {
+      pairs[x].value= NULL;
+      pairs[x].value_length= 0;
+    }
+  }
+
+  return pairs;
+error:
+    fprintf(stderr, "Memory Allocation failure in pairs_generate.\n");
+    exit(0);
+}

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

@@ -0,0 +1,36 @@
+/* LibMemcached
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ *
+ * Summary:
+ *
+ */
+
+/*
+  Code to generate data to be pushed into memcached
+*/
+
+#pragma once
+
+typedef struct pairs_st pairs_st;
+
+struct pairs_st {
+  char *key;
+  size_t key_length;
+  char *value;
+  size_t value_length;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+pairs_st *pairs_generate(uint64_t number_of, size_t value_length);
+void pairs_free(pairs_st *pairs);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

data/ext/libmemcached-0.50/clients/include.am

@@ -0,0 +1,116 @@
+# vim:ft=automake
+# included from Top Level Makefile.am
+# All paths should be given relative to the root
+
+CLIENTS_LDADDS= \
+		$(LIBM) \
+		clients/libutilities.la \
+		libmemcached/libmemcached.la
+
+if HAVE_SASL
+CLIENTS_LDADDS+= $(LIBSASL)
+endif
+
+bin_PROGRAMS+= \
+	clients/memcapable \
+	clients/memcat \
+	clients/memcp \
+	clients/memdump \
+	clients/memerror \
+	clients/memflush \
+	clients/memparse \
+	clients/memrm \
+	clients/memslap \
+	clients/memstat
+
+if BUILD_MEMASLAP
+if HAVE_LIBEVENT
+if !BUILD_WIN32_WRAPPERS
+  bin_PROGRAMS+= clients/memaslap
+endif
+endif
+endif
+
+noinst_HEADERS+= \
+		clients/client_options.h \
+		clients/execute.h \
+		clients/generator.h \
+		clients/ms_atomic.h \
+		clients/ms_conn.h \
+		clients/ms_memslap.h \
+		clients/ms_setting.h \
+		clients/ms_sigsegv.h \
+		clients/ms_stats.h \
+		clients/ms_task.h \
+		clients/ms_thread.h \
+		clients/utilities.h
+
+noinst_LTLIBRARIES+= clients/libutilities.la
+clients_libutilities_la_SOURCES= clients/utilities.cc
+
+clients_memcat_SOURCES= clients/memcat.cc
+clients_memcat_LDADD= $(CLIENTS_LDADDS)
+
+clients_memparse_SOURCES= clients/memparse.cc
+clients_memparse_LDADD= $(CLIENTS_LDADDS)
+
+clients_memcp_SOURCES= clients/memcp.cc
+clients_memcp_LDADD= $(CLIENTS_LDADDS)
+
+clients_memdump_SOURCES= clients/memdump.cc
+clients_memdump_LDADD= $(CLIENTS_LDADDS)
+
+clients_memstat_SOURCES= clients/memstat.cc
+clients_memstat_LDADD= $(CLIENTS_LDADDS)
+
+clients_memrm_SOURCES= clients/memrm.cc
+clients_memrm_LDADD= $(CLIENTS_LDADDS)
+
+clients_memflush_SOURCES= clients/memflush.cc
+clients_memflush_LDADD= $(CLIENTS_LDADDS)
+
+clients_memerror_SOURCES= clients/memerror.cc
+clients_memerror_LDADD= $(CLIENTS_LDADDS)
+
+clients_memslap_SOURCES = clients/memslap.cc
+clients_memslap_SOURCES+= clients/generator.cc clients/execute.cc
+clients_memslap_LDADD = $(PTHREAD_LIBS) $(CLIENTS_LDADDS)
+
+clients_memaslap_SOURCES= \
+			  clients/memaslap.c \
+			  clients/ms_conn.c \
+			  clients/ms_setting.c \
+			  clients/ms_sigsegv.c \
+			  clients/ms_stats.c \
+			  clients/ms_task.c \
+			  clients/ms_thread.c
+clients_memaslap_SOURCES+= clients/generator.cc clients/execute.cc
+clients_memaslap_LDADD= $(LTLIBEVENT) $(CLIENTS_LDADDS)
+
+clients_memcapable_SOURCES= \
+			    clients/memcapable.cc \
+			    libmemcached/byteorder.cc
+clients_memcapable_LDADD= $(CLIENTS_LDADDS)
+
+test-start-server:
+	clients/memflush --servers=localhost
+	clients/memcp --servers=localhost /etc/services
+	clients/memcat --servers=localhost /etc/services
+	clients/memrm --servers=localhost /etc/services
+	clients/memstat --servers=localhost
+	clients/memslap --servers=localhost
+	clients/memslap --servers=localhost --concurrency=10
+	clients/memslap --servers=localhost --concurrency=10 --initial-load=1000
+	clients/memslap --servers=localhost --concurrency=10 --initial-load=1000 --execute-number=10
+	clients/memslap --servers=localhost --concurrency=10 --initial-load=1000 --execute-number=10 --test=get
+	clients/memslap --servers=localhost --concurrency=10 --initial-load=1000 --execute-number=10 --test=set
+	clients/memslap --servers=localhost --concurrency=10 --initial-load=1000 --execute-number=10 --test=set --non-blocking
+
+client-valgrind:
+	libtool --mode=execute valgrind --leak-check=yes --show-reachable=yes  clients/memslap --servers=localhost
+	libtool --mode=execute valgrind --leak-check=yes --show-reachable=yes  clients/memslap --servers=localhost --concurrency=10
+	libtool --mode=execute valgrind --leak-check=yes --show-reachable=yes  clients/memslap --servers=localhost --concurrency=10 --initial-load=1000
+	libtool --mode=execute valgrind --leak-check=yes --show-reachable=yes  clients/memslap --servers=localhost --concurrency=10 --initial-load=1000 --execute-number=10
+	libtool --mode=execute valgrind --leak-check=yes --show-reachable=yes  clients/memslap --servers=localhost --concurrency=10 --initial-load=1000 --execute-number=10 --test=get
+	libtool --mode=execute valgrind --leak-check=yes --show-reachable=yes  clients/memslap --servers=localhost --concurrency=10 --initial-load=1000 --execute-number=10 --test=set
+	libtool --mode=execute valgrind --leak-check=yes --show-reachable=yes  clients/memslap --servers=localhost --concurrency=10 --initial-load=1000 --execute-number=10 --test=set --non-blocking