From d74d67a0e2d3de0ec208ed9b839815a70d84f727 Mon Sep 17 00:00:00 2001 From: dimitri staessens Date: Tue, 24 May 2016 20:38:01 +0200 Subject: 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. --- src/lib/CMakeLists.txt | 1 + src/lib/time_utils.c | 141 +++++++++++++++++++++++++++++++++++ src/tools/CMakeLists.txt | 1 + src/tools/cbr/CMakeLists.txt | 16 ++++ src/tools/cbr/cbr.c | 124 ++++++++++++++++++++++++++++++ src/tools/cbr/cbr_client.c | 97 ++++++++++++++++++++++++ src/tools/cbr/cbr_server.c | 174 +++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 554 insertions(+) create mode 100644 src/lib/time_utils.c create mode 100644 src/tools/cbr/CMakeLists.txt create mode 100644 src/tools/cbr/cbr.c create mode 100644 src/tools/cbr/cbr_client.c create mode 100644 src/tools/cbr/cbr_server.c (limited to 'src') 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 + * + * 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 +#include + +/* 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 + * Sander Vrijders + * + * 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 +#include +#include +#include +#include +#include + +#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 + * Sander Vrijders + * + * 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 +#include + +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 + * Sander Vrijders + * + * 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 +#include +#include +#include +#include + +#include +#include + +#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; +} -- cgit v1.2.3