libcouchbase 0.0.1

data/ext/libcouchbase/src/timings.c

@@ -0,0 +1,208 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2011-2015 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+#include "internal.h"
+
+/**
+ * Timing data in libcouchbase is stored in a structure to make
+ * it easy to work with. It ill consume a fair amount of data,
+ * but it's only allocated when you enable it ;-)
+ * I decided I'd rather just make it easy to work with...
+ */
+struct lcb_histogram_st {
+    /** The highest value (number of ocurrences ) in all of the buckets */
+    lcb_U32 max;
+
+    /** Number of entries below a microsecond */
+    lcb_U32 nsec;
+
+    /**
+     * Entries between 1-1000 microseconds. Each array element refers to a
+     * 10 microsecond interval
+     */
+    lcb_U32 usec[100];
+
+    /**
+     * Entries between 1-10 milliseconds. Each array entry refers to a 100
+     * microsecond interval.
+     */
+    lcb_U32 lt10msec[100];
+
+    /**
+     * Entries between 10-1000 milliseconds. Each entry refers to a 10 millisecond
+     * interval
+     */
+    lcb_U32 msec[100];
+
+    /**
+     * Seconds are collected per sec
+     */
+    lcb_U32 sec[10];
+};
+
+LCB_INTERNAL_API
+lcb_HISTOGRAM *
+lcb_histogram_create(void)
+{
+    return calloc(1, sizeof(lcb_HISTOGRAM));
+}
+
+LCB_INTERNAL_API
+void
+lcb_histogram_destroy(lcb_HISTOGRAM *hg)
+{
+    free(hg);
+}
+
+
+LCB_INTERNAL_API
+void
+lcb_histogram_read(const lcb_HISTOGRAM *hg,
+    const void *cookie, lcb_HISTOGRAM_CALLBACK callback)
+{
+    lcb_U32 max, start, ii, end;
+
+    max = hg->max;
+    /*
+    ** @todo I should merge "empty" sets.. currently I'm only going to
+    ** report the nonzero ones...
+    */
+    if (hg->nsec) {
+        callback(cookie, LCB_TIMEUNIT_NSEC, 0, 999, hg->nsec, max);
+    }
+
+    start = 1;
+    for (ii = 0; ii < 100; ++ii) {
+        end = (ii + 1) * 10 - 1;
+        if (hg->usec[ii]) {
+            callback(cookie, LCB_TIMEUNIT_USEC, start, end, hg->usec[ii], max);
+        }
+        start = end + 1;
+    }
+
+    start = 1000;
+    for (ii = 0; ii < 100; ++ii) {
+        end = (ii + 1) * 100 - 1;
+        if (hg->lt10msec[ii]) {
+            callback(cookie, LCB_TIMEUNIT_USEC, start, end, hg->lt10msec[ii], max);
+        }
+        start = end + 1;
+    }
+
+    start = 1;
+    for (ii = 0; ii < 100; ++ii) {
+        end = (ii + 1) * 10 - 1;
+        if (hg->msec[ii]) {
+            callback(cookie, LCB_TIMEUNIT_MSEC, start, end, hg->msec[ii], max);
+        }
+        start = end + 1;
+    }
+
+    start = 1000;
+    for (ii = 1; ii < 9; ++ii) {
+        start = ii * 1000;
+        end = ((ii + 1) * 1000) - 1;
+        if (hg->sec[ii]) {
+            callback(cookie, LCB_TIMEUNIT_MSEC, start, end, hg->sec[ii], max);
+        }
+    }
+
+    if (hg->sec[9]) {
+        callback(cookie, LCB_TIMEUNIT_SEC, 9, 9999, hg->sec[9], max);
+    }
+}
+
+static void
+default_timings_callback(const void *cookie,
+                         lcb_timeunit_t timeunit,
+                         lcb_uint32_t min_val, lcb_uint32_t max_val,
+                         lcb_uint32_t total, lcb_uint32_t maxtotal) {
+    FILE* stream = (FILE*)cookie;
+    const char *unit = NULL;
+    int ii;
+    int num_hash;
+
+    fprintf(stream, "[%-4u - %-4u]", min_val, max_val);
+    if (timeunit == LCB_TIMEUNIT_NSEC) {
+        unit = "ns";
+    } else if (timeunit == LCB_TIMEUNIT_USEC) {
+        unit = "us";
+    } else if (timeunit == LCB_TIMEUNIT_MSEC) {
+        unit = "ms";
+    } else if (timeunit == LCB_TIMEUNIT_SEC) {
+        unit = "s";
+    } else {
+        unit = "?";
+    }
+    fprintf(stream, "%s |", unit);
+
+    num_hash = (int)((float)40.0 * (float)total / (float)maxtotal);
+
+    for (ii = 0; ii < num_hash; ++ii) {
+        putw('#', stream);
+    }
+
+    fprintf(stream, " - %u\n", total);
+}
+
+
+LCB_INTERNAL_API
+void lcb_histogram_print(lcb_HISTOGRAM* hg, FILE* stream)
+{
+    lcb_histogram_read(hg, stream, default_timings_callback);
+}
+
+
+LCB_INTERNAL_API
+void
+lcb_histogram_record(lcb_HISTOGRAM *hg, lcb_U64 delta)
+{
+    lcb_U32 num;
+
+    if (delta < 1000) {
+        /* nsec */
+        if (++hg->nsec > hg->max) {
+            hg->max = hg->nsec;
+        }
+    } else if (delta < LCB_US2NS(1000)) {
+        /* micros */
+        delta /= LCB_US2NS(1);
+        if ((num = ++hg->usec[delta/10]) > hg->max) {
+            hg->max = num;
+        }
+    } else if (delta < LCB_US2NS(10000)) {
+        /* 1-10ms */
+        delta /= LCB_US2NS(1);
+        assert(delta <= 10000);
+        if ((num = ++hg->lt10msec[delta/100]) > hg->max) {
+            hg->max = num;
+        }
+    } else if (delta < LCB_S2NS(1)) {
+        delta /= LCB_US2NS(1000);
+        if ((num = ++hg->msec[delta/10]) > hg->max) {
+            hg->max = num;
+        }
+    } else {
+        delta /= LCB_S2NS(1);
+        if (delta > 9) {
+            delta = 9;
+        }
+
+        if ((num = ++hg->sec[delta]) > hg->max) {
+            hg->max = num;
+        }
+    }
+}

