N-API Support (#36)

* Initial commit

* _Bool for Windows

* _Bool for Windows, pt 2

* Windows link error

* Update documentation

* Add N-API v3 badge to README

* Clarify licensing

* Update appveyor.yml to use Node.js 14.2.0

Author: jschlight

.gitignore

@@ -21,7 +21,7 @@ coverage
 .lock-wscript
 
 # Compiled binary addons (http://nodejs.org/api/addons.html)
-build/Release
+build-tmp-napi-v3/
 
 # Dependency directory
 node_modules
@@ -42,3 +42,4 @@ lib/binding
 
 yarn.lock
 package-lock.json
+.nyc_output

.travis.yml

@@ -7,18 +7,18 @@ branches:
   - /^v[0-9]/
 matrix:
   include:
+  - os: linux
+    env: NODE_VERSION="14"
   - os: linux
     env: NODE_VERSION="12"
   - os: linux
     env: NODE_VERSION="10"
-  - os: linux
-    env: NODE_VERSION="8"
+  - os: osx
+    env: NODE_VERSION="14"
   - os: osx
     env: NODE_VERSION="12"
   - os: osx
     env: NODE_VERSION="10"
-  - os: osx
-    env: NODE_VERSION="8"
 env:
   global:
   - JOBS: '8'

HdrHistogram_c/src/CMakeLists.txt

@@ -0,0 +1,33 @@
+FILE(GLOB histogram_files "*.c")
+FILE(GLOB HEADER "*.h")
+
+option(HDR_HISTOGRAM_BUILD_STATIC "Build static library" ON)
+option(HDR_HISTOGRAM_BUILD_SHARED "Build shared library" ON)
+
+if (HDR_HISTOGRAM_BUILD_SHARED)
+    add_library(hdr_histogram SHARED ${histogram_files} ${HEADER})
+    if (WIN32)
+        set_target_properties(hdr_histogram PROPERTIES VERSION ${HDR_VERSION})
+        target_link_libraries(hdr_histogram ws2_32)
+    else ()
+        target_link_libraries(hdr_histogram m)
+        set_target_properties(hdr_histogram PROPERTIES VERSION ${HDR_VERSION} SOVERSION ${HDR_SOVERSION})
+    endif ()
+    target_link_libraries(hdr_histogram ${ZLIB_LIBRARIES})
+    target_include_directories(hdr_histogram SYSTEM PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${ZLIB_INCLUDE_DIRS})
+    install(TARGETS hdr_histogram DESTINATION lib${LIB_SUFFIX})
+endif (HDR_HISTOGRAM_BUILD_SHARED)
+
+if (HDR_HISTOGRAM_BUILD_STATIC)
+    add_library(hdr_histogram_static STATIC ${histogram_files} ${HEADER})
+    if (WIN32)
+        target_link_libraries(hdr_histogram_static ws2_32)
+    else ()
+        target_link_libraries(hdr_histogram_static m)
+    endif ()
+    target_link_libraries(hdr_histogram_static ${ZLIB_LIBRARIES})
+    target_include_directories(hdr_histogram_static SYSTEM PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${ZLIB_INCLUDE_DIRS})
+    install(TARGETS hdr_histogram_static DESTINATION lib${LIB_SUFFIX})
+endif (HDR_HISTOGRAM_BUILD_STATIC)
+
+install(FILES hdr_histogram.h hdr_histogram_log.h hdr_time.h hdr_writer_reader_phaser.h hdr_interval_recorder.h hdr_thread.h DESTINATION include/hdr)

src/hdr_atomic.h HdrHistogram_c/src/hdr_atomic.hsrc/hdr_atomic.h renamed to HdrHistogram_c/src/hdr_atomic.h

@@ -12,6 +12,7 @@
 
 #include <stdint.h>
 #include <intrin.h>
+#include <stdbool.h>
 
 static void __inline * hdr_atomic_load_pointer(void** pointer)
 {
@@ -37,14 +38,45 @@ static void __inline hdr_atomic_store_64(int64_t* field, int64_t value)
 	*field = value;
 }
 
-static int64_t __inline hdr_atomic_exchange_64(volatile int64_t* field, int64_t initial)
+static int64_t __inline hdr_atomic_exchange_64(volatile int64_t* field, int64_t value)
 {
-	return _InterlockedExchange64(field, initial);
+#if defined(_WIN64)
+    return _InterlockedExchange64(field, value);
+#else
+    int64_t comparand;
+    int64_t initial_value = *field;
+    do
+    {
+        comparand = initial_value;
+        initial_value = _InterlockedCompareExchange64(field, value, comparand);
+    }
+    while (comparand != initial_value);
+
+    return initial_value;
+#endif
 }
 
 static int64_t __inline hdr_atomic_add_fetch_64(volatile int64_t* field, int64_t value)
 {
+#if defined(_WIN64)
 	return _InterlockedExchangeAdd64(field, value) + value;
+#else
+    int64_t comparand;
+    int64_t initial_value = *field;
+    do
+    {
+        comparand = initial_value;
+        initial_value = _InterlockedCompareExchange64(field, comparand + value, comparand);
+    }
+    while (comparand != initial_value);
+
+    return initial_value + value;
+#endif
+}
+
+static bool __inline hdr_atomic_compare_exchange_64(volatile int64_t* field, int64_t* expected, int64_t desired)
+{
+    return *expected == _InterlockedCompareExchange64(field, desired, *expected);
 }
 
 #elif defined(__ATOMIC_SEQ_CST)
@@ -55,10 +87,12 @@ static int64_t __inline hdr_atomic_add_fetch_64(volatile int64_t* field, int64_t
 #define hdr_atomic_store_64(f,v) __atomic_store_n(f,v, __ATOMIC_SEQ_CST)
 #define hdr_atomic_exchange_64(f,i) __atomic_exchange_n(f,i, __ATOMIC_SEQ_CST)
 #define hdr_atomic_add_fetch_64(field, value) __atomic_add_fetch(field, value, __ATOMIC_SEQ_CST)
+#define hdr_atomic_compare_exchange_64(field, expected, desired) __atomic_compare_exchange_n(field, expected, desired, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
 
 #elif defined(__x86_64__)
 
 #include <stdint.h>
+#include <stdbool.h>
 
 static inline void* hdr_atomic_load_pointer(void** pointer)
 {
@@ -96,6 +130,13 @@ static inline int64_t hdr_atomic_add_fetch_64(volatile int64_t* field, int64_t v
     return __sync_add_and_fetch(field, value);
 }
 
+static inline bool hdr_atomic_compare_exchange_64(volatile int64_t* field, int64_t* expected, int64_t desired)
+{
+    int64_t original;
+    asm volatile( "lock; cmpxchgq %2, %1" : "=a"(original), "+m"(*field) : "q"(desired), "0"(*expected));
+    return original == *expected;
+}
+
 #else
 
 #error "Unable to determine atomic operations for your platform"

src/hdr_encoding.c HdrHistogram_c/src/hdr_encoding.csrc/hdr_encoding.c renamed to HdrHistogram_c/src/hdr_encoding.c

@@ -95,7 +95,7 @@ int zig_zag_encode_i64(uint8_t* buffer, int64_t signed_value)
     return bytesWritten;
 }
 
-int zig_zag_decode_i64(const uint8_t* buffer, int64_t* retVal)
+int zig_zag_decode_i64(const uint8_t* buffer, int64_t* signed_value)
 {
     uint64_t v = buffer[0];
     uint64_t value = v & 0x7F;
@@ -149,8 +149,15 @@ int zig_zag_decode_i64(const uint8_t* buffer, int64_t* retVal)
         }
     }
 
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable: 4146) // C4146: unary minus operator applied to unsigned type, result still unsigned
+#endif
     value = (value >> 1) ^ (-(value & 1));
