Changeset 1974

Timestamp:

04/12/08 22:34:10 (7 months ago)

Author:

aturner

Message:

now I calculate how much time has passed since the last packet was sent, but I
still need to use the sleep-accellerator. refs #41

Location:

features/performance/src

Files:

• common/timer.h (modified) (3 diffs)
• defines.h.in (modified) (3 diffs)
• send_packets.c (modified) (13 diffs)
• sleep.h (modified) (2 diffs)

features/performance/src/common/timer.h

@@ -43 +43 @@
 #include <math.h>
 
+#ifdef HAVE_ABSOLUTE_TIME
+#include <CoreServices/CoreServices.h>
+#endif
+
+/* AbsoluteTime methods */
+#ifndef NonZero
+#define NonZero(x) ((x).hi | (x).lo)
+#endif
+#ifndef SetZero
+#define SetZero(x) do { (x).hi = 0 ; (x).lo = 0; } while(0)
+#endif
+#ifndef CopyAbsolute
+#define CopyAbsolute(x, y) do { (x).lo = (y).lo ; (x).hi = (y).hi; } while (0)
+#endif
+#ifndef AbsoluteCmp
+#define AbsoluteCmp(left, right, cmp)       \
+        (((left)->hi == (right)->hi) ?              \
+        ((left)->lo cmp (right)->lo) :              \
+        ((left)->hi cmp (right)->hi))
+#endif
+
 /*
  * 1 sec = 1,0000 millisec (ms)
@@ -77 +98 @@
 
 #ifndef ROUND_TIMESPEC_TO_MICROSEC(ts)
-#define ROUND_TIMESPEC_TO_MICROSEC(ts)       \
-    do {                                        \
-        (ts)->tv_nsec = (lroundf((float)(ts)->tv_nsec / 1000) * 1000);   \
+#define ROUND_TIMESPEC_TO_MICROSEC(ts)      \
+    do {                                    \
+        (ts)->tv_nsec = ((((ts)->tv_nsec / 1000) + ((ts)->tv_nsec % 1000 >= 500 ? 1 : 0)) * 1000);   \
     } while (0)
 #endif
@@ -170 +191 @@
         } while(0)
 
-#endif
+
+/* 
+ * returns the amount of time that has passed since the 
+ * last time you called this function.
+ */
+static inline void
+get_delta_time(struct timespec *ret)
+{
+/* OS X has absolute time */
+#ifdef HAVE_ABSOLUTE_TIME
+    static AbsoluteTime last = {0, 0};
+    AbsoluteTime now, delta;
+    Nanoseconds nano;
+    
+    now = UpTime();
+    
+    if (! NonZero(last)) {
+        timesclear(ret);
+    } else {
+        delta = SubAbsoluteFromAbsolute(now, last);
+        nano = AbsoluteToNanoseconds(delta);
+        NANOSEC_TO_TIMESPEC(UnsignedWideToUInt64(nano) / 10, ret);
+    }
+
+    CopyAbsolute(last, now);
+    
+/* Everyone else just uses gettimeofday */
+#else
+    static struct timeval last = {0, 0};
+    struct timeval now, delta;
+    
+    gettimeofday(&now, NULL);
+    if (!timerisset(&last)) {
+        timeradd(&last, &now, &last);
+        timesclear(ret);
+    } else {
+        timersub(&now, &last, &delta);
+        last.tv_sec = now.tv_sec;
+        last.tv_nsec = now.tv_nsec;
+        TIMEVAL_TO_TIMESPEC(&delta, ret);
+    }
+#endif
+}
+
+#endif /* _TIMER_H_ */

features/performance/src/defines.h.in

@@ -161 +161 @@
 
 /* struct timeval print structs */
-#define TIMEVAL_FORMAT "%lu.%06lu"
+#define TIMEVAL_FORMAT "%lus %luusec"
+#define TIMESPEC_FORMAT "%lus %lunsec"
 
 /* force a word or half-word swap on both Big and Little endian systems */
@@ -227 +228 @@
         (tv)->tv_usec = (x) - ((tv)->tv_sec * 1000000);   \
     } while(0)
-
+/*
 #define NANOSEC_TO_TIMEVAL(x, tv)           \
     do {                                    \
@@ -238 +239 @@
         (ts)->tv_sec = (x) / 1000000000;      \
         (ts)->tv_nsec = (x) - ((ts)->tv_sec * 1000000000);   \
+    } while(0)
+*/
+#define NANOSEC_TO_TIMEVAL(x, tv)           \
+    do {                                    \
+        (tv)->tv_sec =  (x) / 1000000000;      \
+        (tv)->tv_usec = ((x) % 1000000000) / 1000);   \
+    } while(0)
+
+#define NANOSEC_TO_TIMESPEC(x, ts)          \
+    do {                                    \
+        (ts)->tv_sec = (x) / 1000000000;      \
+        (ts)->tv_nsec = (x) % 1000000000;   \
     } while(0)
 

features/performance/src/send_packets.c