data/ext/libcouchbase/src/trace.h

@@ -0,0 +1,105 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#ifndef LIBCOUCHBASE_TRACE_H
+#define LIBCOUCHBASE_TRACE_H 1
+
+#ifdef __clang__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
+#endif
+
+#ifdef HAVE_DTRACE
+/* include the generated probes header and put markers in code */
+#include "probes.h"
+#define TRACE(probe) probe
+
+#else
+/* Wrap the probe to allow it to be removed when no systemtap available */
+#define TRACE(probe)
+#endif
+
+#define TRACE_BEGIN_COMMON(TGT, req, cmd,  ...) \
+    TGT((req)->request.opaque, ntohs((req)->request.vbucket), (req)->request.opcode, \
+    (cmd)->key.contig.bytes, (cmd)->key.contig.nbytes, ## __VA_ARGS__)
+
+#define TRACE_BEGIN_SIMPLE(TGT, req, cmd) \
+    TGT((req)->request.opaque, ntohs((req)->request.vbucket), (req)->request.opcode, \
+        (cmd)->key.contig.bytes, (cmd)->key.contig.nbytes)
+
+#define TRACE_END_COMMON(TGT, mcresp, resp, ...) \
+    TGT(PACKET_OPAQUE(mcresp), 0, PACKET_OPCODE(mcresp), (resp)->rc, (resp)->key, (resp)->nkey, \
+        ## __VA_ARGS__)
+
+#define TRACE_END_SIMPLE(TGT, mcresp, resp) \
+    TGT(PACKET_OPAQUE(mcresp), 0, PACKET_OPCODE(mcresp), (resp)->rc, (resp)->key, (resp)->nkey)
+
+#define TRACE_GET_BEGIN(req, cmd) \
+    TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_GET_BEGIN, req, cmd, (cmd)->exptime))
+
+#define TRACE_GET_END(mcresp, resp) \
+    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_GET_END, mcresp, resp, \
+        (char*)(resp)->value, (resp)->nvalue, (resp)->itmflags, (resp)->cas, \
+        PACKET_DATATYPE(mcresp)))
+
+#define TRACE_UNLOCK_BEGIN(req, cmd) TRACE(TRACE_BEGIN_SIMPLE(LIBCOUCHBASE_UNLOCK_BEGIN, req, cmd))
+#define TRACE_UNLOCK_END(mcresp, resp) TRACE(TRACE_END_SIMPLE(LIBCOUCHBASE_UNLOCK_END, mcresp, resp))
+
+#define TRACE_STORE_BEGIN(req, cmd) \
+    TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_STORE_BEGIN, req, cmd, \
+        ( (cmd)->value.vtype == LCB_KV_IOV ? NULL : (cmd)->value.u_buf.contig.bytes ),\
+        ( (cmd)->value.vtype == LCB_KV_IOV ? 0 : (cmd)->value.u_buf.contig.nbytes ),\
+        (cmd)->flags, (cmd)->cas, (req)->request.datatype, (cmd)->exptime))
+
+#define TRACE_STORE_END(mcresp, resp) TRACE(TRACE_END_COMMON(LIBCOUCHBASE_STORE_END, mcresp, resp, (resp)->cas))
+
+#define TRACE_ARITHMETIC_BEGIN(req, cmd) \
+    TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_ARITHMETIC_BEGIN, req, cmd, \
+        (cmd)->delta, (cmd)->initial, (cmd)->exptime))
+
+#define TRACE_ARITHMETIC_END(mcresp, resp) \
+    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_ARITHMETIC_END, mcresp, resp, (resp)->value, (resp)->cas))
+
+#define TRACE_TOUCH_BEGIN(req, cmd) \
+    TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_TOUCH_BEGIN, req, cmd, (cmd)->exptime))
+#define TRACE_TOUCH_END(mcresp, resp) \
+    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_TOUCH_END, mcresp, resp, (resp)->cas))
+
+#define TRACE_REMOVE_BEGIN(req, cmd) TRACE(TRACE_BEGIN_SIMPLE(LIBCOUCHBASE_REMOVE_BEGIN, req, cmd))
+#define TRACE_REMOVE_END(mcresp, resp) \
+    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_REMOVE_END, mcresp, resp, (resp)->cas))
+
+#define TRACE_OBSERVE_BEGIN(req, body) \
+    TRACE(LIBCOUCHBASE_OBSERVE_BEGIN(\
+        (req)->request.opaque, 0, (req)->request.opcode, body, \
+        ntohl( (req)->request.bodylen) ))
+
+#define TRACE_OBSERVE_PROGRESS(mcresp, resp) \
+    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_OBSERVE_PROGRESS,mcresp,resp, \
+        (resp)->cas, (resp)->status, (resp)->ismaster, (resp)->ttp, (resp)->ttr))
+
+#define TRACE_OBSERVE_END(mcresp) \
+    TRACE(LIBCOUCHBASE_OBSERVE_END(PACKET_OPAQUE(mcresp), 0, PACKET_OPCODE(mcresp), LCB_SUCCESS))
+
+#define TRACE_HTTP_BEGIN(req) TRACE(LIBCOUCHBASE_HTTP_BEGIN((req)->url, (req)->nurl, (req)->method))
+#define TRACE_HTTP_END(req, rc, resp) TRACE(LIBCOUCHBASE_HTTP_END((req)->url, (req)->nurl, (req)->method, (resp)->rc, (resp)->htstatus
+
+#ifdef __clang__
+#pragma GCC diagnostic pop
+#endif /* __clang__ */
+
+#endif /* TRACE_H */