-    *retVal = (int64_t) value;
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+    *signed_value = (int64_t) value;
 
     return bytesRead;
 }

src/hdr_encoding.h HdrHistogram_c/src/hdr_encoding.hsrc/hdr_encoding.h renamed to HdrHistogram_c/src/hdr_encoding.h

@@ -16,6 +16,7 @@
 
 #include "hdr_histogram.h"
 #include "hdr_tests.h"
+#include "hdr_atomic.h"
 
 /*  ######   #######  ##     ## ##    ## ########  ######  */
 /* ##    ## ##     ## ##     ## ###   ##    ##    ##    ## */
@@ -66,12 +67,49 @@ static void counts_inc_normalised(
     h->total_count += value;
 }
 
+static void counts_inc_normalised_atomic(
+    struct hdr_histogram* h, int32_t index, int64_t value)
+{
+    int32_t normalised_index = normalize_index(h, index);
+
+    hdr_atomic_add_fetch_64(&h->counts[normalised_index], value);
+    hdr_atomic_add_fetch_64(&h->total_count, value);
+}
+
 static void update_min_max(struct hdr_histogram* h, int64_t value)
 {
     h->min_value = (value < h->min_value && value != 0) ? value : h->min_value;
     h->max_value = (value > h->max_value) ? value : h->max_value;
 }
 
