Changeset 6a6e6a8 for tools

Timestamp:

03/12/15 17:14:42 (7 years ago)

Author:

Richard Sanger <rsangerarj@…>

Branches:

4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes

Children:

a978dec

Parents:

b54e2da

Message:

More documentation, including some renaming and modifications to behaviour

• Removes accessor functions for libtrace_result_t, instead directly access the structure
• Documentation for most functions
• Split tick into interval and count messages for the two modes of operation
• Normalise interval and packet order to use the erf timestamp format
• Rename trace_send_message_to_XXX to trace trace_message_XXX

Location:

tools

Files:

• traceanon/traceanon_parallel.c (modified) (3 diffs)
• tracertstats/tracertstats_parallel.c (modified) (5 diffs)
• tracestats/tracestats_parallel.c (modified) (2 diffs)

tools/traceanon/traceanon_parallel.c

@@ -161 +161 @@
         libtrace_udp_t *udp = NULL;
         libtrace_tcp_t *tcp = NULL;
-
+        libtrace_stat_t *stats = NULL;
         switch (mesg) {
         case MESSAGE_PACKET:
@@ -199 +199 @@
                 enc_init(enc_type,key);
                 break;
-        case MESSAGE_TICK:
-                trace_publish_result(trace, t, data.uint64, (libtrace_generic_t){0}, RESULT_TICK);
+        case MESSAGE_TICK_INTERVAL:
+                trace_publish_result(trace, t, data.uint64, (libtrace_generic_t){0}, RESULT_TICK_INTERVAL);
+                break;
+        case MESSAGE_TICK_COUNT:
+                trace_publish_result(trace, t, data.uint64, (libtrace_generic_t){0}, RESULT_TICK_COUNT);
+                break;
+        case MESSAGE_STOPPING:
+                stats = trace_create_statistics();
+                trace_get_thread_statistics(trace, t, stats);
+                trace_print_statistics(stats, stderr, NULL);
+                free(stats);
+                stats = trace_get_statistics(trace, NULL);
+                trace_print_statistics(stats, stderr, NULL);
+                //fprintf(stderr, "tracestats_parallel:\t Stopping thread - publishing results\n");
                 break;
         }
@@ -216 +228 @@
         case MESSAGE_RESULT:
                 if (data.res->type == RESULT_PACKET) {
-                        libtrace_packet_t *packet = (libtrace_packet_t*) libtrace_result_get_value(data.res).pkt;
-                        assert(libtrace_result_get_key(data.res) == packet_count++);
+                        libtrace_packet_t *packet = (libtrace_packet_t*) data.res->value.pkt;
+                        assert(data.res->key >= packet_count);
+                        packet_count = data.res->key;
                         if (trace_write_packet(writer,packet)==-1) {
                                 trace_perror_output(writer,"writer");
                                 trace_interrupt();
                         }
-                        trace_free_result_packet(trace, packet);
+                        trace_free_packet(trace, packet);
 
                 } else {
-                        assert(data.res->type == RESULT_TICK);
+                        assert(data.res->type == RESULT_TICK_COUNT || data.res->type == RESULT_TICK_INTERVAL);
                         // Ignore it
                 }

tools/tracertstats/tracertstats_parallel.c

@@ -147 +147 @@
         switch (mesg) {
                 case MESSAGE_RESULT:
-                ts = libtrace_result_get_key(data.res);
-                res = libtrace_result_get_value(data.res).ptr;
+                ts = data.res->key;
+                res = data.res->value.ptr;
                 if (last_ts == 0)
                         last_ts = ts;
@@ -195 +195 @@
                         // Publish and make a new one new
                         //fprintf(stderr, "Publishing result %"PRIu64"\n", last_ts);
-                        trace_publish_result(trace, t, (uint64_t) last_ts, tmp, RESULT_NORMAL);
+                        trace_publish_result(trace, t, (uint64_t) last_ts, tmp, RESULT_USER);
                         trace_post_reporter(trace);
                         results = calloc(1, sizeof(result_t) + sizeof(statistic_t) * filter_count);
@@ -225 +225 @@
                 if (results->total.count) {
                         libtrace_generic_t tmp = {.ptr = results};
-                        trace_publish_result(trace, t, (uint64_t) last_ts, tmp, RESULT_NORMAL);
+                        trace_publish_result(trace, t, (uint64_t) last_ts, tmp, RESULT_USER);
                         trace_post_reporter(trace);
                         results = NULL;
@@ -231 +231 @@
                 break;
 
-                case MESSAGE_TICK:
+        case MESSAGE_TICK_INTERVAL:
+        case MESSAGE_TICK_COUNT:
                 {
                         int64_t offset;
                         struct timeval *tv, tv_real;
                         libtrace_packet_t *first_packet = NULL;
-                        retrive_first_packet(trace, &first_packet, &tv);
+                        trace_get_first_packet(trace, NULL, &first_packet, &tv);
                         if (first_packet != NULL) {
                                 // So figure out our running offset
@@ -247 +248 @@
                                         libtrace_generic_t tmp = {.ptr = results};
                                         //fprintf(stderr, "Got a tick and publishing early!!\n");
-                                        trace_publish_result(trace, t, (uint64_t) last_ts, tmp, RESULT_NORMAL);
+                                        trace_publish_result(trace, t, (uint64_t) last_ts, tmp, RESULT_USER);
                                         trace_post_reporter(trace);
                                         results = calloc(1, sizeof(result_t) + sizeof(statistic_t) * filter_count);

tools/tracestats/tracestats_parallel.c

@@ -139 +139 @@
                 trace_print_statistics(stats, stderr, NULL);
                 free(stats);
-                trace_publish_result(trace, t, 0, (libtrace_generic_t){.ptr = results}, RESULT_NORMAL); // Only ever using a single key 0
+                trace_publish_result(trace, t, 0, (libtrace_generic_t){.ptr = results}, RESULT_USER); // Only ever using a single key 0
                 //fprintf(stderr, "tracestats_parallel:\t Stopping thread - publishing results\n");
                 break;
@@ -168 +168 @@
         case MESSAGE_RESULT:
                 /* Get the results from each core and sum 'em up */
-                assert(libtrace_result_get_key(data.res) == 0);
-                statistics_t * res = libtrace_result_get_value(data.res).ptr;
+                assert(data.res->key == 0);
+                statistics_t * res = data.res->value.ptr;
                 count += res[0].count;
                 bytes += res[0].bytes;