Merge branch 'for-sustrik' of git.lucina.net:libxs

13 files changed, 158 insertions, 234 deletions

diff --git a/include/xs.h b/include/xs.h
index a339bb9..f61a41a 100644
--- a/include/xs.h
+++ b/include/xs.h
@@ -241,6 +241,20 @@ typedef struct
 
 XS_EXPORT int xs_poll (xs_pollitem_t *items, int nitems, long timeout);
 
+/******************************************************************************/
+/*  The following utility functions are exported for use from language        */
+/*  bindings in performance tests, for the purpose of consistent results in   */
+/*  such tests.  They are not considered part of the core XS API per se,      */
+/*  use at your own risk!                                                     */
+/******************************************************************************/
+
+/*  Starts the stopwatch. Returns the handle to the watch.                    */
+XS_EXPORT void *xs_stopwatch_start (void);
+
+/*  Stops the stopwatch. Returns the number of microseconds elapsed since     */
+/*  the stopwatch was started.                                                */
+XS_EXPORT unsigned long xs_stopwatch_stop (void *watch);
+
 #undef XS_EXPORT
 
 #ifdef __cplusplus
diff --git a/include/xs_utils.h b/include/xs_utils.h
deleted file mode 100644
index c308d05..0000000
--- a/include/xs_utils.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-    Copyright (c) 2009-2012 250bpm s.r.o.
-    Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
-
-    This file is part of Crossroads I/O project.
-
-    Crossroads I/O is free software; you can redistribute it and/or modify it
-    under the terms of the GNU Lesser General Public License as published by
-    the Free Software Foundation; either version 3 of the License, or
-    (at your option) any later version.
-
-    Crossroads is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef __XS_UTILS_H_INCLUDED__
-#define __XS_UTILS_H_INCLUDED__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*  Handle DSO symbol visibility                                             */
-#if defined _WIN32
-#   if defined DLL_EXPORT
-#       define XS_EXPORT __declspec(dllexport)
-#   else
-#       define XS_EXPORT __declspec(dllimport)
-#   endif
-#else
-#   if defined __SUNPRO_C  || defined __SUNPRO_CC
-#       define XS_EXPORT __global
-#   elif (defined __GNUC__ && __GNUC__ >= 4) || defined __INTEL_COMPILER
-#       define XS_EXPORT __attribute__ ((visibility("default")))
-#   else
-#       define XS_EXPORT
-#   endif
-#endif
-
-/*  Helper functions are used by perf tests so that they don't have to care   */
-/*  about minutiae of different OS platforms.                                 */
-
-/*  Starts the stopwatch. Returns the handle to the watch.                    */
-XS_EXPORT void *xs_stopwatch_start (void);
-
-/*  Stops the stopwatch. Returns the number of microseconds elapsed since     */
-/*  the stopwatch was started.                                                */
-XS_EXPORT unsigned long xs_stopwatch_stop (void *watch);
-
-/*  Sleeps for specified number of seconds.                                   */
-XS_EXPORT void xs_sleep (int seconds);
-
-/*  Creates a new thread.                                                     */
-XS_EXPORT void *xs_thread_create (void (*fn) (void *arg), void* arg);
-
-/*  Wait for thread to finish.                                                */
-XS_EXPORT void xs_thread_join (void *thread);
-
-#undef XS_EXPORT
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/perf/local_lat.cpp b/perf/local_lat.cpp
index ca6a1e3..86adb2f 100644
--- a/perf/local_lat.cpp
+++ b/perf/local_lat.cpp
@@ -91,8 +91,6 @@ int main (int argc, char *argv [])
         return -1;
     }
 