@@ -73 +73 @@
 static void do_sleep(struct timeval *time, struct timeval *last, int len, 
     int accurate, sendpacket_t *sp, COUNTER counter);
-static u_char *get_next_packet(pcap_t *pcap, struct pcap_pkthdr *pkthdr, 
+static const u_char *get_next_packet(pcap_t *pcap, struct pcap_pkthdr *pkthdr, 
     int file_idx, packet_cache_t **prev_packet);
 static u_int32_t get_user_count(sendpacket_t *sp, COUNTER counter);
@@ -164 +164 @@
         /*
          * we have to cast the ts, since OpenBSD sucks
-         * had to be special and use bpf_timeval 
+         * had to be special and use bpf_timeval.
+         * Only sleep if we're not in top speed mode (-t)
          */
-        do_sleep((struct timeval *)&pkthdr.ts, &last, pktlen, options.accurate, sp, packetnum);
-            
+         if (options.speed.mode != SPEED_TOPSPEED)
+            do_sleep((struct timeval *)&pkthdr.ts, &last, pktlen, options.accurate, sp, packetnum);
+        
         /* write packet out on network */
         if (sendpacket(sp, pktdata, pktlen) < (int)pktlen)
             warnx("Unable to send packet: %s", sendpacket_geterr(sp));
-                
+
         /* 
          * track the time of the "last packet sent".  Again, because of OpenBSD
@@ -199 +201 @@
  * will be updated as new entries are added (or retrieved) from the cache list.
  */
-static u_char *
+static const u_char *
 get_next_packet(pcap_t *pcap, struct pcap_pkthdr *pkthdr, int file_idx, 
     packet_cache_t **prev_packet)
@@ -238 +240 @@
                          * We should read the pcap file, and cache the results
                          */
-                        pktdata = pcap_next(pcap, pkthdr);
+                        pktdata = (u_char *)pcap_next(pcap, pkthdr);
                         if (pktdata != NULL) {
                                 if (*prev_packet == NULL) {
@@ -268 +270 @@
                  * Read pcap file as normal
                  */
-                pktdata = pcap_next(pcap, pkthdr);
+                pktdata = (u_char *)pcap_next(pcap, pkthdr);
         }
 
+    /* this get's casted to a const on the way out */
         return pktdata;
 }
@@ -325 +328 @@
     static struct timeval totalsleep = { 0, 0 };
 #endif
-    static int adjuster_flipper = 0;
-#ifdef HAVE_TCPREPLAY
-    struct timespec adjuster = { 0, OPT_VALUE_SLEEP_ACCEL * 1000 }
-#else
-    struct timespec adjuster = { 0, ADJUSTER_OFFSET * 1000 };
-#endif
-    static struct timespec nap = { 0, 0 };
-    static u_int32_t double_up = 0;
+    struct timespec adjuster = { 0, 0 };
+    static struct timespec nap = { 0, 0 }, delta_time = {0, 0};
     struct timeval nap_for, now, sleep_until;
-    struct timespec ignore, sleep, nap_this_time;
+    struct timespec nap_this_time;
+    static int32_t nsec_adjuster = -1, nsec_times = -1;
     float n;
     static u_int32_t send = 0;      /* accellerator.   # of packets to send w/o sleeping */
     u_int64_t ppnsec; /* packets per usec */
+
+
+#ifdef TCPREPLAY
+    adjuster.tv_nsec = OPT_VALUE_SLEEP_ACCEL * 1000;
+#else
+    adjuster.tv_nsec = ADJUSTER_OFFSET * 1000;
+#endif
+
+    dbgx(2, "Adjuster: " TIMEVAL_FORMAT, adjuster.tv_sec, adjuster.tv_nsec);
     
-    /* just return if topspeed */
-    if (options.speed.mode == SPEED_TOPSPEED)
-        return;
-
     /* acclerator time? */
     if (send > 0) {
@@ -349 +352 @@
     }
         
-    dbgx(3, "Last time: " TIMEVAL_FORMAT, last->tv_sec, last->tv_usec);
-
-    if (gettimeofday(&now, NULL) < 0) {
+    dbgx(4, "Last time: " TIMEVAL_FORMAT, last->tv_sec, last->tv_usec);
+
+    if (gettimeofday(&now, NULL) < 0)
         errx(1, "Error gettimeofday: %s", strerror(errno));
-    }
-
-    dbgx(3, "Now time: " TIMEVAL_FORMAT, now.tv_sec, now.tv_usec);
+
+    dbgx(4, "Now time: " TIMEVAL_FORMAT, now.tv_sec, now.tv_usec);
 
     /* First time through for this file */
@@ -368 +370 @@
 
     switch(options.speed.mode) {
+    /* 
+     * If top speed, you shouldn't even be here, but handle it anyways
+     */
+    case SPEED_TOPSPEED:
+        notice("you shouldn't call do_sleep() in top speed mode.");
+        return;
+        break;
+        
     case SPEED_MULTIPLIER:
         /* 
@@ -384 +394 @@
              */
             timesclear(&nap);
-        }
-
-        /* round up/down as necessary */
-        if (accurate != ACCURATE_ABS_TIME)
-            ROUND_TIMESPEC_TO_MICROSEC(&nap);
-        
+        }        
         break;
 
