@ohos-ports/confluentinc-kafka-javascript 1.10.0-beta.1

package/deps/librdkafka/src/rdatomic.h

@@ -0,0 +1,262 @@
+/*
+ * librdkafka - The Apache Kafka C/C++ library
+ *
+ * Copyright (c) 2014-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _RDATOMIC_H_
+#define _RDATOMIC_H_
+
+#include "tinycthread.h"
+
+typedef struct {
+        int32_t val;
+#if !defined(_WIN32) && !HAVE_ATOMICS_32
+        mtx_t lock;
+#endif
+} rd_atomic32_t;
+
+typedef struct {
+        int64_t val;
+#if !defined(_WIN32) && !HAVE_ATOMICS_64
+        mtx_t lock;
+#endif
+} rd_atomic64_t;
+
+
+static RD_INLINE RD_UNUSED void rd_atomic32_init(rd_atomic32_t *ra, int32_t v) {
+        ra->val = v;
+#if !defined(_WIN32) && !HAVE_ATOMICS_32
+        mtx_init(&ra->lock, mtx_plain);
+#endif
+}
+
+
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_add(rd_atomic32_t *ra,
+                                                   int32_t v) {
+#ifdef __SUNPRO_C
+        return atomic_add_32_nv(&ra->val, v);
+#elif defined(_WIN32)
+        return InterlockedAdd((LONG *)&ra->val, v);
+#elif !HAVE_ATOMICS_32
+        int32_t r;
+        mtx_lock(&ra->lock);
+        ra->val += v;
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP32(add, fetch, &ra->val, v);
+#endif
+}
+
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_sub(rd_atomic32_t *ra,
+                                                   int32_t v) {
+#ifdef __SUNPRO_C
+        return atomic_add_32_nv(&ra->val, -v);
+#elif defined(_WIN32)
+        return InterlockedAdd((LONG *)&ra->val, -v);
+#elif !HAVE_ATOMICS_32
+        int32_t r;
+        mtx_lock(&ra->lock);
+        ra->val -= v;
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP32(sub, fetch, &ra->val, v);
+#endif
+}
+
+/**
+ * @warning The returned value is the nominal value and will be outdated
+ *          by the time the application reads it.
+ *          It should not be used for exact arithmetics, any correlation
+ *          with other data is unsynchronized, meaning that two atomics,
+ *          or one atomic and a mutex-protected piece of data have no
+ *          common synchronization and can't be relied on.
+ */
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_get(rd_atomic32_t *ra) {
+#if defined(_WIN32) || defined(__SUNPRO_C)
+        return ra->val;
+#elif !HAVE_ATOMICS_32
+        int32_t r;
+        mtx_lock(&ra->lock);
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP32(fetch, add, &ra->val, 0);
+#endif
+}
+
+/**
+ * @brief Set the atomic value to \p v and return the previous value to
+ *        that can be used to determine if the value was changed.
+ */
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_set(rd_atomic32_t *ra,
+                                                   int32_t v) {
+#ifdef _WIN32
+        return InterlockedExchange((LONG *)&ra->val, v);
+#elif HAVE_ATOMICS_32 && HAVE_ATOMICS_32_ATOMIC
+        return __atomic_exchange_n(&ra->val, v, __ATOMIC_SEQ_CST);
+#elif HAVE_ATOMICS_32 && HAVE_ATOMICS_32_SYNC
+        return __sync_lock_test_and_set(&ra->val, v);
+#else
+        int32_t r;
+        mtx_lock(&ra->lock);
+        r       = ra->val;
+        ra->val = v;
+        mtx_unlock(&ra->lock);
+        return r;
+#endif
+}
+
+
+
+static RD_INLINE RD_UNUSED void rd_atomic64_init(rd_atomic64_t *ra, int64_t v) {
+        ra->val = v;
+#if !defined(_WIN32) && !HAVE_ATOMICS_64
+        mtx_init(&ra->lock, mtx_plain);
+#endif
+}
+
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_add(rd_atomic64_t *ra,
+                                                   int64_t v) {
+#ifdef __SUNPRO_C
+        return atomic_add_64_nv(&ra->val, v);
+#elif defined(_WIN32)
+        return InterlockedAdd64(&ra->val, v);
+#elif !HAVE_ATOMICS_64
+        int64_t r;
+        mtx_lock(&ra->lock);
+        ra->val += v;
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP64(add, fetch, &ra->val, v);
+#endif
+}
+
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_sub(rd_atomic64_t *ra,
+                                                   int64_t v) {
+#ifdef __SUNPRO_C
+        return atomic_add_64_nv(&ra->val, -v);
+#elif defined(_WIN32)
+        return InterlockedAdd64(&ra->val, -v);
+#elif !HAVE_ATOMICS_64
+        int64_t r;
+        mtx_lock(&ra->lock);
+        ra->val -= v;
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP64(sub, fetch, &ra->val, v);
+#endif
+}
+
+/**
+ * @warning The returned value is the nominal value and will be outdated
+ *          by the time the application reads it.
+ *          It should not be used for exact arithmetics, any correlation
+ *          with other data is unsynchronized, meaning that two atomics,
+ *          or one atomic and a mutex-protected piece of data have no
+ *          common synchronization and can't be relied on.
+ *          Use with care.
+ */
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_get(rd_atomic64_t *ra) {
+#if defined(_WIN32) || defined(__SUNPRO_C)
+        return InterlockedCompareExchange64(&ra->val, 0, 0);
+#elif !HAVE_ATOMICS_64
+        int64_t r;
+        mtx_lock(&ra->lock);
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP64(fetch, add, &ra->val, 0);
+#endif
+}
+
+/**
+ * @brief Set the atomic value to \p v and return the previous value to
+ *        that can be used to determine if the value was changed.
+ */
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_set(rd_atomic64_t *ra,
+                                                   int64_t v) {
+#ifdef _WIN32
+        return InterlockedExchange64(&ra->val, v);
+#elif HAVE_ATOMICS_64 && HAVE_ATOMICS_64_ATOMIC
+        return __atomic_exchange_n(&ra->val, v, __ATOMIC_SEQ_CST);
+#elif HAVE_ATOMICS_64 && HAVE_ATOMICS_64_SYNC
+        return __sync_lock_test_and_set(&ra->val, v);
+#else
+        int64_t r;
+        mtx_lock(&ra->lock);
+        r       = ra->val;
+        ra->val = v;
+        mtx_unlock(&ra->lock);
+        return r;
+#endif
+}
+
+/**
+ * @brief Atomic compare-and-swap on a 64-bit value.
+ *
+ *        If *ra == @p expected, atomically replace it with @p desired
+ *        and return 1. Otherwise leave *ra unchanged and return 0.
+ */
+static RD_INLINE int RD_UNUSED rd_atomic64_cas(rd_atomic64_t *ra,
+                                               int64_t expected,
+                                               int64_t desired) {
+#ifdef __SUNPRO_C
+        return atomic_cas_64((volatile uint64_t *)&ra->val, (uint64_t)expected,
+                             (uint64_t)desired) == (uint64_t)expected;
+#elif defined(_WIN32)
+        return InterlockedCompareExchange64((LONG64 *)&ra->val, (LONG64)desired,
+                                            (LONG64)expected) ==
+               (LONG64)expected;
+#elif HAVE_ATOMICS_64 && HAVE_ATOMICS_64_ATOMIC
+        return __atomic_compare_exchange_n(&ra->val, &expected, desired,
+                                           0 /* strong */, __ATOMIC_SEQ_CST,
+                                           __ATOMIC_SEQ_CST);
+#elif HAVE_ATOMICS_64 && HAVE_ATOMICS_64_SYNC
+        return __sync_bool_compare_and_swap(&ra->val, expected, desired);
+#else
+        int r;
+        mtx_lock(&ra->lock);
+        if (ra->val == expected) {
+                ra->val = desired;
+                r       = 1;
+        } else {
+                r = 0;
+        }
+        mtx_unlock(&ra->lock);
+        return r;
+#endif
+}
+
+#endif /* _RDATOMIC_H_ */