-    xs_sleep (1);
-
     rc = xs_close (s);
     if (rc != 0) {
         printf ("error in xs_close: %s\n", xs_strerror (errno));
diff --git a/src/Makefile.am b/src/Makefile.am
index 0b226a1..c30c6cb 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -5,14 +5,14 @@ lib_LTLIBRARIES = libxs.la libzmq.la
 
 pkgconfig_DATA = libxs.pc libzmq.pc
 
-include_HEADERS = ../include/xs.h ../include/xs_utils.h \
+include_HEADERS = ../include/xs.h \
     ../include/zmq.h ../include/zmq_utils.h
 else
 lib_LTLIBRARIES = libxs.la
 
 pkgconfig_DATA = libxs.pc
 
-include_HEADERS = ../include/xs.h ../include/xs_utils.h
+include_HEADERS = ../include/xs.h
 endif
 
 libxs_la_SOURCES = \
@@ -138,8 +138,7 @@ libxs_la_SOURCES = \
     xrep.cpp \
     xreq.cpp \
     xsub.cpp \
-    xs.cpp \
-    xs_utils.cpp
+    xs.cpp
 
 if ON_MINGW
 libxs_la_LDFLAGS = -no-undefined -avoid-version -version-info @LIBXS_ABI_VERSION@ @LIBXS_EXTRA_LDFLAGS@
diff --git a/src/xs.cpp b/src/xs.cpp
index b90e383..36d40da 100644
--- a/src/xs.cpp
+++ b/src/xs.cpp
@@ -37,6 +37,7 @@
 #include "config.hpp"
 #include "likely.hpp"
 #include "upoll.hpp"
+#include "clock.hpp"
 #include "ctx.hpp"
 #include "err.hpp"
 #include "msg.hpp"
@@ -356,4 +357,24 @@ int xs_errno ()
     return errno;
 }
 
+//  The following utility functions are exported for use from language bindings
+//  in performance tests, for the purpose of consistent results in such tests.
+//  They are not considered part of the core XS API per se, use at your own
+//  risk!
+
+void *xs_stopwatch_start ()
+{
+    uint64_t *watch = (uint64_t*) malloc (sizeof (uint64_t));
+    alloc_assert (watch);
+    *watch = xs::clock_t::now_us ();
+    return (void*) watch;
+}
+
+unsigned long xs_stopwatch_stop (void *watch_)
+{
+    uint64_t end = xs::clock_t::now_us ();
+    uint64_t start = *(uint64_t*) watch_;
+    free (watch_);
+    return (unsigned long) (end - start);
+}
 
