Changeset cc9c9de

Timestamp:

05/18/18 11:39:59 (3 years ago)

Author:

Shane Alcock <salcock@…>

Branches:

cachetimestamps, develop, etsilive, master, rc-4.0.4, ringdecrementfix, ringperformance

Children:

1e0a804

Parents:

e732393

git-author:

Shane Alcock <salcock@…> (04/17/18 16:45:58)

git-committer:

Shane Alcock <salcock@…> (05/18/18 11:39:59)

Message:

Add new config option for trace_event() -- REPLAY_SPEEDUP

This allows users to specify a "speedup factor" when using
trace_event() to replay trace files, i.e. all inter-packet
gaps will be divided by the speedup factor. This allows traces
to be replayed faster, while still preserving the same relative
gaps between packets.

Files:

• lib/format_dag25.c (modified) (1 diff)
• lib/format_helper.c (modified) (4 diffs)
• lib/format_linux_common.c (modified) (1 diff)
• lib/format_pcapfile.c (modified) (1 diff)
• lib/format_pcapng.c (modified) (1 diff)
• lib/libtrace.h.in (modified) (1 diff)
• lib/libtrace_int.h (modified) (2 diffs)
• lib/trace.c (modified) (3 diffs)
• tools/tracereplay/tracereplay.c (modified) (1 diff)

lib/format_dag25.c

@@ -608 +608 @@
                 return -1;
         case TRACE_OPTION_EVENT_REALTIME:
+        case TRACE_OPTION_REPLAY_SPEEDUP:
                 /* Live capture is always going to be realtime */
                 return -1;

lib/format_helper.c

@@ -127 +127 @@
         double ts;
         double now;
+        double sincebeginnow = 0;
+        double sincebegintrace = 0;
+
 #ifdef WIN32
         struct __timeb64 tstruct;
@@ -182 +185 @@
 
         
-        if (fabs(trace->event.tdelta)>1e-9) {
-                /* Subtract the tdelta from the walltime to get a suitable
+        if (fabs(trace->event.first_now)>1e-9) {
+                /* Subtract the tdelta from the starting times to get a suitable
                  * "relative" time */
-                now -= trace->event.tdelta; 
+                sincebeginnow = (now - trace->event.first_now);
+                sincebegintrace = (ts - trace->event.first_ts);
 
                 /* If the trace timestamp is still in the future, return a 
                  * SLEEP event, otherwise return the packet */
-                if (ts > now) {
-                        event.seconds = ts - 
-                                trace->event.trace_last_ts;
-                        trace->event.trace_last_ts = ts;
+                if (sincebeginnow <= sincebegintrace / trace->replayspeedup) {
+                        event.seconds = ((sincebegintrace / trace->replayspeedup) - sincebeginnow);
                         event.type = TRACE_EVENT_SLEEP;
                         trace->event.waiting = true;
@@ -204 +206 @@
                  * trace file.
                  */
-                trace->event.tdelta = now - ts;
+                trace->event.first_now = now;
+                trace->event.first_ts = ts;
         }
 
@@ -219 +222 @@
         event.type = TRACE_EVENT_PACKET;
 
-        trace->event.trace_last_ts = ts;
         trace->event.waiting = false;
 

lib/format_linux_common.c

@@ -164 +164 @@
                         /* Live captures are always going to be in trace time */
                         break;
+                case TRACE_OPTION_REPLAY_SPEEDUP:
+                        break;
                 /* Avoid default: so that future options will cause a warning
                  * here to remind us to implement it, or flag it as

lib/format_pcapfile.c

@@ -257 +257 @@
                 case TRACE_OPTION_FILTER:
                 case TRACE_OPTION_HASHER:
+                case TRACE_OPTION_REPLAY_SPEEDUP:
                         /* All these are either unsupported or handled
                          * by trace_config */

lib/format_pcapng.c

@@ -260 +260 @@
                 case TRACE_OPTION_FILTER:
                 case TRACE_OPTION_HASHER:
+                case TRACE_OPTION_REPLAY_SPEEDUP:
                         break;
         }

lib/libtrace.h.in

@@ -1320 +1320 @@
         /** The hasher function for a parallel libtrace. It is recommended to
          * access this option via trace_set_hasher(). */
-        TRACE_OPTION_HASHER
+        TRACE_OPTION_HASHER,
+
+        /** Speed up trace file replays (via trace_event()) by this factor */
+        TRACE_OPTION_REPLAY_SPEEDUP,
 } trace_option_t;
 

lib/libtrace_int.h

@@ -152 +152 @@
 //#define RP_BUFSIZE 65536U
 
+#define LIBTRACE_MAX_REPLAY_SPEEDUP 1000
+
 /** Data about the most recent event from a trace file */
 struct libtrace_event_status_t {
         /** A libtrace packet to store the packet when a PACKET event occurs */
         libtrace_packet_t *packet;
-        /** Time between the timestamp for the current packet and the current 
-         * walltime */
-        double tdelta;
-        /** The timestamp of the previous PACKET event */
-        double trace_last_ts;
+
+        /* The walltime when we processed the first packet from the trace */
+        double first_now;
+
+        /* The tracetime of the first packet in the trace */
+        double first_ts;
+
         /** The size of the current PACKET event */
         int psize;
@@ -313 +317 @@
          * used only if the capture format does not support snapping natively */
         size_t snaplen;                 
+        /** Speed up the packet rate when using trace_event() to process trace
+         * files by this factor. */
+        int replayspeedup;
         /** Count of the number of packets returned to the libtrace user */
         uint64_t accepted_packets;

lib/trace.c

@@ -251 +251 @@
         libtrace->format=NULL;
 
-        libtrace->event.tdelta = 0.0;
         libtrace->event.packet = NULL;
         libtrace->event.psize = 0;
-        libtrace->event.trace_last_ts = 0.0;
+        libtrace->event.first_ts = 0.0;
+        libtrace->event.first_now = 0.0;
         libtrace->event.waiting = false;
         libtrace->filter = NULL;
         libtrace->snaplen = 0;
+        libtrace->replayspeedup = 1;
         libtrace->started=false;
         libtrace->uridata = NULL;
@@ -378 +379 @@
         libtrace->format=NULL;
 
-        libtrace->event.tdelta = 0.0;
         libtrace->event.packet = NULL;
         libtrace->event.psize = 0;
-        libtrace->event.trace_last_ts = 0.0;
+        libtrace->event.first_ts = 0;
+        libtrace->event.first_now = 0;
         libtrace->filter = NULL;
         libtrace->snaplen = 0;
@@ -595 +596 @@
          * deal with some options itself, so give that a go */
         switch(option) {
+                case TRACE_OPTION_REPLAY_SPEEDUP:
+                        /* Clear the error if there was one */
+                        if (trace_is_err(libtrace)) {
+                                trace_get_err(libtrace);
+                        }
+                        if (*(int*)value<1
+                                || *(int*)value>LIBTRACE_MAX_REPLAY_SPEEDUP) {
+                                trace_set_err(libtrace,TRACE_ERR_BAD_STATE,
+                                        "Invalid replay speed");
+                        }
+                        libtrace->replayspeedup=*(int*)value;
+                        return 0;
+
                 case TRACE_OPTION_SNAPLEN:
                         /* Clear the error if there was one */

tools/tracereplay/tracereplay.c

@@ -209 +209 @@
         libtrace_packet_t * new;
         int snaplen = 0;
+        int speedup = 1;