couchbase 3.1.1-universal-darwin-20 → 3.2.0-universal-darwin-20

data/ext/third_party/hdr_histogram_c/src/hdr_interval_recorder.h

@@ -0,0 +1,109 @@
+/**
+ * hdr_interval_recorder.h
+ * Written by Michael Barker and released to the public domain,
+ * as explained at http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+#ifndef HDR_INTERVAL_RECORDER_H
+#define HDR_INTERVAL_RECORDER_H 1
+
+#include "hdr_writer_reader_phaser.h"
+#include "hdr_histogram.h"
+
+HDR_ALIGN_PREFIX(8)
+struct hdr_interval_recorder
+{
+    struct hdr_histogram* active;
+    struct hdr_histogram* inactive;
+    struct hdr_writer_reader_phaser phaser;
+} 
+HDR_ALIGN_SUFFIX(8);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int hdr_interval_recorder_init(struct hdr_interval_recorder* r);
+
+int hdr_interval_recorder_init_all(
+    struct hdr_interval_recorder* r,
+    int64_t lowest_trackable_value,
+    int64_t highest_trackable_value,
+    int significant_figures);
+
+void hdr_interval_recorder_destroy(struct hdr_interval_recorder* r);
+
+int64_t hdr_interval_recorder_record_value(
+    struct hdr_interval_recorder* r,
+    int64_t value
+);
+
+int64_t hdr_interval_recorder_record_values(
+    struct hdr_interval_recorder* r,
+    int64_t value,
+    int64_t count
+);
+
+int64_t hdr_interval_recorder_record_corrected_value(
+    struct hdr_interval_recorder* r,
+    int64_t value,
+    int64_t expected_interval
+);
+
+int64_t hdr_interval_recorder_record_corrected_values(
+    struct hdr_interval_recorder* r,
+    int64_t value,
+    int64_t count,
+    int64_t expected_interval
+);
+
+int64_t hdr_interval_recorder_record_value_atomic(
+    struct hdr_interval_recorder* r,
+    int64_t value
+);
+
+int64_t hdr_interval_recorder_record_values_atomic(
+    struct hdr_interval_recorder* r,
+    int64_t value,
+    int64_t count
+);
+
+int64_t hdr_interval_recorder_record_corrected_value_atomic(
+    struct hdr_interval_recorder* r,
+    int64_t value,
+    int64_t expected_interval
+);
+
+int64_t hdr_interval_recorder_record_corrected_values_atomic(
+    struct hdr_interval_recorder* r,
+    int64_t value,
+    int64_t count,
+    int64_t expected_interval
+);
+
+/**
+ * The is generally the preferred approach for recylcing histograms through
+ * the recorder as it is safe when used from callers in multiple threads and
+ * the returned histogram won't automatically become active without being
+ * passed back into this method.
+ *
+ * @param r 'this' recorder
+ * @param histogram_to_recycle
+ * @return the histogram that was previous being recorded to.
+ */
+struct hdr_histogram* hdr_interval_recorder_sample_and_recycle(
+    struct hdr_interval_recorder* r,
+    struct hdr_histogram* histogram_to_recycle);
+
+/**
+ * @deprecated Prefer hdr_interval_recorder_sample_and_recycle
+ * @param r 'this' recorder
+ * @return the histogram that was previous being recorded to.
+ */
+struct hdr_histogram* hdr_interval_recorder_sample(struct hdr_interval_recorder* r);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/third_party/hdr_histogram_c/src/hdr_malloc.h

@@ -0,0 +1,19 @@
+/**
+ * hdr_malloc.h
+ * Written by Filipe Oliveira and released to the public domain,
+ * as explained at http://creativecommons.org/publicdomain/zero/1.0/
+ *
+ * Allocator selection.
+ *
+ * This file is used in order to change the HdrHistogram allocator at compile time.
+ * Just define the following defines to what you want to use. Also add
+ * the include of your alternate allocator if needed (not needed in order
+ * to use the default libc allocator). */
+
+#ifndef HDR_MALLOC_H__
+#define HDR_MALLOC_H__
+#define hdr_malloc malloc
+#define hdr_calloc calloc
+#define hdr_realloc realloc
+#define hdr_free free
+#endif

data/ext/third_party/hdr_histogram_c/src/hdr_tests.h