diff --git a/src/xs_utils.cpp b/src/xs_utils.cpp
deleted file mode 100644
index d10efbc..0000000
--- a/src/xs_utils.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
-    Copyright (c) 2009-2012 250bpm s.r.o.
-    Copyright (c) 2007-2009 iMatix Corporation
-    Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
-
-    This file is part of Crossroads I/O project.
-
-    Crossroads I/O is free software; you can redistribute it and/or modify it
-    under the terms of the GNU Lesser General Public License as published by
-    the Free Software Foundation; either version 3 of the License, or
-    (at your option) any later version.
-
-    Crossroads is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "platform.hpp"
-
-#include "../include/xs_utils.h"
-
-#include <stdlib.h>
-
-#include "stdint.hpp"
-#include "clock.hpp"
-#include "err.hpp"
-
-#if !defined XS_HAVE_WINDOWS
-#include <unistd.h>
-#include <pthread.h>
-#else
-#include "windows.hpp"
-#endif
-
-void xs_sleep (int seconds_)
-{
-#if defined XS_HAVE_WINDOWS
-    Sleep (seconds_ * 1000);
-#else
-    sleep (seconds_);
-#endif
-}
-
-void *xs_stopwatch_start ()
-{
-    uint64_t *watch = (uint64_t*) malloc (sizeof (uint64_t));
-    alloc_assert (watch);
-    *watch = xs::clock_t::now_us ();
-    return (void*) watch;
-}
-
-unsigned long xs_stopwatch_stop (void *watch_)
-{
-    uint64_t end = xs::clock_t::now_us ();
-    uint64_t start = *(uint64_t*) watch_;
-    free (watch_);
-    return (unsigned long) (end - start);
-}
-
-#if defined XS_HAVE_WINDOWS
-
-struct arg_t
-{
-    HANDLE handle;
-    void (*fn) (void *arg);
-    void *arg;
-};
-
-extern "C"
-{
-    static unsigned int __stdcall thread_routine (void *arg_)
-    {
-        arg_t *arg = (arg_t*) arg_;
-        arg->fn (arg->arg);
-        return 0;
-    }
-}
-
-void *xs_thread_create (void (*fn_) (void *arg_), void *arg_)
-{
-    arg_t *arg = (arg_t*) malloc (sizeof (arg_t));
-    alloc_assert (arg);
-    arg->fn = fn_;
-    arg->arg = arg_;
-    arg->handle = (HANDLE) _beginthreadex (NULL, 0,
-        &::thread_routine, (void*) arg, 0 , NULL);
-    win_assert (arg->handle != NULL);
-    return (void*) arg;
-}
-
-void xs_thread_join (void *thread_)
-{
-    arg_t *arg = (arg_t*) thread_;
-    DWORD rc = WaitForSingleObject (arg->handle, INFINITE);
-    win_assert (rc != WAIT_FAILED);
-    BOOL rc2 = CloseHandle (arg->handle);
-    win_assert (rc2 != 0);
-    free (arg);
-}
-
-#else
-
-struct arg_t
-{
-    pthread_t handle;
-    void (*fn) (void *arg);
-    void *arg;
-};
-
-extern "C"
-{
-    static void *thread_routine (void *arg_)
-    {
-        arg_t *arg = (arg_t*) arg_;
-        arg->fn (arg->arg);
-        return NULL;
-    }
-}
-
-void *xs_thread_create (void (*fn_) (void *arg_), void *arg_)
-{
-    arg_t *arg = (arg_t*) malloc (sizeof (arg_t));
-    alloc_assert (arg);
-    arg->fn = fn_;
-    arg->arg = arg_;
-    int rc = pthread_create (&arg->handle, NULL, thread_routine, (void*) arg);
-    posix_assert (rc);
-    return (void*) arg;
-}
-
-void xs_thread_join (void *thread_)
-{
-    arg_t *arg = (arg_t*) thread_;
-    int rc = pthread_join (arg->handle, NULL);
-    posix_assert (rc);
-    free (arg);
-}
-
-#endif
diff --git a/src/xszmq.cpp b/src/xszmq.cpp
index 350929d..b1f892a 100644
--- a/src/xszmq.cpp
+++ b/src/xszmq.cpp
@@ -25,10 +25,18 @@
 #include "../include/xs.h"
 #include "../include/xs_utils.h"
 
+#include "platform.hpp"
+
 #include <assert.h>
 #include <stdlib.h>
 #include <stdint.h>
 
+#if !defined XS_HAVE_WINDOWS
+#include <unistd.h>
+#else
+#include <windows.hpp>
+#endif
+
 void zmq_version (int *major_, int *minor_, int *patch_)
 {
     *major_ = ZMQ_VERSION_MAJOR;
@@ -451,8 +459,12 @@ unsigned long zmq_stopwatch_stop (void *watch)
     return xs_stopwatch_stop (watch);
 }
 
-void zmq_sleep (int seconds)
+void zmq_sleep (int seconds_)
 {
-    xs_sleep (seconds);
+#if defined XS_HAVE_WINDOWS
+    Sleep (seconds_ * 1000);
+#else
+    sleep (seconds_);
+#endif
 }
 
diff --git a/tests/polltimeo.cpp b/tests/polltimeo.cpp
index 3f7a233..087d125 100644
--- a/tests/polltimeo.cpp
+++ b/tests/polltimeo.cpp
@@ -26,12 +26,12 @@ extern "C"
     {
         //  Worker thread connects after delay of 1 second. Then it waits
         //  for 1 more second, so that async connect has time to succeed.
-        xs_sleep (1);
+        sleep (1);
         void *sc = xs_socket (ctx_, XS_PUSH);
         assert (sc);
         int rc = xs_connect (sc, "inproc://timeout_test");
         assert (rc == 0);
-        xs_sleep (1);
+        sleep (1);
         rc = xs_close (sc);
         assert (rc == 0);
     }
