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

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

@@ -0,0 +1,236 @@
+/**
+ * hdr_histogram_log.h
+ * Written by Michael Barker and released to the public domain,
+ * as explained at http://creativecommons.org/publicdomain/zero/1.0/
+ *
+ * The implementation makes use of zlib to provide compression.  You will need
+ * to link against -lz in order to link applications that include this header.
+ */
+
+#ifndef HDR_HISTOGRAM_H_LOG
+#define HDR_HISTOGRAM_H_LOG 1
+
+#define HDR_COMPRESSION_COOKIE_MISMATCH -29999
+#define HDR_ENCODING_COOKIE_MISMATCH -29998
+#define HDR_DEFLATE_INIT_FAIL -29997
+#define HDR_DEFLATE_FAIL -29996
+#define HDR_INFLATE_INIT_FAIL -29995
+#define HDR_INFLATE_FAIL -29994
+#define HDR_LOG_INVALID_VERSION -29993
+#define HDR_TRAILING_ZEROS_INVALID -29992
+#define HDR_VALUE_TRUNCATED -29991
+#define HDR_ENCODED_INPUT_TOO_LONG -29990
+
+#define HDR_LOG_TAG_MAX_BUFFER_LEN (1024)
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+#include "hdr_time.h"
+#include "hdr_histogram.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Encode and compress the histogram with gzip.
+ */
+int hdr_log_encode(struct hdr_histogram* histogram, char** encoded_histogram);
+
+/**
+ * Decode and decompress the histogram with gzip.
+ */
+int hdr_log_decode(struct hdr_histogram** histogram, char* base64_histogram, size_t base64_len);
+
+struct hdr_log_entry
+{
+    hdr_timespec start_timestamp;
+    hdr_timespec interval;
+    hdr_timespec max;
+    char *tag;
+    size_t tag_len;
+};
+
+struct hdr_log_writer
+{
+    uint32_t nonce;
+};
+
+/**
+ * Initialise the log writer.
+ *
+ * @param writer 'This' pointer
+ * @return 0 on success.
+ */
+int hdr_log_writer_init(struct hdr_log_writer* writer);
+
+/**
+ * Write the header to the log, this will constist of a user defined string,
+ * the current timestamp, version information and the CSV header.
+ *
+ * @param writer 'This' pointer
+ * @param file The stream to output the log header to.
+ * @param user_prefix User defined string to include in the header.
+ * @param timestamp The start time that the histogram started recording from.
+ * @return Will return 0 if it successfully completed or an error number if there
+ * was a failure.  EIO if the write failed.
+ */
+int hdr_log_write_header(
+    struct hdr_log_writer* writer,
+    FILE* file,
+    const char* user_prefix,
+    hdr_timespec* timestamp);
+
+/**
+ * Write an hdr_histogram entry to the log.  It will be encoded in a similar
+ * fashion to the approach used by the Java version of the HdrHistogram.  It will
+ * be a CSV line consisting of <start timestamp>,<end timestamp>,<max>,<histogram>
+ * where <histogram> is the binary histogram gzip compressed and base64 encoded.
+ *
+ * Timestamp is a bit of misnomer for the start_timestamp and end_timestamp values
+ * these could be offsets, e.g. start_timestamp could be offset from process start
+ * time and end_timestamp could actually be the length of the recorded interval.
+ *
+ * @param writer 'This' pointer
+ * @param file The stream to write the entry to.
+ * @param start_timestamp The start timestamp to include in the logged entry.
+ * @param end_timestamp The end timestamp to include in the logged entry.
+ * @param histogram The histogram to encode and log.
+ * @return Will return 0 if it successfully completed or an error number if there
+ * was a failure.  Errors include HDR_DEFLATE_INIT_FAIL, HDR_DEFLATE_FAIL if
+ * something when wrong during gzip compression.  ENOMEM if we failed to allocate
+ * or reallocate the buffer used for encoding (out of memory problem).  EIO if
+ * write failed.
+ */
+int hdr_log_write(
+    struct hdr_log_writer* writer,
+    FILE* file,
+    const hdr_timespec* start_timestamp,
+    const hdr_timespec* end_timestamp,
+    struct hdr_histogram* histogram);
+
+/**
+ * Write an hdr_histogram entry to the log.  It will be encoded in a similar
+ * fashion to the approach used by the Java version of the HdrHistogram.  It will
+ * be a CSV line consisting of [Tag=XXX,]<start timestamp>,<end timestamp>,<max>,<histogram>
+ * where <histogram> is the binary histogram gzip compressed and base64 encoded.
+ *
+ * The tag is option and will only be written if the tag is non-NULL and the tag_len is
+ * greater than 0.
+ *
+ * Timestamp is a bit of misnomer for the start_timestamp and end_timestamp values
+ * these could be offsets, e.g. start_timestamp could be offset from process start
+ * time and end_timestamp could actually be the length of the recorded interval.
+ *
+ * @param writer 'This' pointer
+ * @param file The stream to write the entry to.
+ * @param entry Prefix information for the log line, including timestamps and tag.
+ * @param histogram The histogram to encode and log.
+ * @return Will return 0 if it successfully completed or an error number if there
+ * was a failure.  Errors include HDR_DEFLATE_INIT_FAIL, HDR_DEFLATE_FAIL if
+ * something when wrong during gzip compression.  ENOMEM if we failed to allocate
+ * or reallocate the buffer used for encoding (out of memory problem).  EIO if
+ * write failed.
+ */
+int hdr_log_write_entry(
+    struct hdr_log_writer* writer,
+    FILE* file,
+    struct hdr_log_entry* entry,
+    struct hdr_histogram* histogram);
+
+struct hdr_log_reader
+{
+    int major_version;
+    int minor_version;
+    hdr_timespec start_timestamp;
+};
+
+/**
+ * Initialise the log reader.
+ *
+ * @param reader 'This' pointer
+ * @return 0 on success
+ */
+int hdr_log_reader_init(struct hdr_log_reader* reader);
+
+/**
+ * Reads the the header information from the log.  Will capure information
+ * such as version number and start timestamp from the header.
+ *
+ * @param hdr_log_reader 'This' pointer
+ * @param file The data stream to read from.
+ * @return 0 on success.  An error number on failure.
+ */
+int hdr_log_read_header(struct hdr_log_reader* reader, FILE* file);
+
+/**
+ * Reads an entry from the log filling in the specified histogram, timestamp and
+ * interval values.  If the supplied pointer to the histogram for this method is
+ * NULL then a new histogram will be allocated for the caller, however it will
+ * become the callers responsibility to free it later.  If the pointer is non-null
+ * the histogram read from the log will be merged with the supplied histogram.
+ *
+ * @param reader 'This' pointer
+ * @param file The stream to read the histogram from.
+ * @param histogram Pointer to allocate a histogram to or merge into.
+ * @param timestamp The first timestamp from the CSV entry.
+ * @param interval The second timestamp from the CSV entry
+ * @return Will return 0 on success or an error number if there was some wrong
+ * when reading in the histogram.  EOF (-1) will indicate that there are no more
+ * histograms left to be read from 'file'.
+ * HDR_INFLATE_INIT_FAIL or HDR_INFLATE_FAIL if
+ * there was a problem with Gzip.  HDR_COMPRESSION_COOKIE_MISMATCH or
+ * HDR_ENCODING_COOKIE_MISMATCH if the cookie values are incorrect.
+ * HDR_LOG_INVALID_VERSION if the log can not be parsed.  ENOMEM if buffer space
+ * or the histogram can not be allocated.  EIO if there was an error during
+ * the read.  EINVAL in any input values are incorrect.
+ */
+int hdr_log_read(
+    struct hdr_log_reader* reader, FILE* file, struct hdr_histogram** histogram,
+    hdr_timespec* timestamp, hdr_timespec* interval);
+
+/**
+ * Reads an entry from the log filling in the specified histogram and log entry struct.
+ * If the supplied pointer to the histogram for this method is
+ * NULL then a new histogram will be allocated for the caller, however it will
+ * become the callers responsibility to free it later.  If the pointer is non-null
+ * the histogram read from the log will be merged with the supplied histogram.
+ * The entry struct contains a pointer to a buffer to load the tag into.  If this
+ * is NULL or the tag_len is 0 then it won't store the tag there.  The tag value will be
+ * NULL-terminated if there available space in the supplied buffer.  If the tag is larger
+ * than the supplied buffer then it will be truncated.  If the caller sets the last element
+ * in the buffer to '\0' before calling this function and it is not '\0' after the function
+ * returns then the value has been truncated.
+ *
+ * @param reader 'This' pointer
+ * @param file The stream to read the histogram from.
+ * @param entry Contains all of the information from the log line that is not the histogram.
+ * @param histogram Pointer to allocate a histogram to or merge into.
+ * @return Will return 0 on success or an error number if there was some wrong
+ * when reading in the histogram.  EOF (-1) will indicate that there are no more
+ * histograms left to be read from 'file'.
+ * HDR_INFLATE_INIT_FAIL or HDR_INFLATE_FAIL if
+ * there was a problem with Gzip.  HDR_COMPRESSION_COOKIE_MISMATCH or
+ * HDR_ENCODING_COOKIE_MISMATCH if the cookie values are incorrect.
+ * HDR_LOG_INVALID_VERSION if the log can not be parsed.  ENOMEM if buffer space
+ * or the histogram can not be allocated.  EIO if there was an error during
+ * the read.  EINVAL in any input values are incorrect.
+ */
+int hdr_log_read_entry(
+    struct hdr_log_reader* reader, FILE* file, struct hdr_log_entry *entry, struct hdr_histogram** histogram);
+
+/**
+ * Returns a string representation of the error number.
+ *
+ * @param errnum The error response from a previous call.
+ * @return The user readable representation of the error.
+ */
+const char* hdr_strerror(int errnum);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,171 @@
+/**
+ * hdr_histogram_log.c
+ * Written by Michael Barker and released to the public domain,
+ * as explained at http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "hdr_histogram.h"
+#include "hdr_histogram_log.h"
+#include "hdr_tests.h"
+
+#define UNUSED(x) (void)(x)
+
+const char* hdr_strerror(int errnum)
+{
+    switch (errnum)
+    {
+        case HDR_COMPRESSION_COOKIE_MISMATCH:
+            return "Compression cookie mismatch";
+        case HDR_ENCODING_COOKIE_MISMATCH:
+            return "Encoding cookie mismatch";
+        case HDR_DEFLATE_INIT_FAIL:
+            return "Deflate initialisation failed";
+        case HDR_DEFLATE_FAIL:
+            return "Deflate failed";
+        case HDR_INFLATE_INIT_FAIL:
+            return "Inflate initialisation failed";
+        case HDR_INFLATE_FAIL:
+            return "Inflate failed";
+        case HDR_LOG_INVALID_VERSION:
+            return "Log - invalid version in log header";
+        case HDR_TRAILING_ZEROS_INVALID:
+            return "Invalid number of trailing zeros";
+        case HDR_VALUE_TRUNCATED:
+            return "Truncated value found when decoding";
+        case HDR_ENCODED_INPUT_TOO_LONG:
+            return "The encoded input exceeds the size of the histogram";
+        default:
+            return strerror(errnum);
+    }
+}
+
+int hdr_encode_compressed(
+    struct hdr_histogram* h,
+    uint8_t** compressed_histogram,
+    size_t* compressed_len)
+{
+    UNUSED(h);
+    UNUSED(compressed_histogram);
+    UNUSED(compressed_len);
+
+    return -1;
+}
+
+int hdr_decode_compressed(
+    uint8_t* buffer, size_t length, struct hdr_histogram** histogram)
+{
+    UNUSED(buffer);
+    UNUSED(length);
+    UNUSED(histogram);
+
+    return -1;
+}
+
+int hdr_log_writer_init(struct hdr_log_writer* writer)
+{
+    UNUSED(writer);
+
+    return -1;
+}
+
+int hdr_log_write_header(
+    struct hdr_log_writer* writer, FILE* file,
+    const char* user_prefix, hdr_timespec* timestamp)
+{
+    UNUSED(writer);
+    UNUSED(file);
+    UNUSED(user_prefix);
+    UNUSED(timestamp);
+
+    return -1;
+}
+
+int hdr_log_write(
+    struct hdr_log_writer* writer,
+    FILE* file,
+    const hdr_timespec* start_timestamp,
+    const hdr_timespec* end_timestamp,
+    struct hdr_histogram* histogram)
+{
+    UNUSED(writer);
+    UNUSED(file);
+    UNUSED(start_timestamp);
+    UNUSED(end_timestamp);
+    UNUSED(histogram);
+
+    return -1;
+}
+
+int hdr_log_write_entry(
+    struct hdr_log_writer* writer,
+    FILE* file,
+    struct hdr_log_entry* entry,
+    struct hdr_histogram* histogram)
+{
+    UNUSED(writer);
+    UNUSED(file);
+    UNUSED(entry);
+    UNUSED(histogram);
+
+    return -1;
+}
+
+int hdr_log_reader_init(struct hdr_log_reader* reader)
+{
+    UNUSED(reader);
+
+    return -1;
+}
+
+int hdr_log_read_header(struct hdr_log_reader* reader, FILE* file)
+{
+    UNUSED(reader);
+    UNUSED(file);
+
+    return -1;
+}
+
+int hdr_log_read(
+    struct hdr_log_reader* reader, FILE* file, struct hdr_histogram** histogram,
+    hdr_timespec* timestamp, hdr_timespec* interval)
+{
+    UNUSED(reader);
+    UNUSED(file);
+    UNUSED(histogram);
+    UNUSED(timestamp);
+    UNUSED(interval);
+
+    return -1;
+}
+
+int hdr_log_read_entry(
+    struct hdr_log_reader* reader, FILE* file, struct hdr_log_entry *entry, struct hdr_histogram** histogram)
+{
+    UNUSED(reader);
+    UNUSED(file);
+    UNUSED(entry);
+    UNUSED(histogram);
+
+    return -1;
+}
+
+int hdr_log_encode(struct hdr_histogram* histogram, char** encoded_histogram)
+{
+    UNUSED(histogram);
+    UNUSED(encoded_histogram);
+
+    return -1;
+}
+
+int hdr_log_decode(struct hdr_histogram** histogram, char* base64_histogram, size_t base64_len)
+{
+    UNUSED(histogram);
+    UNUSED(base64_histogram);
+    UNUSED(base64_len);
+
+    return -1;
+}

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

@@ -0,0 +1,227 @@
+/**
+ * hdr_interval_recorder.h
+ * Written by Michael Barker and released to the public domain,
+ * as explained at http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+#include "hdr_atomic.h"
+#include "hdr_interval_recorder.h"
+
+#ifndef HDR_MALLOC_INCLUDE
+#define HDR_MALLOC_INCLUDE "hdr_malloc.h"
+#endif
+
+#include HDR_MALLOC_INCLUDE
+
+int hdr_interval_recorder_init(struct hdr_interval_recorder* r)
+{
+    r->active = r->inactive = NULL;
+    return hdr_writer_reader_phaser_init(&r->phaser);
+}
+
+int hdr_interval_recorder_init_all(
+    struct hdr_interval_recorder* r,
+    int64_t lowest_discernible_value,
+    int64_t highest_trackable_value,
+    int significant_figures)
+{
+    int result;
+
+    r->active = r->inactive = NULL;
+    result = hdr_writer_reader_phaser_init(&r->phaser);
+    result = result == 0
+        ? hdr_init(lowest_discernible_value, highest_trackable_value, significant_figures, &r->active)
+        : result;
+
+    return result;
+}
+
+void hdr_interval_recorder_destroy(struct hdr_interval_recorder* r)
+{
+    hdr_writer_reader_phaser_destroy(&r->phaser);
+    if (r->active) {
+        hdr_close(r->active);
+    }
+    if (r->inactive) {
+        hdr_close(r->inactive);
+    }
+}
+
+struct hdr_histogram* hdr_interval_recorder_sample_and_recycle(
+    struct hdr_interval_recorder* r,
+    struct hdr_histogram* histogram_to_recycle)
+{
+    struct hdr_histogram* old_active;
+
+    if (NULL == histogram_to_recycle)
+    {
+        int64_t lo = r->active->lowest_discernible_value;
+        int64_t hi = r->active->highest_trackable_value;
+        int significant_figures = r->active->significant_figures;
+        hdr_init(lo, hi, significant_figures, &histogram_to_recycle);
+    }
+    else
+    {
+        hdr_reset(histogram_to_recycle);
+    }
+
+    hdr_phaser_reader_lock(&r->phaser);
+
+    /* volatile read */
+    old_active = hdr_atomic_load_pointer(&r->active);
+
+    /* volatile write */
+    hdr_atomic_store_pointer(&r->active, histogram_to_recycle);
+
+    hdr_phaser_flip_phase(&r->phaser, 0);
+
+    hdr_phaser_reader_unlock(&r->phaser);
+
+    return old_active;
+}
+
+struct hdr_histogram* hdr_interval_recorder_sample(struct hdr_interval_recorder* r)
+{
+    r->inactive = hdr_interval_recorder_sample_and_recycle(r, r->inactive);
+    return r->inactive;
+}
+
+static void hdr_interval_recorder_update(
+    struct hdr_interval_recorder* r,
+    void(*update_action)(struct hdr_histogram*, void*),
+    void* arg)
+{
+    int64_t val = hdr_phaser_writer_enter(&r->phaser);
+
+    void* active = hdr_atomic_load_pointer(&r->active);
+
+    update_action(active, arg);
+
+    hdr_phaser_writer_exit(&r->phaser, val);
+}
+
+static void update_values(struct hdr_histogram* data, void* arg)
+{
+    struct hdr_histogram* h = data;
+    int64_t* params = arg;
+    params[2] = hdr_record_values(h, params[0], params[1]);
+}
+
+static void update_values_atomic(struct hdr_histogram* data, void* arg)
+{
+    struct hdr_histogram* h = data;
+    int64_t* params = arg;
+    params[2] = hdr_record_values_atomic(h, params[0], params[1]);
+}
+
+int64_t hdr_interval_recorder_record_values(
+    struct hdr_interval_recorder* r,
+    int64_t value,
+    int64_t count
+)
+{
+    int64_t params[3];
+    params[0] = value;
+    params[1] = count;
+    params[2] = 0;
+
+    hdr_interval_recorder_update(r, update_values, &params[0]);
+    return params[2];
+}
+
+int64_t hdr_interval_recorder_record_value(
+    struct hdr_interval_recorder* r,
+    int64_t value
+)
+{
+    return hdr_interval_recorder_record_values(r, value, 1);
+}
+
+static void update_corrected_values(struct hdr_histogram* data, void* arg)
+{
+    struct hdr_histogram* h = data;
+    int64_t* params = arg;
+    params[3] = hdr_record_corrected_values(h, params[0], params[1], params[2]);
+}
+
+static void update_corrected_values_atomic(struct hdr_histogram* data, void* arg)
+{
+    struct hdr_histogram* h = data;
+    int64_t* params = arg;
+    params[3] = hdr_record_corrected_values_atomic(h, params[0], params[1], params[2]);
+}
+
+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 params[4];
+    params[0] = value;
+    params[1] = count;
+    params[2] = expected_interval;
+    params[3] = 0;
+
+    hdr_interval_recorder_update(r, update_corrected_values, &params[0]);
+    return params[3];
+}
+
+int64_t hdr_interval_recorder_record_corrected_value(
+    struct hdr_interval_recorder* r,
+    int64_t value,
+    int64_t expected_interval
+)
+{
+    return hdr_interval_recorder_record_corrected_values(r, value, 1, expected_interval);
+}
+
+int64_t hdr_interval_recorder_record_value_atomic(
+    struct hdr_interval_recorder* r,
+    int64_t value
+)
+{
+    return hdr_interval_recorder_record_values_atomic(r, value, 1);
+}
+
+int64_t hdr_interval_recorder_record_values_atomic(
+    struct hdr_interval_recorder* r,
+    int64_t value,
+    int64_t count
+)
+{
+    int64_t params[3];
+    params[0] = value;
+    params[1] = count;
+    params[2] = 0;
+
+    hdr_interval_recorder_update(r, update_values_atomic, &params[0]);
+    return params[2];
+}
+
+int64_t hdr_interval_recorder_record_corrected_value_atomic(
+    struct hdr_interval_recorder* r,
+    int64_t value,
+    int64_t expected_interval
+)
+{
+    return hdr_interval_recorder_record_corrected_values_atomic(r, value, 1, 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
+)
+{
+    int64_t params[4];
+    params[0] = value;
+    params[1] = count;
+    params[2] = expected_interval;
+    params[3] = 0;
+
+    hdr_interval_recorder_update(r, update_corrected_values_atomic, &params[0]);
+    return params[3];
+}