tools, lib: cbr tool for bandwidth testing

The tool sends constant bandwidth traffic between a client and a
server. cbr --help for more info.

Adds time_utils.h to the library containing useful functions for
arithmetic with timespec and timeval structures.

7 files changed, 554 insertions, 0 deletions

diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt
index ac9b93b1..796a0b7c 100644
--- a/src/lib/CMakeLists.txt
+++ b/src/lib/CMakeLists.txt
@@ -36,6 +36,7 @@ set(SOURCE_FILES
   shm_ap_rbuff.c
   shm_du_map.c
   sockets.c
+  time_utils.c
   utils.c
   )
 
diff --git a/src/lib/time_utils.c b/src/lib/time_utils.c
new file mode 100644
index 00000000..2521f217
--- /dev/null
+++ b/src/lib/time_utils.c
@@ -0,0 +1,141 @@
+/*
+ * Ouroboros - Copyright (C) 2016
+ *
+ * Time utilities
+ *
+ *    Dimitri Staessens <dimitri.staessens@intec.ugent.be>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <ouroboros/time_utils.h>
+#include <stddef.h>
+
+/* functions for timespecs */
+
+/* add intv to t and store it in res*/
+int ts_add(const struct timespec * t,
+           const struct timespec * intv,
+           struct timespec *       res)
+{
+        long nanos = 0;
+
+        if (t == NULL || intv == NULL || res == NULL)
+                return -1;
+
+        nanos = t->tv_nsec + intv->tv_nsec;
+
+        res->tv_sec = t->tv_sec + intv->tv_sec;
+        while (nanos > BILLION) {
+                nanos -= BILLION;
+                ++(res->tv_sec);
+        }
+        res->tv_nsec = nanos;
+
+        return 0;
+}
+
+/* subtract intv from t and stores it in res */
+int ts_diff(const struct timespec * t,
+            const struct timespec * intv,
+            struct timespec *       res)
+{
+        long nanos = 0;
+
+        if (t == NULL || intv == NULL || res == NULL)
+                return -1;
+
+        nanos = t->tv_nsec - intv->tv_nsec;
+
+        res->tv_sec = t->tv_sec - intv->tv_sec;
+        while (nanos < 0) {
+                nanos += BILLION;
+                --(res->tv_sec);
+        }
+        res->tv_nsec = nanos;
+
+        return 0;
+}
+
+/* functions for timevals */
+
+/* add intv to t and store it in res*/
+int tv_add(const struct timeval * t,
+           const struct timeval * intv,
+           struct timeval *       res)
+{
+        long micros = 0;
+
+        if (t == NULL || intv == NULL || res == NULL)
+                return -1;
+
+        micros = t->tv_usec + intv->tv_usec;
+
+        res->tv_sec = t->tv_sec + intv->tv_sec;
+        while (micros > MILLION) {
+                micros -= MILLION;
+                --(res->tv_sec);
+        }
+        res->tv_usec = micros;
+
+        return 0;
+}
+
+/* subtract intv from t and stores it in res */
+int tv_diff(const struct timeval * t,
+            const struct timeval * intv,
+            struct timeval       * res)
+{
+        long micros = 0;
+
+        if (t == NULL || intv == NULL || res == NULL)
+                return -1;
+
+        micros = t->tv_usec - intv->tv_usec;
+
+        res->tv_sec = t->tv_sec - intv->tv_sec;
+        while (micros < 0) {
+                micros += MILLION;
+                --(res->tv_sec);
+        }
+        res->tv_usec = micros;
+
+        return 0;
+}
+
+int tv_to_ts(const struct timeval * src,
+             struct timespec *      dst)
+{
+        if (src == NULL || dst == NULL)
+                return -1;
+
+        dst->tv_sec  = src->tv_sec;
+        dst->tv_nsec = src->tv_usec * 1000L;
+
+        return 0;
+}
+
+/* copying a timespec into a timeval (loss of resolution) */
+int ts_to_tv(const struct timespec * src,
+             struct timeval *        dst)
+{
+        if (src == NULL || dst == NULL)
+                return -1;
+
+        dst->tv_sec  = src->tv_sec;
+        dst->tv_usec = src->tv_nsec / 1000L;
+
+        return 0;
+}
diff --git a/src/tools/CMakeLists.txt b/src/tools/CMakeLists.txt
index 73b749f8..9f5e6fbe 100644
--- a/src/tools/CMakeLists.txt
+++ b/src/tools/CMakeLists.txt
@@ -1,2 +1,3 @@
 add_subdirectory(irm)
 add_subdirectory(echo)
