Removed sleep-accel option. Timestamp after packet sent which allows us to clean up several timestamp hacks.

Author: fklassen

autogen.sh

@@ -6,7 +6,7 @@ if test -x "`which glibtoolize`" ; then
     # Necessary under OS X
     glibtoolize --copy --automake --force
 else
-    libtoolize --copy
+    libtoolize --copy --force
 fi
 autoheader
 automake --add-missing --copy

docs/CHANGELOG

@@ -1,6 +1,7 @@
 $Id$
 
 ??/??/2013 Version 3.5.0
+    - Removed sleep-accel option (anneta #2) 
     - Enhance accuracy and performance of --mbps option (appneta #2)
     - Add netmap injector (appneta #1)
     - Add --sleepmode option to handle high precision timing (#421)

libopts/parse-duration.c

@@ -54,14 +54,14 @@ typedef enum {
 #define TIME_MAX        0x7FFFFFFF
 
 /* Wrapper around strtoul that does not require a cast.  */
-static unsigned long inline
+static inline unsigned long
 str_const_to_ul (cch_t * str, cch_t ** ppz, int base)
 {
   return strtoul (str, (char **)ppz, base);
 }
 
 /* Wrapper around strtol that does not require a cast.  */
-static long inline
+static inline long
 str_const_to_l (cch_t * str, cch_t ** ppz, int base)
 {
   return strtol (str, (char **)ppz, base);
@@ -70,7 +70,7 @@ str_const_to_l (cch_t * str, cch_t ** ppz, int base)
 /* Returns BASE + VAL * SCALE, interpreting BASE = BAD_TIME
    with errno set as an error situation, and returning BAD_TIME
    with errno set in an error situation.  */
-static time_t inline
+static inline time_t
 scale_n_add (time_t base, time_t val, int scale)
 {
   if (base == BAD_TIME)

src/common/fakepoll.c

@@ -39,6 +39,7 @@
 #include "defines.h"
 #include "common.h"
 
+#ifdef USE_FAKE_POLL
 /* prevents ISO C error */
 static void FAKEPOLL(int stop)
 { 
@@ -48,7 +49,6 @@ static void FAKEPOLL(int stop)
 
 } 
 
-#ifdef USE_FAKE_POLL
 #include <sys/types.h>
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>

src/common/mac.c

@@ -81,7 +81,7 @@ mac2hex(const char *mac, u_char *dst, int len)
 int
 dualmac2hex(const char *dualmac, u_char *first, u_char *second, int len)
 {
-    char *tok, *temp, *string;
+    char *tok = NULL, *temp, *string;
     int ret = 0;
 
     string = safe_strdup(dualmac);
@@ -121,7 +121,7 @@ dualmac2hex(const char *dualmac, u_char *first, u_char *second, int len)
 tcpr_dir_t
 macinstring(const char *macstring, const u_char *mac)
 {
-    char *tok, *tempstr, *ourstring;
+    char *tok = NULL, *tempstr, *ourstring;
     u_char tempmac[6];
     int len = 6, ret = TCPR_DIR_S2C;
 

src/common/sendpacket.c

@@ -255,7 +255,7 @@ extern volatile int didsig;
 int
 sendpacket(sendpacket_t *sp, const u_char *data, size_t len, struct pcap_pkthdr *pkthdr)
 {
-    int retcode, val;
+    int retcode = 0, val;
     u_char buffer[10000]; /* 10K bytes, enough for jumbo frames + pkthdr */
 #ifdef HAVE_NETMAP
     struct netmap_ring *txring;
@@ -702,7 +702,7 @@ sendpacket_seterr(sendpacket_t *sp, const char *fmt, ...)
 }
 
 
-#if defined HAVE_PCAP_INJECT || defined HAVE_PCAP_SENDPACKET
+#if (defined HAVE_PCAP_INJECT || defined HAVE_PCAP_SENDPACKET) && ! defined INJECT_METHOD
 /**
  * Inner sendpacket_open() method for using libpcap
  */
@@ -996,7 +996,7 @@ sendpacket_open_pf(const char *device, char *errbuf)
     struct sockaddr_ll sa;
     int n = 1, err;
     socklen_t errlen = sizeof(err);
-    unsigned int mtu=1500;
+    unsigned int UNUSED(mtu) = 1500;
 
     assert(device);
     assert(errbuf);

src/common/timer.c

@@ -98,7 +98,7 @@ void timesdiv(struct timespec *tvs, COUNTER div)
 }
 
 void
-init_delta_time(delta_t *ctx)
+init_timestamp(timestamp_t *ctx)
 {
 #ifdef HAVE_ABSOLUTE_TIME
     SetZero(*ctx);

src/common/timer.h

@@ -201,17 +201,17 @@ void timesdiv(struct timespec *tvs, COUNTER div);
     } while(0)
 
 #ifdef HAVE_ABSOLUTE_TIME
-    typedef AbsoluteTime delta_t;
+    typedef AbsoluteTime timestamp_t;
 #else
-    typedef struct timeval delta_t;
+    typedef struct timeval timestamp_t;
 #endif
 
 /*
- * starts a timer so we can figure out how much time has passed
- * when we call get_delta_timer()
+ * starts a timer so we can figure out how long we have
+ * bee transmitting
  */
 static inline void
-start_delta_time(delta_t *ctx)
+get_packet_timestamp(timestamp_t *ctx)
 {
 #ifdef HAVE_ABSOLUTE_TIME
     *ctx = UpTime();
@@ -220,42 +220,7 @@ start_delta_time(delta_t *ctx)
 #endif
 }
 
-void init_delta_time(delta_t *ctx);
+void init_timestamp(timestamp_t *ctx);
 
-/*
- * returns the amount of time that has passed since the 
- * last time you called start_delta_time()
- */
-static inline void
-get_delta_time(delta_t *ctx, struct timespec *ret)
-{
-/* OS X has absolute time */
-#ifdef HAVE_ABSOLUTE_TIME
-    AbsoluteTime now, delta;
-    Nanoseconds nano;
-
-
-    if (! NonZero(*ctx)) {
-        timesclear(ret);
-    } else {
-        now = UpTime();
-        delta = SubAbsoluteFromAbsolute(now, *ctx);
-        nano = AbsoluteToNanoseconds(delta);
-        NANOSEC_TO_TIMESPEC(UnsignedWideToUInt64(nano) / 10, ret);
-    }
-
-    /* Everyone else just uses gettimeofday */
-#else
-    struct timeval now, delta;
-
-    if (!timerisset(ctx)) {
-        timesclear(ret);
-    } else {
-        gettimeofday(&now, NULL);
-        timersub(&now, ctx, &delta);
-        TIMEVAL_TO_TIMESPEC(&delta, ret);
-    }
-#endif
-}
 
 #endif /* _TIMER_H_ */

src/common/utils.h

@@ -38,16 +38,6 @@
 #include "defines.h"
 #include "common.h"
 
-#define max(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a > _b ? _a : _b; })
-
-#define min(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a > _b ? _b : _a; })
-
 int read_hexstring(const char *l2string, u_char *hex, const int hexlen);
 void packet_stats(struct timeval *begin, struct timeval *end, 
                   COUNTER bytes_sent, COUNTER pkts_sent, COUNTER failed);

src/defines.h.in

@@ -285,4 +285,28 @@ typedef u_int32_t uint32_t
 #define TIMESPEC_TO_MICROSEC(x)  (((x)->tv_sec * 1000000) + (x)->tv_nsec / 1000)
 #define TIMESPEC_TO_NANOSEC(x) ((u_int64_t)((x)->tv_sec * 1000000000) + ((u_int64_t)(x)->tv_nsec))
 
+/* help suppress some compiler warnings */
+#ifdef UNUSED 
+#elif defined(__GNUC__) 
+# define UNUSED(x) UNUSED_ ## x __attribute__((unused)) 
+#elif defined(__LCLINT__) 
+# define UNUSED(x) /*@unused@*/ x 
+#else 
+# define UNUSED(x) x 
+#endif
+
+#ifndef max
+#  define max(a,b) \
+       ({ __typeof__ (a) _a = (a); \
+           __typeof__ (b) _b = (b); \
+       _a > _b ? _a : _b; })
+#endif
+
+#ifndef min
+#  define min(a,b) \
+       ({ __typeof__ (a) _a = (a); \
+           __typeof__ (b) _b = (b); \
+       _a > _b ? _b : _a; })
+#endif
+
 #endif /* DEFINES */

src/send_packets.c

@@ -89,11 +89,12 @@ send_packets(pcap_t *pcap, int cache_file_idx)
 #if defined TCPREPLAY && defined TCPREPLAY_EDIT
     struct pcap_pkthdr *pkthdr_ptr;
 #endif
-    delta_t delta_ctx;
     COUNTER skip_length = 0;
     COUNTER start_us;
+    bool do_not_timestamp = options.speed.mode == SPEED_TOPSPEED ||
+            (options.speed.mode == SPEED_MBPSRATE && !options.speed.speed);
 
-    init_delta_time(&delta_ctx);
+    init_timestamp(&end);
     start_us = TIMEVAL_TO_MICROSEC(&begin);
 
     /* register signals */
@@ -166,26 +167,46 @@ send_packets(pcap_t *pcap, int cache_file_idx)
          * had to be special and use bpf_timeval.
          * Only sleep if we're not in top speed mode (-t)
          */
-        if (options.speed.mode != SPEED_TOPSPEED &&
-                !(options.speed.mode == SPEED_MBPSRATE && !options.speed.speed)) {
+
+        if (!do_not_timestamp) {
+            /*
+             * this accelerator improves performance by avoiding expensive
+             * time stamps during periods where we have fallen behind in our
+             * sending
+             */
+            if (skip_length) {
+                if ((COUNTER)pktlen < skip_length) {
+                    skip_length -= pktlen;
+                    goto SEND_NOW;
+                }
+
+                get_packet_timestamp(&end);
+                skip_length = 0;
+            }
+
             if (options.sleep_mode == REPLAY_V325) {
                 do_sleep_325((struct timeval *)&pkthdr.ts, &last, pktlen, options.accurate, sp, packetnum);
             } else {
                 do_sleep((struct timeval *)&pkthdr.ts, &last, pktlen, options.accurate, sp, packetnum,
-                        &delta_ctx, &start_us, &skip_length);
+                        &end, &start_us, &skip_length);
 
                 /* mark the time when we send the last packet */
                 if (!skip_length)
-                    start_delta_time(&delta_ctx);
+                    get_packet_timestamp(&end);
             }
         }
 
+SEND_NOW:
         dbgx(2, "Sending packet #" COUNTER_SPEC, packetnum);
 
         /* write packet out on network */
         if (sendpacket(sp, pktdata, pktlen, &pkthdr) < (int)pktlen)
             warnx("Unable to send packet: %s", sendpacket_geterr(sp));
 
+        /* mark the time when we send the last packet */
+        if (!do_not_timestamp && !skip_length)
+            get_packet_timestamp(&end);
+
         /*
          * track the time of the "last packet sent".  Again, because of OpenBSD
          * we have to do a memcpy rather then assignment.
@@ -238,11 +259,12 @@ send_dual_packets(pcap_t *pcap1, int cache_file_idx1, pcap_t *pcap2, int cache_f
     packet_cache_t *cached_packet1 = NULL, *cached_packet2 = NULL;
     packet_cache_t **prev_packet1 = NULL, **prev_packet2 = NULL, **prev_packet = NULL;
     struct pcap_pkthdr *pkthdr_ptr;
-    delta_t delta_ctx;
     COUNTER start_us;
     COUNTER skip_length = 0;
+    bool do_not_timestamp = options.speed.mode == SPEED_TOPSPEED ||
+            (options.speed.mode == SPEED_MBPSRATE && !options.speed.speed);
 
-    init_delta_time(&delta_ctx);
+    init_timestamp(&end);
     start_us = TIMEVAL_TO_MICROSEC(&begin);
 
     /* register signals */
@@ -350,26 +372,42 @@ send_dual_packets(pcap_t *pcap1, int cache_file_idx1, pcap_t *pcap2, int cache_f
          * had to be special and use bpf_timeval.
          * Only sleep if we're not in top speed mode (-t)
          */
-        if (options.speed.mode != SPEED_TOPSPEED &&
-                !(options.speed.mode == SPEED_MBPSRATE && !options.speed.speed)) {
+        if (!do_not_timestamp) {
+            /*
+             * this accelerator improves performance by avoiding expensive
+             * time stamps during periods where we have fallen behind in our
+             * sending
+             */
+            if (skip_length) {
+                if ((COUNTER)pktlen < skip_length) {
+                    skip_length -= pktlen;
+                    goto SEND_NOW;
+                }
+
+                get_packet_timestamp(&end);
+                skip_length = 0;
+            }
+
             if (options.sleep_mode == REPLAY_V325) {
                 do_sleep_325((struct timeval *)&pkthdr_ptr->ts, &last, pktlen, options.accurate, sp, packetnum);
             } else {
                 do_sleep((struct timeval *)&pkthdr_ptr->ts, &last, pktlen, options.accurate, sp, packetnum,
-                        &delta_ctx, &start_us, &skip_length);
+                        &end, &start_us, &skip_length);
 
-                /* mark the time when we send the last packet */
-                if (!skip_length)
-                    start_delta_time(&delta_ctx);
             }
         }
 
+SEND_NOW:
         dbgx(2, "Sending packet #" COUNTER_SPEC, packetnum);
 
         /* write packet out on network */
         if (sendpacket(sp, pktdata, pktlen, pkthdr_ptr) < (int)pktlen)
             warnx("Unable to send packet: %s", sendpacket_geterr(sp));
 
+        /* mark the time when we send the last packet */
+        if (!do_not_timestamp && !skip_length)
+            get_packet_timestamp(&end);
+
         /*
          * track the time of the "last packet sent".  Again, because of OpenBSD
          * we have to do a memcpy rather then assignment.