Changeset 0ec8a7c for tools/tracertstats


Ignore:
Timestamp:
02/27/15 17:31:03 (6 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:
98dc1ba
Parents:
7718e54
Message:

Change the user interface from a message and a packet to only messages.

Now a packet is a type of message (MESSAGE_PACKET).
I expanded the message structure into seperate arguments such that these
will be passed in registers on x64 systems. As such performance has
remained identical if not better.

I renamed libtrace_generic_types_t to libtrace_generic_t so it was shorter.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • tools/tracertstats/tracertstats_parallel.c

    r2e22196d r0ec8a7c  
    171171} timestamp_sync_t;
    172172
    173 static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
    174                                                 libtrace_message_t *mesg,
    175                                                 libtrace_thread_t *t)
     173static void* per_packet(libtrace_t *trace, libtrace_thread_t *t,
     174                        int mesg, libtrace_generic_t data,
     175                        libtrace_thread_t *sender UNUSED)
    176176{
    177177        int i;
    178178        static __thread uint64_t last_ts = 0, ts = 0;
    179179        static __thread result_t * results = NULL;
    180         // Unsure when we would hit this case but the old code had it, I
    181         // guess we should keep it
    182         if (pkt && trace_get_packet_buffer(pkt,NULL,NULL) != NULL) {
    183                 //fprintf(stderr, "Got packet t=%x\n", t);
    184                 ts = trace_get_seconds(pkt) / packet_interval;
     180
     181        switch(mesg) {
     182        case MESSAGE_PACKET:
     183                // Unsure when we would hit this case but the old code had it, I
     184                // guess we should keep it
     185                assert(trace_get_packet_buffer(pkt,NULL,NULL) != NULL);
     186                ts = trace_get_seconds(data.pkt) / packet_interval;
    185187                if (last_ts == 0)
    186188                        last_ts = ts;
    187189
    188190                while (packet_interval != UINT64_MAX && last_ts<ts) {
     191                        libtrace_generic_t tmp = {.ptr = results};
    189192                        // Publish and make a new one new
    190193                        //fprintf(stderr, "Publishing result %"PRIu64"\n", last_ts);
    191                         trace_publish_result(trace, t, (uint64_t) last_ts, (libtrace_generic_types_t){.ptr = results}, RESULT_NORMAL);
     194                        trace_publish_result(trace, t, (uint64_t) last_ts, tmp, RESULT_NORMAL);
    192195                        trace_post_reporter(trace);
    193196                        results = calloc(1, sizeof(result_t) + sizeof(statistic_t) * filter_count);
    194197                        last_ts++;
    195198                }
    196                
     199
    197200                for(i=0;i<filter_count;++i) {
    198                         if(trace_apply_filter(filters[i].filter, pkt)) {
     201                        if(trace_apply_filter(filters[i].filter, data.pkt)) {
    199202                                results->filters[i].count++;
    200                                 results->filters[i].bytes+=trace_get_wire_length(pkt);
     203                                results->filters[i].bytes+=trace_get_wire_length(data.pkt);
    201204                        }
    202205                }
    203                
     206
    204207                results->total.count++;
    205                 results->total.bytes +=trace_get_wire_length(pkt);
     208                results->total.bytes +=trace_get_wire_length(data.pkt);
    206209                /*if (count >= packet_count) {
    207210                        report_results(ts,count,bytes);
     
    209212                        bytes=0;
    210213                }*/ // TODO what was happening here doesn't match up with any of the documentations!!!
    211         }
    212        
    213         if (mesg) {
    214                 // printf ("%d.%06d READ #%"PRIu64"\n", tv.tv_sec, tv.tv_usec, trace_packet_get(packet));
    215                 switch (mesg->code) {
    216                         case MESSAGE_STARTING:
    217                                 results = calloc(1, sizeof(result_t) + sizeof(statistic_t) * filter_count);
    218                                 break;
    219                         case MESSAGE_STOPPING:
    220                                 // Should we always post this?
    221                                 if (results->total.count) {
    222                                         trace_publish_result(trace, t, (uint64_t) last_ts, (libtrace_generic_types_t){.ptr = results}, RESULT_NORMAL);
     214                return data.pkt;
     215
     216        case MESSAGE_STARTING:
     217                results = calloc(1, sizeof(result_t) + sizeof(statistic_t) * filter_count);
     218                break;
     219
     220        case MESSAGE_STOPPING:
     221                // Should we always post this?
     222                if (results->total.count) {
     223                        libtrace_generic_t tmp = {.ptr = results};
     224                        trace_publish_result(trace, t, (uint64_t) last_ts, tmp, RESULT_NORMAL);
     225                        trace_post_reporter(trace);
     226                        results = NULL;
     227                }
     228                break;
     229
     230                case MESSAGE_TICK:
     231                {
     232                        int64_t offset;
     233                        struct timeval *tv, tv_real;
     234                        libtrace_packet_t *first_packet = NULL;
     235                        retrive_first_packet(trace, &first_packet, &tv);
     236                        if (first_packet != NULL) {
     237                                // So figure out our running offset
     238                                tv_real = trace_get_timeval(first_packet);
     239                                offset = tv_to_usec(tv) - tv_to_usec(&tv_real);
     240                                // Get time of day and do this stuff
     241                                uint64_t next_update_time;
     242                                next_update_time = (last_ts*packet_interval + packet_interval) * 1000000 + offset;
     243                                if (next_update_time <= data.uint64) {
     244                                        libtrace_generic_t tmp = {.ptr = results};
     245                                        //fprintf(stderr, "Got a tick and publishing early!!\n");
     246                                        trace_publish_result(trace, t, (uint64_t) last_ts, tmp, RESULT_NORMAL);
    223247                                        trace_post_reporter(trace);
    224                                         results = NULL;
     248                                        results = calloc(1, sizeof(result_t) + sizeof(statistic_t) * filter_count);
     249                                        last_ts++;
     250                                } else {
     251                                        //fprintf(stderr, "Got a tick but no publish ...\n");
    225252                                }
    226                                 break;
    227                         case MESSAGE_TICK:
    228                         {
    229                                 int64_t offset;
    230                                 struct timeval *tv, tv_real;
    231                                 libtrace_packet_t *first_packet = NULL;
    232                                 retrive_first_packet(trace, &first_packet, &tv);
    233                                 if (first_packet != NULL) {
    234                                         // So figure out our running offset
    235                                         tv_real = trace_get_timeval(first_packet);
    236                                         offset = tv_to_usec(tv) - tv_to_usec(&tv_real);
    237                                         // Get time of day and do this stuff
    238                                         uint64_t next_update_time;
    239                                         next_update_time = (last_ts*packet_interval + packet_interval) * 1000000 + offset;
    240                                         if (next_update_time <= mesg->additional.uint64) {
    241                                                 //fprintf(stderr, "Got a tick and publishing early!!\n");
    242                                                 trace_publish_result(trace, t, (uint64_t) last_ts, (libtrace_generic_types_t){.ptr = results}, RESULT_NORMAL);
    243                                                 trace_post_reporter(trace);
    244                                                 results = calloc(1, sizeof(result_t) + sizeof(statistic_t) * filter_count);
    245                                                 last_ts++;
    246                                         } else {
    247                                                 //fprintf(stderr, "Got a tick but no publish ...\n");
    248                                         }
    249                                 } else {
    250                                         //fprintf(stderr, "Got a tick but no packets seen yet!!!\n");
    251                                 }
     253                        } else {
     254                                //fprintf(stderr, "Got a tick but no packets seen yet!!!\n");
    252255                        }
    253256                }
    254257        }
    255         return pkt;
     258        return NULL;
    256259}
    257260
Note: See TracChangeset for help on using the changeset viewer.