Abstracted clock_gettime() to be able to build on OSX

Author: Vladimir Veljkovic

core/samples/pubnub_sync_sample.c

@@ -1,6 +1,8 @@
 /* -*- c-file-style:"stroustrup"; indent-tabs-mode: nil -*- */
 #include "pubnub_sync.h"
 
+#include "pubnub_helper.h"
+
 #include <stdio.h>
 
 

posix/README.md

@@ -25,3 +25,16 @@ build on any regular POSIX system with a C compiler. To use a compiler
 of your choice (rather than the default one), say, `clang`, run:
 
 	make -f posix.mk CC=clang
+
+
+## OSX / Darwin remarks
+
+While being a "mostly POSIX" compliant environment, OSX, in its
+"Darwin" OS base, doesn't support POSIX standard `clock_gettime()`
+API. It is strange as this is a well-known and often complained
+about, and the actual code to implement it is rather simple.
+
+Anyway, to be able to work on OSX / Darwin, we have a small module
+that abstracts "getting a monotonic clock time", with an
+implementation for POSIX and another for Darwin. You have to link the
+right one, and we do that in `posix.mk`.

posix/monotonic_clock_get_time.c

@@ -0,0 +1,7 @@
+#include "monotonic_clock_get_time.h"
+
+
+int monotonic_clock_get_time(struct timespec *tp)
+{
+  return clock_gettime(CLOCK_MONOTONIC, tp);
+}

posix/monotonic_clock_get_time.h

@@ -0,0 +1,20 @@
+#if !defined INC_MONOTONIC_CLOCK_GET_TIME
+#define      INC_MONOTONIC_CLOCK_GET_TIME
+
+#include <time.h>
+
+/** How many "millis" in a "nano" of some (any) unit. */
+#define MILLI_IN_NANO (1000 * 1000)
+
+/** How many "nanos" in one (unit) of something. */
+#define UNIT_IN_NANO (1000 * MILLI_IN_NANO)
+
+/** This abstracts getting of monotonic clock time. On POSIX compliant
+    systems, this is a simple `clock_gettime(CLOCK_MONOTONIC, tp)`.
+    But, not all Unix-like OSes are POSIX compliant that way, with OSX
+    / Darwin being a well-known one.
+ */
+int monotonic_clock_get_time(struct timespec *tp);
+
+
+#endif /* !defined INC_MONOTONIC_CLOCK_GET_TIME */

posix/monotonic_clock_get_time_darwin.c

@@ -0,0 +1,29 @@
+/* -*- c-file-style:"stroustrup"; indent-tabs-mode: nil -*- */
+#include "monotonic_clock_get_time.h"
+
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+#include <unistd.h>
+
+
+int monotonic_clock_get_time(struct timespec *tp)
+{
+    static mach_timebase_info_data_t s_time_base_info;
+    uint64_t absolute_time = mach_absolute_time();
+    uint64_t nanos;
+    
+    if (0 == s_time_base_info.denom) {
+        /* This is obviously not thread safe, but, we don't care, as
+           we always call it from the same thread. A thread safe
+           variant would either always call it, or provide some kind
+           of protection (it is actually hard to foresee which one of
+           those approaches would be faster).
+        */
+        mach_timebase_info(&s_time_base_info);
+    }
+    nanos = (absolute_time * s_time_base_info.numer) / s_time_base_info.denom;
+    tp->tv_sec = nanos / UNIT_IN_NANO;
+    tp->tv_nsec = nanos % UNIT_IN_NANO;
+    
+    return 0;
+}

posix/monotonic_clock_get_time_posix.c

@@ -0,0 +1,8 @@
+/* -*- c-file-style:"stroustrup"; indent-tabs-mode: nil -*- */
+#include "monotonic_clock_get_time.h"
+
+
+int monotonic_clock_get_time(struct timespec *tp)
+{
+    return clock_gettime(CLOCK_MONOTONIC, tp);
+}

posix/posix.mk

@@ -1,5 +1,12 @@
 SOURCEFILES = ../core/pubnub_coreapi.c ../core/pubnub_ccore.c ../core/pubnub_netcore.c  ../lib/sockets/pbpal_sockets.c ../lib/sockets/pbpal_resolv_and_connect_sockets.c ../core/pubnub_alloc_std.c ../core/pubnub_assert_std.c ../core/pubnub_generate_uuid.c ../core/pubnub_blocking_io.c ../core/pubnub_json_parse.c ../core/pubnub_helper.c  pubnub_version_posix.c  pubnub_generate_uuid_posix.c pbpal_posix_blocking_io.c
 
+OS := $(shell uname)
+ifeq ($(OS),Darwin)
+SOURCEFILES += monotonic_clock_get_time_darwin.c
+else
+SOURCEFILES += monotonic_clock_get_time_posix.c
+endif
+
 CFLAGS =-g -I ../core -I . -I fntest -I ../core/fntest -Wall
 # -g enables debugging, remove to get a smaller executable
 

posix/pubnub_ntf_callback_posix.c

@@ -1,6 +1,8 @@
 /* -*- c-file-style:"stroustrup"; indent-tabs-mode: nil -*- */
 #include "pubnub_ntf_callback.h"
 
+#include "monotonic_clock_get_time.h"
+
 #include "pubnub_internal.h"
 #include "pubnub_assert.h"
 #include "pbntf_trans_outcome_common.h"
@@ -79,9 +81,9 @@ void* socket_watcher_thread(void *arg)
     for (;;) {
         struct timespec timspec;
 
-        clock_gettime(CLOCK_MONOTONIC, &timspec);
-        timspec.tv_sec = (timspec.tv_nsec + 300) / 1000;
-        timspec.tv_nsec = (timspec.tv_nsec + 300) % 1000;
+        monotonic_clock_get_time(&timspec);
+        timspec.tv_sec = (timspec.tv_nsec + 300*MILLI_IN_NANO) / UNIT_IN_NANO;
+        timspec.tv_nsec = (timspec.tv_nsec + 300*MILLI_IN_NANO) % UNIT_IN_NANO;
 
         pthread_mutex_lock(&m_watcher.mutw);
         pthread_cond_timedwait(&m_watcher.condw, &m_watcher.mutw, &timspec);