+add_subdirectory(cbr)
diff --git a/src/tools/cbr/CMakeLists.txt b/src/tools/cbr/CMakeLists.txt
new file mode 100644
index 00000000..7c3f93f8
--- /dev/null
+++ b/src/tools/cbr/CMakeLists.txt
@@ -0,0 +1,16 @@
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+include_directories(${CMAKE_SOURCE_DIR}/include)
+include_directories(${CMAKE_BINARY_DIR}/include)
+
+set(SOURCE_FILES
+        # Add source files here
+        cbr.c
+)
+
+add_executable(cbr ${SOURCE_FILES})
+
+target_link_libraries(cbr LINK_PUBLIC ouroboros)
+
+install(TARGETS cbr RUNTIME DESTINATION bin)
diff --git a/src/tools/cbr/cbr.c b/src/tools/cbr/cbr.c
new file mode 100644
index 00000000..2317cd62
--- /dev/null
+++ b/src/tools/cbr/cbr.c
@@ -0,0 +1,124 @@
+/*
+ * Ouroboros - Copyright (C) 2016
+ *
+ * CBR traffic generator
+ *
+ *    Dimitri Staessens <dimitri.staessens@intec.ugent.be>
+ *    Sander Vrijders   <sander.vrijders@intec.ugent.be>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define _POSIX_C_SOURCE 199506L
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+#include <limits.h>
+#include <time.h>
+#include <stdbool.h>
+
+#define SERVER_AP_NAME "cbr-server"
+#define CLIENT_AP_NAME "echo-client"
+
+#define MILLION 1000000
+#define BILLION 1000000000
+
+#define BUF_SIZE 1500
+
+#include "cbr_client.c"
+
+struct s {
+        long interval;
+        long timeout;
+} server_settings;
+
+#include "cbr_server.c"
+
+static void usage(void)
+{
+        printf("Usage: cbr [OPTION]...\n"
+               "Sends SDU's from client to server at a constant bit rate.\n\n"
+               "  -l, --listen              Run in server mode\n"
+               "\n"
+               "Server options:\n"
+               "  -i, --interval            Server report interval (s)\n"
+               "  -t, --timeout             Server timeout interval (s)\n"
+               "\n"
+               "Client options:\n"
+               "  -d  --duration            Duration for sending (s)\n"
+               "  -s, --size                SDU size (B)\n"
+               "  -r, --rate                Rate (b/s)\n"
+               "\n\n"
+               "      --help                Display this help text and exit\n");
+}
+
+int main(int argc, char ** argv)
+{
+        int  duration = 60;      /* One minute test */
+        int  size     = 1000;    /* 1000 byte SDU's */
+        long rate     = 1000000; /* 1 Mb/s */
+        char * rem;
+
+        bool server = false;
+        server_settings.interval = 1; /* One second reporting interval */
+        server_settings.timeout  = 1;
+
+        argc--;
+        argv++;
+        while (argc > 0) {
+                if (strcmp(*argv, "-i") == 0 ||
+                    strcmp(*argv, "--interval") == 0) {
+                        server_settings.interval = strtol(*(++argv), &rem, 10);
+                        --argc;
+                } else if (strcmp(*argv, "-t") == 0 ||
+                           strcmp(*argv, "--timeout") == 0) {
+                        server_settings.timeout = strtol(*(++argv), &rem, 10);
+                        --argc;
+                } else if (strcmp(*argv, "-d") == 0 ||
+                           strcmp(*argv, "--duration") == 0) {
+                        duration = strtol(*(++argv), &rem, 10);
+                        --argc;
+                } else if (strcmp(*argv, "-s") == 0 ||
+                    strcmp(*argv, "--size") == 0) {
+                        size = strtol(*(++argv), &rem, 10);
+                        --argc;
+                } else if (strcmp(*argv, "-r") == 0 ||
+                           strcmp(*argv, "--rate") == 0) {
+                        rate = strtol(*(++argv), &rem, 10);
+                        if (*rem == 'k')
+                                rate *= 1000;
+                        if (*rem == 'M')
+                                rate *= MILLION;
+                        if (*rem == 'G')
+                                rate *= BILLION;
+                        --argc;
+                } else if (strcmp(*argv, "-l") == 0 ||
+                    strcmp(*argv, "--listen") == 0) {
+                        server = true;
+                } else {
+                        usage();
+                        return 0;
+                }
+                argc--;
+                argv++;
+        }
+
+        if (server) {
+                return server_main();
+        }
+
+        return client_main(duration, size, rate);
+}
diff --git a/src/tools/cbr/cbr_client.c b/src/tools/cbr/cbr_client.c
new file mode 100644
index 00000000..7b8e8b3f
--- /dev/null
+++ b/src/tools/cbr/cbr_client.c
@@ -0,0 +1,97 @@
+/*
+ * Ouroboros - Copyright (C) 2016
+ *
+ * A simple CBR generator
+ *
+ *    Dimitri Staessens <dimitri.staessens@intec.ugent.be>
+ *    Sander Vrijders <sander.vrijders@intec.ugent.be>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <ouroboros/dev.h>
+#include <ouroboros/time_utils.h>
+
+int client_main(int duration, int size, long rate)
+{
+        int fd = 0;
+        int result = 0;
+        bool stop = false;
+        char buf[size];
+        long seqnr = 0;
+        long long gap = size * 8 * (BILLION / rate); /* ns */
+
+        struct timespec start;
+        struct timespec end;
+        struct timespec interval = {(gap / BILLION), gap % BILLION};
+        int ms;
+
+        if (ap_init(CLIENT_AP_NAME)) {
+                printf("Failed to init AP.\n");
+                return -1;
+        }
+
+        printf("Client started, duration %d, rate %lu b/s, size %d B.\n",
+                duration, rate, size);
+
+        fd = flow_alloc(SERVER_AP_NAME, NULL, NULL);
+        if (fd < 0) {
+                printf("Failed to allocate flow.\n");
+                ap_fini();
+                return -1;
+        }
+
+        result = flow_alloc_res(fd);
+        if (result < 0) {
+                printf("Flow allocation refused.\n");
+                flow_dealloc(fd);
+                ap_fini();
+                return -1;
+        }
+
+        clock_gettime(CLOCK_REALTIME, &start);
+        while (!stop) {
+                memcpy(buf, &seqnr, sizeof(seqnr));
+
+                if (flow_write(fd, buf, size) == -1) {
+                        printf("Failed to write SDU.\n");
+                        stop = true;
+                }
+
+                nanosleep(&interval, NULL);
+
+                seqnr++;
+
+                clock_gettime(CLOCK_REALTIME, &end);
+
+                if (duration != 0
+                    && ts_diff_us(&start, &end) / MILLION >= (long) duration)
+                        stop = 1;
+        }
+
+        clock_gettime(CLOCK_REALTIME, &end);
+
+        ms = ts_diff_ms(&start, &end);
+
+        printf("sent statistics: "
+               "%9ld SDUs, %12ld bytes in %9d ms, %4.4f Mb/s\n",
+               seqnr, seqnr * size, ms, (seqnr * size * 8.0)/(ms * 1000));
+
+        flow_dealloc(fd);
+
+        ap_fini();
+
+        return 0;
+}
diff --git a/src/tools/cbr/cbr_server.c b/src/tools/cbr/cbr_server.c
new file mode 100644
index 00000000..14791bd4
--- /dev/null
+++ b/src/tools/cbr/cbr_server.c
@@ -0,0 +1,174 @@
+/*
+ * Ouroboros - Copyright (C) 2016
+ *
+ * A simple CBR generator
+ *
+ *    Dimitri Staessens <dimitri.staessens@intec.ugent.be>
+ *    Sander Vrijders   <sander.vrijders@intec.ugent.be>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdbool.h>
+#include <signal.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+#include <ouroboros/dev.h>
+#include <ouroboros/time_utils.h>
+
+#define DIF_NAME "*"
+
+
+void shutdown_server(int signo)
+{
+        char * dif = DIF_NAME;
+
+        if (ap_unreg(&dif, 1)) {
+                printf("Failed to unregister application.\n");
+                ap_fini();
+                exit(EXIT_FAILURE);
+        }
+
+        ap_fini();
+        exit(EXIT_SUCCESS);
+}
+
+void * handleflow(void * o)
+{
+        ssize_t count = 0;
+        int fd = *((int *) o);
+        char buf[BUF_SIZE];
+
+        struct timespec now;
+        struct timespec alive;
+        struct timespec intv = {server_settings.interval, 0};
+
+        struct timespec iv_start;
+        struct timespec iv_end;
+
+        bool stop = false;
+
+        long sdus            = 0;
+        long sdus_intv       = 0;
+        long bytes_read      = 0;
+        long bytes_read_intv = 0;
+
+
+        clock_gettime(CLOCK_REALTIME, &iv_start);
+        alive = iv_start;
+        ts_add(&iv_start, &intv, &iv_end);
+
+        flow_cntl(fd, FLOW_F_SETFL, FLOW_O_NONBLOCK);
+
+        while (!stop) {
+                clock_gettime(CLOCK_REALTIME, &now);
+
+                count = flow_read(fd, buf, BUF_SIZE);
+
+                if (count > 0) {
+                        clock_gettime(CLOCK_REALTIME, &alive);
+                        sdus++;
+                        bytes_read += count;
+                }
+
+                if (ts_diff_us(&alive, &now)
+                    > server_settings.timeout * MILLION) {
+                        printf("Test on flow %d timed out\n", fd);
+                        stop = true;
+                }
+
+                if (stop || ts_diff_ms(&now, &iv_end) < 0) {
+                        long us = ts_diff_us(&iv_start, &now);
+                        printf("Flow %4d: %9ld SDUs (%12ld bytes) in %9ld ms"
+                               " => %9.4f p/s, %9.4f Mb/s\n",
+                               fd,
+                               sdus-sdus_intv,
+                               bytes_read-bytes_read_intv,
+                               us / 1000,
+                               ((sdus-sdus_intv) / (float) us) * MILLION,
+                               8 * (bytes_read-bytes_read_intv)
+                               / (float)(us));
+                        iv_start=iv_end;
+                        sdus_intv = sdus;
+                        bytes_read_intv = bytes_read;
+                        ts_add(&iv_start, &intv, &iv_end);
+                }
+        }
+
+        return 0;
+}
+
+int server_main()
+{
+        int    server_fd = 0;
+        int    client_fd = 0;
+        char * dif = DIF_NAME;
+        char * client_name = NULL;
+        int    i         = 0;
+        pthread_t * threads = malloc(sizeof(*threads) * 10);
+        if (threads == NULL)
+                exit(1);
+
+        printf("Server started, interval is %ld s, timeout is %ld s.\n",
+               server_settings.interval, server_settings.timeout);
+
+        /* Manual cleanup is required for now */
+        if (signal(SIGINT, shutdown_server) == SIG_ERR) {
+                printf("Can't install signal handler.\n");
+                return -1;
+        }
+
+        if (ap_init(SERVER_AP_NAME)) {
+                printf("Failed to init AP.\n");
+                return -1;
+        }
+
+        server_fd = ap_reg(&dif, 1);
+        if (server_fd < 0) {
+                printf("Failed to register application.\n");
+                ap_fini();
+                return -1;
+        }
+
+        while (true) {
+                client_fd = flow_accept(server_fd,
+                                        &client_name, NULL);
+                if (client_fd < 0) {
+                        printf("Failed to accept flow.\n");
+                        break;
+                }
+
+                printf("New flow from %s.\n", client_name);
+
+                if (flow_alloc_resp(client_fd, 0)) {
+                        printf("Failed to give an allocate response.\n");
+                        flow_dealloc(client_fd);
+                        continue;
+                }
+
+                if (i < 10) {
+                        pthread_create(&threads[i++],
+                                       NULL,
+                                       handleflow,
+                                       &client_fd);
+                }
+        }
+
+        ap_fini();
+
+        return 0;
+}