@@ -61,14 +61,14 @@ int XS_TEST_MAIN ()
     assert (elapsed > 440000 && elapsed < 550000);
 
     //  Check whether connection during the wait doesn't distort the timeout.
-    void *thread = xs_thread_create (polltimeo_worker, ctx);
+    void *thread = thread_create (polltimeo_worker, ctx);
     assert (thread);
     watch = xs_stopwatch_start ();
     rc = xs_poll (&pi, 1, 2000);
     assert (rc == 0);
     elapsed = xs_stopwatch_stop (watch);
     assert (elapsed > 1900000 && elapsed < 2100000);
-    xs_thread_join (thread);
+    thread_join (thread);
 
     //  Clean-up.
     rc = xs_close (sb);
diff --git a/tests/reconnect.cpp b/tests/reconnect.cpp
index c23d306..af8eda4 100644
--- a/tests/reconnect.cpp
+++ b/tests/reconnect.cpp
@@ -39,7 +39,7 @@ int XS_TEST_MAIN ()
     assert (rc == 3);
 
     //  Wait a while for few attempts to reconnect to happen.
-    xs_sleep (1);
+    sleep (1);
 
     //  Bind the peer and get the message.
     rc = xs_bind (pull, "tcp://127.0.0.1:5560");
@@ -67,7 +67,7 @@ int XS_TEST_MAIN ()
     assert (rc == 3);
 
     //  Wait a while for few attempts to reconnect to happen.
-    xs_sleep (1);
+    sleep (1);
 
     //  Bind the peer and get the message.
     rc = xs_bind (pull, "tcp://127.0.0.1:5560");
diff --git a/tests/shutdown_stress.cpp b/tests/shutdown_stress.cpp
index d7dffe8..27ab1f0 100644
--- a/tests/shutdown_stress.cpp
+++ b/tests/shutdown_stress.cpp
@@ -70,12 +70,12 @@ int XS_TEST_MAIN ()
         for (i = 0; i != THREAD_COUNT; i++) {
             s2 = xs_socket (ctx, XS_SUB);
             assert (s2);
-            threads [i] = xs_thread_create (shutdown_stress_worker, s2);
+            threads [i] = thread_create (shutdown_stress_worker, s2);
             assert (threads [i]);
         }
 
         for (i = 0; i != THREAD_COUNT; i++)
-            xs_thread_join (threads [i]);
+            thread_join (threads [i]);
 
         rc = xs_close (s1);
         assert (rc == 0);
diff --git a/tests/sub_forward.cpp b/tests/sub_forward.cpp
index cfff043..6d385de 100644
--- a/tests/sub_forward.cpp
+++ b/tests/sub_forward.cpp
@@ -62,7 +62,7 @@ int XS_TEST_MAIN ()
     assert (rc >= 0);
 
     //  Wait a bit till the subscription gets to the publisher.
-    xs_sleep (1);
+    sleep (1);
 
     //  Send an empty message.
     rc = xs_send (pub, NULL, 0, 0);
diff --git a/tests/testutil.hpp b/tests/testutil.hpp
index 8935dc8..d3452e3 100644
--- a/tests/testutil.hpp
+++ b/tests/testutil.hpp
@@ -26,15 +26,108 @@
 #include <string.h>
 #include <stdio.h>
 #include <stddef.h>
+#include <stdlib.h>
 
 #include "../include/xs.h"
 #include "../include/xs_utils.h"
 #include "../src/platform.hpp"
 
+#if !defined XS_HAVE_WINDOWS
+#include <unistd.h>
+#include <pthread.h>
+#else
+#include "../src/windows.hpp"
+#endif
+
 #if !defined XS_TEST_MAIN
 #define XS_TEST_MAIN main
 #endif
 