data/ext/libcouchbase/src/utilities.c

@@ -0,0 +1,171 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010-2012 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "internal.h"
+
+/**
+ * This file contains utility functions which don't have another place
+ * to call home
+ */
+
+extern lcb_uint64_t lcb_byteswap64(lcb_uint64_t val)
+{
+    lcb_size_t ii;
+    lcb_uint64_t ret = 0;
+    for (ii = 0; ii < sizeof(lcb_uint64_t); ii++) {
+        ret <<= 8;
+        ret |= val & 0xff;
+        val >>= 8;
+    }
+    return ret;
+}
+
+/**
+ * While the C standard library uses 'putenv' for environment variable
+ * manipulation, POSIX defines setenv (which works sanely) but Windows
+ * only has putenv (via the CRT interface).
+ * However Windows also has the 'GetEnvironmentVariable' etc. API - which
+ * actually uses a different interface.
+ *
+ * We prefer to use actual API calls rather than hack into a poor excuse
+ * of conformance. Since putenv requires ownership of the string, its use
+ * is discouraged (and _putenv_s isn't available in MinGW); thus the
+ * assumption that the most common APIs are GetEnvironmentVariable and
+ * SetEnvironmentVariable. We try to abstract this away from the rest of the
+ * library.
+ */
+
+#ifdef _WIN32
+int lcb_getenv_nonempty(const char *key, char *buf, lcb_size_t len)
+{
+    DWORD nvalue = GetEnvironmentVariable(key, buf, (DWORD)len);
+
+    if (nvalue == 0 || nvalue >= len) {
+        return 0;
+    }
+
+    if (!buf[0]) {
+        return 0;
+    }
+    return 1;
+}
+
+#else
+int lcb_getenv_nonempty(const char *key, char *buf, lcb_size_t len)
+{
+    const char *cur = getenv(key);
+    if (cur == NULL || *cur == '\0') {
+        return 0;
+    }
+
+    strncpy(buf, cur, len);
+    return 1;
+}
+#endif
+
+int lcb_getenv_boolean(const char *key)
+{
+    char value[4096] = { 0 };
+    int rv;
+    rv = lcb_getenv_nonempty(key, value, sizeof(value));
+    return rv != 0 && value[0] != '\0' && value[0] != '0';
+}
+
+#ifdef _WIN32
+lcb_error_t lcb_initialize_socket_subsystem(void)
+{
+    static volatile LONG initialized = 0;
+    WSADATA wsaData;
+
+    if (InterlockedCompareExchange(&initialized, 1, 0)) {
+        return LCB_SUCCESS;
+    }
+    if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0) {
+        lcb_assert("Winsock initialization error" && 0);
+    }
+    return LCB_SUCCESS;
+}
+#else
+lcb_error_t lcb_initialize_socket_subsystem(void)
+{
+    return LCB_SUCCESS;
+}
+#endif
+
+int
+lcb_getenv_nonempty_multi(char *buf, lcb_size_t nbuf, ...)
+{
+    va_list ap;
+    const char *cur;
+    int found = 0;
+
+    va_start(ap, nbuf);
+    while ((cur = va_arg(ap, const char*))) {
+        if ((found = lcb_getenv_nonempty(cur, buf, nbuf))) {
+            break;
+        }
+    }
+    va_end(ap);
+    return found;
+}
+
+int
+lcb_getenv_boolean_multi(const char *key, ...)
+{
+    va_list ap;
+    const char *cur;
+    int ret = 0;
+
+    va_start(ap, key);
+    if (lcb_getenv_boolean(key)) {
+        va_end(ap);
+        return 1;
+    }
+
+    while ((cur = va_arg(ap, const char *))) {
+        if ((ret = lcb_getenv_boolean(cur))) {
+            break;
+        }
+    }
+    va_end(ap);
+    return ret;
+}
+
+const char *
+lcb_get_tmpdir(void)
+{
+#if defined(_WIN32)
+    static char buf[MAX_PATH+1] = { 0 };
+    if (buf[0]) {
+        return buf;
+    }
+    GetTempPath(sizeof buf, buf);
+    return buf;
+#else
+    const char *ret;
+    if ((ret = getenv("TMPDIR")) != NULL) {
+        return ret;
+    } else {
+
+    #if defined(_POSIX_VERSION)
+        return "/tmp";
+    #else
+        return ".";
+    #endif
+    }
+#endif
+}