@@ -0,0 +1,22 @@
+#ifndef HDR_TESTS_H
+#define HDR_TESTS_H
+
+/* These are functions used in tests and are not intended for normal usage. */
+
+#include "hdr_histogram.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t counts_index_for(const struct hdr_histogram* h, int64_t value);
+int hdr_encode_compressed(struct hdr_histogram* h, uint8_t** compressed_histogram, size_t* compressed_len);
+int hdr_decode_compressed(uint8_t* buffer, size_t length, struct hdr_histogram** histogram);
+void hdr_base64_decode_block(const char* input, uint8_t* output);
+void hdr_base64_encode_block(const uint8_t* input, char* output);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/third_party/hdr_histogram_c/src/hdr_thread.c

@@ -0,0 +1,108 @@
+/**
+* hdr_thread.c
+* Written by Philip Orwig and released to the public domain,
+* as explained at http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#include <stdlib.h>
+#include "hdr_thread.h"
+
+#ifndef HDR_MALLOC_INCLUDE
+#define HDR_MALLOC_INCLUDE "hdr_malloc.h"
+#endif
+
+#include HDR_MALLOC_INCLUDE
+
+struct hdr_mutex* hdr_mutex_alloc(void)
+{
+    return hdr_malloc(sizeof(hdr_mutex));
+}
+
+void hdr_mutex_free(struct hdr_mutex* mutex)
+{
+    hdr_free(mutex);
+}
+
+#if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__)
+
+#if !defined(WIN32_LEAN_AND_MEAN)
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+#include <WinSock2.h>
+
+int hdr_mutex_init(struct hdr_mutex* mutex)
+{
+    InitializeCriticalSection((CRITICAL_SECTION*)(mutex->_critical_section));
+    return 0;
+}
+
+void hdr_mutex_destroy(struct hdr_mutex* mutex)
+{
+    DeleteCriticalSection((CRITICAL_SECTION*)(mutex->_critical_section));
+}
+
+void hdr_mutex_lock(struct hdr_mutex* mutex)
+{
+    EnterCriticalSection((CRITICAL_SECTION*)(mutex->_critical_section));
+}
+
+void hdr_mutex_unlock(struct hdr_mutex* mutex)
+{
+    LeaveCriticalSection((CRITICAL_SECTION*)(mutex->_critical_section));
+}
+
+void hdr_yield()
+{
+    Sleep(0);
+}
+
+int hdr_usleep(unsigned int useconds)
+{
+    struct timeval tv;
+
+    tv.tv_sec = (long)useconds / 1000000;
+    tv.tv_usec = useconds % 1000000;
+    select(0, NULL, NULL, NULL, &tv);
+
+    return 0;
+}
+
+
+#else
+#include <pthread.h>
+#include <unistd.h>
+
+int hdr_mutex_init(struct hdr_mutex* mutex)
+{
+    return pthread_mutex_init(&mutex->_mutex, NULL);
+}
+
+void hdr_mutex_destroy(struct hdr_mutex* mutex)
+{
+    pthread_mutex_destroy(&mutex->_mutex);
+}
+
+void hdr_mutex_lock(struct hdr_mutex* mutex)
+{
+    pthread_mutex_lock(&mutex->_mutex);
+}
+
+void hdr_mutex_unlock(struct hdr_mutex* mutex)
+{
+    pthread_mutex_unlock(&mutex->_mutex);
+}
+
+void hdr_yield()
+{
+    sched_yield();
+}
+
+int hdr_usleep(unsigned int useconds)
+{
+    return usleep(useconds);
+}
+
+
+#endif

data/ext/third_party/hdr_histogram_c/src/hdr_thread.h

@@ -0,0 +1,55 @@
+/**
+ * hdr_thread.h
+ * Written by Philip Orwig and released to the public domain,
+ * as explained at http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+#ifndef HDR_THREAD_H__
+#define HDR_THREAD_H__
+
+#include <stdint.h>
+
+#if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__)
+
+
+#define HDR_ALIGN_PREFIX(alignment) __declspec( align(alignment) )
+#define HDR_ALIGN_SUFFIX(alignment) 
+
+typedef struct hdr_mutex
+{
+    uint8_t _critical_section[40];
+} hdr_mutex;
+
+#else
+
+#include <pthread.h>
+
+#define HDR_ALIGN_PREFIX(alignment) 
+#define HDR_ALIGN_SUFFIX(alignment) __attribute__((aligned(alignment)))
+
+typedef struct hdr_mutex
+{
+    pthread_mutex_t _mutex;
+} hdr_mutex;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct hdr_mutex* hdr_mutex_alloc(void);
+void hdr_mutex_free(struct hdr_mutex*);
+
+int hdr_mutex_init(struct hdr_mutex* mutex);
+void hdr_mutex_destroy(struct hdr_mutex* mutex);
+
+void hdr_mutex_lock(struct hdr_mutex* mutex);
+void hdr_mutex_unlock(struct hdr_mutex* mutex);
+
+void hdr_yield(void);
+int hdr_usleep(unsigned int useconds);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/third_party/hdr_histogram_c/src/hdr_time.c

@@ -0,0 +1,98 @@
+/**
+* hdr_time.h
+* Written by Michael Barker and Philip Orwig and released to the public domain,
+* as explained at http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#include "hdr_time.h"
+
+#if defined(_WIN32) || defined(_WIN64)
+
+#if !defined(WIN32_LEAN_AND_MEAN)
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+
+static int s_clockPeriodSet = 0;
+static double s_clockPeriod = 1.0;
+
+void hdr_gettime(hdr_timespec* t)
+{
+    LARGE_INTEGER num;
+    /* if this is distasteful, we can add in an hdr_time_init() */
+    if (!s_clockPeriodSet)
+    {
+        QueryPerformanceFrequency(&num);
+        s_clockPeriod = 1.0 / (double) num.QuadPart;
+        s_clockPeriodSet = 1;
+    }
+
+    QueryPerformanceCounter(&num);
+    double seconds = num.QuadPart * s_clockPeriod;
+    double integral;
+    double remainder = modf(seconds, &integral);
+
+    t->tv_sec  = (long) integral;
+    t->tv_nsec = (long) (remainder * 1000000000);
+}
+
+#elif defined(__APPLE__)
+
+#include <mach/clock.h>
+#include <mach/mach.h>
+
+
+void hdr_gettime(hdr_timespec* ts)
+{
+    clock_serv_t cclock;
+    mach_timespec_t mts;
+    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
+    clock_get_time(cclock, &mts);
+    mach_port_deallocate(mach_task_self(), cclock);
+    ts->tv_sec = mts.tv_sec;
+    ts->tv_nsec = mts.tv_nsec;
+}
+
+
+void hdr_getnow(hdr_timespec* ts)
+{
+    hdr_gettime(ts);
+}
+
+#elif defined(__linux__) || defined(__CYGWIN__) || defined(__OpenBSD__)
+
+
+void hdr_gettime(hdr_timespec* t)
+{
+    clock_gettime(CLOCK_MONOTONIC, (struct timespec*)t);
+}
+
+void hdr_getnow(hdr_timespec* t)
+{
+    clock_gettime(CLOCK_REALTIME, (struct timespec*)t);
+}
+
+#else
+
+#warning "Platform not supported\n"
+
+#endif
+
+double hdr_timespec_as_double(const hdr_timespec* t)
+{
+    double d = t->tv_sec;
+    return d + (t->tv_nsec / 1000000000.0);
+}
+
+void hdr_timespec_from_double(hdr_timespec* t, double value)
+{
+    int seconds = (int) value;
+    int milliseconds = (int) round((value - seconds) * 1000);
+
+    t->tv_sec = seconds;
+    t->tv_nsec = milliseconds * 1000000;
+}
+
+
+

data/ext/third_party/hdr_histogram_c/src/hdr_time.h

@@ -0,0 +1,49 @@
+/**
+ * hdr_time.h
+ * Written by Michael Barker and released to the public domain,
+ * as explained at http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+#ifndef HDR_TIME_H__
+#define HDR_TIME_H__
+
+#include <math.h>
+#include <time.h>
+
+#if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__)
+
+typedef struct hdr_timespec
+{
+    long tv_sec;
+    long tv_nsec;
+} hdr_timespec;
+
+#else
+
+typedef struct timespec hdr_timespec;
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_MSC_VER)
+void hdr_gettime(hdr_timespec* t);
+#else
+void hdr_gettime(hdr_timespec* t);
+#endif
+
+void hdr_getnow(hdr_timespec* t);
+
+double hdr_timespec_as_double(const hdr_timespec* t);
+
+/* Assumes only millisecond accuracy. */
+void hdr_timespec_from_double(hdr_timespec* t, double value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+