+static void update_min_max_atomic(struct hdr_histogram* h, int64_t value)
+{
+    int64_t current_min_value;
+    int64_t current_max_value;
+    do
+    {
+        current_min_value = hdr_atomic_load_64(&h->min_value);
+
+        if (0 == value || current_min_value <= value)
+        {
+            break;
+        }
+    }
+    while (!hdr_atomic_compare_exchange_64(&h->min_value, &current_min_value, value));
+
+    do
+    {
+        current_max_value = hdr_atomic_load_64(&h->max_value);
+
+        if (value <= current_max_value)
+        {
+            break;
+        }
+    }
+    while (!hdr_atomic_compare_exchange_64(&h->max_value, &current_max_value, value));
+}
+
+
 /* ##     ## ######## #### ##       #### ######## ##    ## */
 /* ##     ##    ##     ##  ##        ##     ##     ##  ##  */
 /* ##     ##    ##     ##  ##        ##     ##      ####   */
@@ -359,13 +397,13 @@ int hdr_init(
         return r;
     }
 
-    counts = calloc((size_t) cfg.counts_len, sizeof(int64_t));
+    counts = (int64_t*) calloc((size_t) cfg.counts_len, sizeof(int64_t));
     if (!counts)
     {
         return ENOMEM;
     }
 
-    histogram = calloc(1, sizeof(struct hdr_histogram));
+    histogram = (struct hdr_histogram*) calloc(1, sizeof(struct hdr_histogram));
     if (!histogram)
     {
         return ENOMEM;
@@ -381,8 +419,10 @@ int hdr_init(
 
 void hdr_close(struct hdr_histogram* h)
 {
-    free(h->counts);
-    free(h);
+    if (h) {
+	free(h->counts);
+	free(h);
+    }
 }
 
 int hdr_alloc(int64_t highest_trackable_value, int significant_figures, struct hdr_histogram** result)
@@ -418,6 +458,11 @@ bool hdr_record_value(struct hdr_histogram* h, int64_t value)
     return hdr_record_values(h, value, 1);
 }
 
+bool hdr_record_value_atomic(struct hdr_histogram* h, int64_t value)
+{
+    return hdr_record_values_atomic(h, value, 1);
+}
+
 bool hdr_record_values(struct hdr_histogram* h, int64_t value, int64_t count)
 {
     int32_t counts_index;
@@ -440,11 +485,37 @@ bool hdr_record_values(struct hdr_histogram* h, int64_t value, int64_t count)
     return true;
 }
 
+bool hdr_record_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count)
+{
+    int32_t counts_index;
+
+    if (value < 0)
+    {
+        return false;
+    }
+
+    counts_index = counts_index_for(h, value);
+
+    if (counts_index < 0 || h->counts_len <= counts_index)
+    {
+        return false;
+    }
+
+    counts_inc_normalised_atomic(h, counts_index, count);
+    update_min_max_atomic(h, value);
+
+    return true;
+}
+
 bool hdr_record_corrected_value(struct hdr_histogram* h, int64_t value, int64_t expected_interval)
 {
     return hdr_record_corrected_values(h, value, 1, expected_interval);
 }
 
+bool hdr_record_corrected_value_atomic(struct hdr_histogram* h, int64_t value, int64_t expected_interval)
+{
+    return hdr_record_corrected_values_atomic(h, value, 1, expected_interval);
+}
 
 bool hdr_record_corrected_values(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval)
 {
@@ -472,6 +543,32 @@ bool hdr_record_corrected_values(struct hdr_histogram* h, int64_t value, int64_t
     return true;
 }
 
+bool hdr_record_corrected_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval)
+{
+    int64_t missing_value;
+
+    if (!hdr_record_values_atomic(h, value, count))
+    {
+        return false;
+    }
+
+    if (expected_interval <= 0 || value <= expected_interval)
+    {
+        return true;
+    }
+
+    missing_value = value - expected_interval;
+    for (; missing_value >= expected_interval; missing_value -= expected_interval)
+    {
+        if (!hdr_record_values_atomic(h, missing_value, count))
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
 int64_t hdr_add(struct hdr_histogram* h, const struct hdr_histogram* from)
 {
     struct hdr_iter iter;