@@ -402 +407 @@
             nap.tv_nsec = (n - nap.tv_sec)  * 1000000000;
             
-            /* round up/down as necessary */
-            if (accurate != ACCURATE_ABS_TIME)
-                ROUND_TIMESPEC_TO_MICROSEC(&nap);
-
             dbgx(3, "packet size %d\t\tequals %f bps\t\tnap " TIMEVAL_FORMAT, len, n, 
                 nap.tv_sec, nap.tv_nsec);
@@ -424 +425 @@
         }
         break;
-
+        
     case SPEED_ONEATATIME:
         /* do we skip prompting for a key press? */
@@ -452 +453 @@
     nap_this_time.tv_nsec = nap.tv_nsec;
 
+    if (accurate != ACCURATE_ABS_TIME) {
+
+        switch (options.speed.mode) {
+            /* Mbps & Multipler are dynamic timings, so we round to the nearest usec */
+            case SPEED_MBPSRATE:
+            case SPEED_MULTIPLIER:
+                ROUND_TIMESPEC_TO_MICROSEC(&nap_this_time);
+                break;
+
+            /* Packets/sec is static, so we weight packets for .1usec accuracy */
+            case SPEED_PACKETRATE:
+                if (nsec_adjuster < 0)
+                    nsec_adjuster = (nap_this_time.tv_nsec % 10000) / 1000;
+        
+                /* update in the range of 0-9 */
+                nsec_times = (nsec_times + 1) % 10;
+        
+                if (nsec_times < nsec_adjuster) {
+                    /* sorta looks like a no-op, but gives us a nice round usec number */
+                    nap_this_time.tv_nsec = (nap_this_time.tv_nsec / 1000 * 1000) + 1000;
+                } else {
+                    nap_this_time.tv_nsec -= (nap_this_time.tv_nsec % 1000);
+                }
+    
+                dbgx(3, "(%ld)\tnsec_times = %ld\tnap adjust: %lu -> %lu", nsec_adjuster, nsec_times, nap.tv_nsec, nap_this_time.tv_nsec);            
+                break;
+                
+            default:
+                errx(1, "Unknown/supported speed mode: %d", options.speed.mode);
+        }
+    }
+
+
+    get_delta_time(&delta_time);
+    dbgx(2, "delta: " TIMESPEC_FORMAT, delta_time.tv_sec, delta_time.tv_nsec);
+
+    if (timesisset(&delta_time)) {
+        if (timescmp(&nap_this_time, &delta_time, >)) {
+            timessub(&nap_this_time, &delta_time, &nap_this_time);
+            dbgx(3, "timesub: %lu %lu", delta_time.tv_sec, delta_time.tv_nsec);
+        } else { 
+            timesclear(&nap_this_time);
+            dbgx(3, "timesclear: " TIMESPEC_FORMAT, delta_time.tv_sec, delta_time.tv_nsec);
+        }
+    }
+
     /* apply the adjuster... */
     if (timesisset(&adjuster)) {
         if (timescmp(&nap_this_time, &adjuster, >)) {
             timessub(&nap_this_time, &adjuster, &nap_this_time);
-            dbgx(1, "adjusting nap_this_time by %lu nsec", adjuster.tv_nsec);
         } else { 
-            dbg(1, "resetting nap_this_time to 0");
             timesclear(&nap_this_time);
         }
     }
     
-    /* don't sleep if nap = { 0, 0} */
+    dbgx(2, "Sleeping: " TIMESPEC_FORMAT, nap_this_time.tv_sec, nap_this_time.tv_nsec);
+
+    /* don't sleep if nap = {0, 0} */
     if (!timesisset(&nap_this_time))
         return;
-
-
+        
     /*
      * Depending on the accurate method & packet rate computation method
-
-    /* 
      * We have multiple methods of sleeping, pick the right one...
      */
@@ -532 +576 @@
     dbgx(4, "Total sleep time: " TIMEVAL_FORMAT, totalsleep.tv_sec, totalsleep.tv_usec);
 #endif
+
+    get_delta_time(&delta_time);
+    dbgx(2, "sleep delta: " TIMESPEC_FORMAT, delta_time.tv_sec, delta_time.tv_nsec);
+
 }
 

features/performance/src/sleep.h

@@ -33 +33 @@
 #include "config.h"
 #include "defines.h"
+#include "common.h"
 
 #ifdef HAVE_SYS_SELECT  /* According to POSIX 1003.1-2001 */
@@ -83 +84 @@
 #ifdef HAVE_ABSOLUTE_TIME
 #include <CoreServices/CoreServices.h>
-#define NonZero(x) ((x).hi | (x).lo)
-
 
 /*