+#if defined XS_HAVE_WINDOWS
+#define sleep(s) Sleep ((s) * 1000)
+#endif
+
+#if defined XS_HAVE_WINDOWS
+
+struct arg_t
+{
+    HANDLE handle;
+    void (*fn) (void *arg);
+    void *arg;
+};
+
+extern "C"
+{
+    static unsigned int __stdcall thread_routine (void *arg_)
+    {
+        arg_t *arg = (arg_t*) arg_;
+        arg->fn (arg->arg);
+        return 0;
+    }
+}
+
+void *thread_create (void (*fn_) (void *arg_), void *arg_)
+{
+    arg_t *arg = (arg_t*) malloc (sizeof (arg_t));
+    assert (arg);
+    arg->fn = fn_;
+    arg->arg = arg_;
+    arg->handle = (HANDLE) _beginthreadex (NULL, 0,
+        &::thread_routine, (void*) arg, 0 , NULL);
+    win_assert (arg->handle != NULL);
+    return (void*) arg;
+}
+
+void thread_join (void *thread_)
+{
+    arg_t *arg = (arg_t*) thread_;
+    DWORD rc = WaitForSingleObject (arg->handle, INFINITE);
+    win_assert (rc != WAIT_FAILED);
+    BOOL rc2 = CloseHandle (arg->handle);
+    win_assert (rc2 != 0);
+    free (arg);
+}
+
+#else
+
+struct arg_t
+{
+    pthread_t handle;
+    void (*fn) (void *arg);
+    void *arg;
+};
+
+extern "C"
+{
+    static void *thread_routine (void *arg_)
+    {
+        arg_t *arg = (arg_t*) arg_;
+        arg->fn (arg->arg);
+        return NULL;
+    }
+}
+
+void *thread_create (void (*fn_) (void *arg_), void *arg_)
+{
+    arg_t *arg = (arg_t*) malloc (sizeof (arg_t));
+    assert (arg);
+    arg->fn = fn_;
+    arg->arg = arg_;
+    int rc = pthread_create (&arg->handle, NULL, thread_routine, (void*) arg);
+    assert (rc == 0);
+    return (void*) arg;
+}
+
+void thread_join (void *thread_)
+{
+    arg_t *arg = (arg_t*) thread_;
+    int rc = pthread_join (arg->handle, NULL);
+    assert (rc == 0);
+    free (arg);
+}
+
+#endif
+
 inline void bounce (void *sb, void *sc)
 {
     const char *content = "12345678ABCDEFGH12345678abcdefgh";
diff --git a/tests/timeo.cpp b/tests/timeo.cpp
index 000e718..e2dcbb8 100644
--- a/tests/timeo.cpp
+++ b/tests/timeo.cpp
@@ -26,12 +26,12 @@ extern "C"
     {
         //  Worker thread connects after delay of 1 second. Then it waits
         //  for 1 more second, so that async connect has time to succeed.
-        xs_sleep (1);
+        sleep (1);
         void *sc = xs_socket (ctx_, XS_PUSH);
         assert (sc);
         int rc = xs_connect (sc, "inproc://timeout_test");
         assert (rc == 0);
-        xs_sleep (1);
+        sleep (1);
         rc = xs_close (sc);
         assert (rc == 0);
     }
@@ -72,7 +72,7 @@ int XS_TEST_MAIN ()
     timeout = 2000;
     rc = xs_setsockopt(sb, XS_RCVTIMEO, &timeout, timeout_size);
     assert (rc == 0);
-    void *thread = xs_thread_create (timeo_worker, ctx);
+    void *thread = thread_create (timeo_worker, ctx);
     assert (thread);
     watch = xs_stopwatch_start ();
     rc = xs_recv (sb, buf, 32, 0);
@@ -80,7 +80,7 @@ int XS_TEST_MAIN ()
     assert (xs_errno () == EAGAIN);
     elapsed = xs_stopwatch_stop (watch);
     assert (elapsed > 1900000 && elapsed < 2100000);
-    xs_thread_join (thread);
+    thread_join (thread);
 
     //  Check that timeouts don't break normal message transfer.
     void *sc = xs_socket (ctx, XS_PUSH);