package/deps/librdkafka/src/rdavg.h

@@ -0,0 +1,260 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2018-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _RDAVG_H_
+#define _RDAVG_H_
+
+
+#if WITH_HDRHISTOGRAM
+#include "rdhdrhistogram.h"
+#endif
+
+typedef struct rd_avg_s {
+        struct {
+                int64_t maxv;
+                int64_t minv;
+                int64_t avg;
+                int64_t sum;
+                int cnt;
+                rd_ts_t start;
+        } ra_v;
+        mtx_t ra_lock;
+        int ra_enabled;
+        enum {
+                RD_AVG_GAUGE,
+                RD_AVG_COUNTER,
+        } ra_type;
+#if WITH_HDRHISTOGRAM
+        rd_hdr_histogram_t *ra_hdr;
+#endif
+        /* Histogram results, calculated for dst in rollover().
+         * Will be all zeroes if histograms are not supported. */
+        struct {
+                /* Quantiles */
+                int64_t p50;
+                int64_t p75;
+                int64_t p90;
+                int64_t p95;
+                int64_t p99;
+                int64_t p99_99;
+
+                int64_t oor;     /**< Values out of range */
+                int32_t hdrsize; /**< hdr.allocatedSize */
+                double stddev;
+                double mean;
+        } ra_hist;
+} rd_avg_t;
+
+
+/**
+ * @brief Add value \p v to averager \p ra.
+ */
+static RD_UNUSED void rd_avg_add(rd_avg_t *ra, int64_t v) {
+        mtx_lock(&ra->ra_lock);
+        if (!ra->ra_enabled) {
+                mtx_unlock(&ra->ra_lock);
+                return;
+        }
+        if (v > ra->ra_v.maxv)
+                ra->ra_v.maxv = v;
+        if (ra->ra_v.minv == 0 || v < ra->ra_v.minv)
+                ra->ra_v.minv = v;
+        ra->ra_v.sum += v;
+        ra->ra_v.cnt++;
+#if WITH_HDRHISTOGRAM
+        rd_hdr_histogram_record(ra->ra_hdr, v);
+#endif
+        mtx_unlock(&ra->ra_lock);
+}
+
+
+/**
+ * @brief Calculate the average
+ */
+static RD_UNUSED void rd_avg_calc(rd_avg_t *ra, rd_ts_t now) {
+        if (ra->ra_type == RD_AVG_GAUGE) {
+                if (ra->ra_v.cnt)
+                        ra->ra_v.avg = ra->ra_v.sum / ra->ra_v.cnt;
+                else
+                        ra->ra_v.avg = 0;
+        } else {
+                rd_ts_t elapsed = now - ra->ra_v.start;
+
+                if (elapsed)
+                        ra->ra_v.avg = (ra->ra_v.sum * 1000000llu) / elapsed;
+                else
+                        ra->ra_v.avg = 0;
+
+                ra->ra_v.start = elapsed;
+        }
+}
+
+
+/**
+ * @returns the quantile \q for \p ra, or 0 if histograms are not supported
+ *          in this build.
+ *
+ * @remark ra will be not locked by this function.
+ */
+static RD_UNUSED int64_t rd_avg_quantile(const rd_avg_t *ra, double q) {
+#if WITH_HDRHISTOGRAM
+        return rd_hdr_histogram_quantile(ra->ra_hdr, q);
+#else
+        return 0;
+#endif
+}
+
+/**
+ * @brief Rolls over statistics in \p src and stores the average in \p dst.
+ * \p src is cleared and ready to be reused.
+ *
+ * Caller must free avg internal members by calling rd_avg_destroy()
+ * on the \p dst.
+ */
+static RD_UNUSED void rd_avg_rollover(rd_avg_t *dst, rd_avg_t *src) {
+        rd_ts_t now;
+
+        mtx_lock(&src->ra_lock);
+        if (!src->ra_enabled) {
+                memset(dst, 0, sizeof(*dst));
+                dst->ra_type = src->ra_type;
+                mtx_unlock(&src->ra_lock);
+                return;
+        }
+
+        mtx_init(&dst->ra_lock, mtx_plain);
+        dst->ra_type = src->ra_type;
+        dst->ra_v    = src->ra_v;
+#if WITH_HDRHISTOGRAM
+        dst->ra_hdr = NULL;
+
+        dst->ra_hist.stddev  = rd_hdr_histogram_stddev(src->ra_hdr);
+        dst->ra_hist.mean    = rd_hdr_histogram_mean(src->ra_hdr);
+        dst->ra_hist.oor     = src->ra_hdr->outOfRangeCount;
+        dst->ra_hist.hdrsize = src->ra_hdr->allocatedSize;
+        dst->ra_hist.p50     = rd_hdr_histogram_quantile(src->ra_hdr, 50.0);
+        dst->ra_hist.p75     = rd_hdr_histogram_quantile(src->ra_hdr, 75.0);
+        dst->ra_hist.p90     = rd_hdr_histogram_quantile(src->ra_hdr, 90.0);
+        dst->ra_hist.p95     = rd_hdr_histogram_quantile(src->ra_hdr, 95.0);
+        dst->ra_hist.p99     = rd_hdr_histogram_quantile(src->ra_hdr, 99.0);
+        dst->ra_hist.p99_99  = rd_hdr_histogram_quantile(src->ra_hdr, 99.99);
+#else
+        memset(&dst->ra_hist, 0, sizeof(dst->ra_hist));
+#endif
+        memset(&src->ra_v, 0, sizeof(src->ra_v));
+
+        now             = rd_clock();
+        src->ra_v.start = now;
+
+#if WITH_HDRHISTOGRAM
+        /* Adapt histogram span to fit future out of range entries
+         * from this period. */
+        if (src->ra_hdr->totalCount > 0) {
+                int64_t vmin = src->ra_hdr->lowestTrackableValue;
+                int64_t vmax = src->ra_hdr->highestTrackableValue;
+                int64_t mindiff, maxdiff;
+
+                mindiff = src->ra_hdr->lowestTrackableValue -
+                          src->ra_hdr->lowestOutOfRange;
+
+                if (mindiff > 0) {
+                        /* There were low out of range values, grow lower
+                         * span to fit lowest out of range value + 20%. */
+                        vmin = src->ra_hdr->lowestOutOfRange +
+                               (int64_t)((double)mindiff * 0.2);
+                }
+
+                maxdiff = src->ra_hdr->highestOutOfRange -
+                          src->ra_hdr->highestTrackableValue;
+
+                if (maxdiff > 0) {
+                        /* There were high out of range values, grow higher
+                         * span to fit highest out of range value + 20%. */
+                        vmax = src->ra_hdr->highestOutOfRange +
+                               (int64_t)((double)maxdiff * 0.2);
+                }
+
+                if (vmin == src->ra_hdr->lowestTrackableValue &&
+                    vmax == src->ra_hdr->highestTrackableValue) {
+                        /* No change in min,max, use existing hdr */
+                        rd_hdr_histogram_reset(src->ra_hdr);
+
+                } else {
+                        int sigfigs = (int)src->ra_hdr->significantFigures;
+                        /* Create new hdr for adapted range */
+                        rd_hdr_histogram_destroy(src->ra_hdr);
+                        src->ra_hdr = rd_hdr_histogram_new(vmin, vmax, sigfigs);
+                }
+
+        } else {
+                /* No records, no need to reset. */
+        }
+#endif
+
+        mtx_unlock(&src->ra_lock);
+
+        rd_avg_calc(dst, now);
+}
+
+
+/**
+ * Initialize an averager
+ */
+static RD_UNUSED void rd_avg_init(rd_avg_t *ra,
+                                  int type,
+                                  int64_t exp_min,
+                                  int64_t exp_max,
+                                  int sigfigs,
+                                  int enable) {
+        memset(ra, 0, sizeof(*ra));
+        mtx_init(&ra->ra_lock, 0);
+        ra->ra_enabled = enable;
+        if (!enable)
+                return;
+        ra->ra_type    = type;
+        ra->ra_v.start = rd_clock();
+#if WITH_HDRHISTOGRAM
+        /* Start off the histogram with expected min,max span,
+         * we'll adapt the size on each rollover. */
+        ra->ra_hdr = rd_hdr_histogram_new(exp_min, exp_max, sigfigs);
+#endif
+}
+
+
+/**
+ * Destroy averager
+ */
+static RD_UNUSED void rd_avg_destroy(rd_avg_t *ra) {
+#if WITH_HDRHISTOGRAM
+        if (ra->ra_hdr)
+                rd_hdr_histogram_destroy(ra->ra_hdr);
+#endif
+        mtx_destroy(&ra->ra_lock);
+}
+
+#endif /* _RDAVG_H_ */