Changeset 62b3c4e


Ignore:
Timestamp:
03/05/15 15:44:30 (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:
ab3fa18
Parents:
b023181
Message:

Update the reporter method to match with the per_pkt method.

We now treat a result as a type of message.

Files:
14 edited

Legend:

Unmodified
Added
Removed
  • lib/combiner_ordered.c

    rd994324 r62b3c4e  
    6060                /* Get the minimum queue and then do stuff */
    6161                libtrace_result_t r;
     62                libtrace_generic_t gt = {.res = &r};
    6263
    6364                ASSERT_RET (libtrace_deque_pop_front(&queues[min_queue], (void *) &r), == 1);
    64                 trace->reporter(trace, &r, NULL);
     65                trace->reporter(trace, MESSAGE_RESULT, gt, &trace->reporter_thread);
    6566
    6667                // We expect the key we read +1 now , todo put expected in our storage area
  • lib/combiner_sorted.c

    rd994324 r62b3c4e  
    5858        for (a = 0; a < libtrace_vector_get_size(&queues[0]); ++a) {
    5959                libtrace_result_t r;
    60                 ASSERT_RET (libtrace_vector_get(&queues[0], a,  (void *) &r), == 1);
    61                 trace->reporter(trace, &r, NULL);
     60                libtrace_generic_t gt = {.res = &r};
     61                ASSERT_RET (libtrace_vector_get(&queues[0], a, (void *) &r), == 1);
     62                trace->reporter(trace, MESSAGE_RESULT, gt, &trace->reporter_thread);
    6263        }
    6364        libtrace_vector_empty(&queues[0]);
  • lib/combiner_unordered.c

    rd994324 r62b3c4e  
    3434                while (libtrace_deque_get_size(v) != 0) {
    3535                        libtrace_result_t r;
     36                        libtrace_generic_t gt = {.res = &r};
    3637                        ASSERT_RET (libtrace_deque_pop_front(v, (void *) &r), == 1);
    37                         trace->reporter(trace, &r, NULL);
     38                        trace->reporter(trace, MESSAGE_RESULT, gt, &trace->reporter_thread);
    3839                }
    3940        }
  • lib/libtrace.h.in

    r0ec8a7c r62b3c4e  
    34613461/*@}*/
    34623462
     3463typedef struct libtrace_result_t libtrace_result_t;
    34633464/**
    34643465 * A collection of types for convenience used in place of a
     
    34713472        void *ptr;
    34723473        libtrace_packet_t *pkt;
     3474        libtrace_result_t *res;
    34733475
    34743476        /* C99 Integer types */
     
    35173519
    35183520/** Structure holding information about a result */
    3519 typedef struct libtrace_result_t {
     3521struct libtrace_result_t {
    35203522        uint64_t key;
    35213523        libtrace_generic_t value;
    35223524        int type;
    3523 } libtrace_result_t;
     3525};
    35243526#define RESULT_NORMAL 0
    35253527#define RESULT_PACKET 1
     
    35463548                            libtrace_generic_t data,
    35473549                            libtrace_thread_t *sender);
    3548 typedef void (*fn_reporter)(libtrace_t* trace, libtrace_result_t *r, libtrace_message_t *m);
     3550typedef void (*fn_reporter)(libtrace_t* trace,
     3551                            int mesg_code,
     3552                            libtrace_generic_t data,
     3553                            libtrace_thread_t *sender);
    35493554typedef uint64_t (*fn_hasher)(const libtrace_packet_t* packet, void *data);
    35503555
     
    36193624enum libtrace_messages {
    36203625        MESSAGE_PACKET,
     3626        MESSAGE_RESULT,
    36213627        MESSAGE_STARTING,
    36223628        MESSAGE_RESUMING,
  • lib/trace_parallel.c

    r0ec8a7c r62b3c4e  
    10351035        ASSERT_RET(pthread_mutex_unlock(&trace->libtrace_lock), == 0);
    10361036
    1037         message.code = MESSAGE_STARTING;
    1038         message.sender = t;
    1039         (*trace->reporter)(trace, NULL, &message);
    1040         message.code = MESSAGE_RESUMING;
    1041         (*trace->reporter)(trace, NULL, &message);
     1037        (*trace->reporter)(trace, MESSAGE_STARTING, (libtrace_generic_t) {0}, t);
     1038        (*trace->reporter)(trace, MESSAGE_RESUMING, (libtrace_generic_t) {0}, t);
    10421039
    10431040        while (!trace_finished(trace)) {
     
    10561053                                assert(trace->combiner.pause);
    10571054                                trace->combiner.pause(trace, &trace->combiner);
    1058                                 message.code = MESSAGE_PAUSING;
    1059                                 message.sender = t;
    1060                                 (*trace->reporter)(trace, NULL, &message);
     1055                                (*trace->reporter)(trace, MESSAGE_PAUSING, (libtrace_generic_t) {0}, t);
    10611056                                trace_thread_pause(trace, t);
    1062                                 message.code = MESSAGE_RESUMING;
    1063                                 (*trace->reporter)(trace, NULL, &message);
     1057                                (*trace->reporter)(trace, MESSAGE_RESUMING, (libtrace_generic_t) {0}, t);
    10641058                                break;
    1065                         default:
    1066                                 (*trace->reporter)(trace, NULL, &message);
     1059                default:
     1060                        (*trace->reporter)(trace, message.code, message.additional, message.sender);
    10671061                }
    10681062        }
     
    10721066
    10731067        // GOODBYE
    1074         message.code = MESSAGE_PAUSING;
    1075         message.sender = t;
    1076         (*trace->reporter)(trace, NULL, &message);
    1077         message.code = MESSAGE_STOPPING;
    1078         (*trace->reporter)(trace, NULL, &message);
     1068        (*trace->reporter)(trace, MESSAGE_PAUSING, (libtrace_generic_t) {0}, t);
     1069        (*trace->reporter)(trace, MESSAGE_STOPPING, (libtrace_generic_t) {0}, t);
    10791070
    10801071        thread_change_state(trace, &trace->reporter_thread, THREAD_FINISHED, true);
  • test/test-format-parallel-hasher.c

    r98dc1ba r62b3c4e  
    101101static int totalpkts = 0;
    102102static int expected;
    103 static void report_result(libtrace_t *trace, libtrace_result_t *result, libtrace_message_t *mesg) {
     103static void report_result(libtrace_t *trace UNUSED, int mesg,
     104                          libtrace_generic_t data,
     105                          libtrace_thread_t *sender UNUSED) {
    104106        static int totalthreads = 0;
    105         if (result) {
    106                 assert(libtrace_result_get_key(result) == 0);
    107                 printf("%d,", libtrace_result_get_value(result).sint);
     107        switch (mesg) {
     108        case MESSAGE_RESULT:
     109                assert(libtrace_result_get_key(data.res) == 0);
     110                printf("%d,", libtrace_result_get_value(data.res).sint);
    108111                totalthreads++;
    109                 totalpkts += libtrace_result_get_value(result).sint;
    110                 assert(libtrace_result_get_value(result).sint == 25 ||
    111                         libtrace_result_get_value(result).sint == expected - 25);
    112         } else {
    113                 switch(mesg->code) {
    114                         case MESSAGE_STARTING:
    115                                 // Should have two threads here
    116                                 assert(libtrace_get_perpkt_count(trace) == 2);
    117                                 printf("\tLooks like %d threads are being used!\n\tcounts(", libtrace_get_perpkt_count(trace));
    118                                 break;
    119                         case MESSAGE_STOPPING:
    120                                 printf(")\n");
    121                                 assert(totalthreads == libtrace_get_perpkt_count(trace));
    122                                 break;
    123                 }
     112                totalpkts += libtrace_result_get_value(data.res).sint;
     113                assert(libtrace_result_get_value(data.res).sint == 25 ||
     114                        libtrace_result_get_value(data.res).sint == expected - 25);
     115                break;
     116        case MESSAGE_STARTING:
     117                // Should have two threads here
     118                assert(libtrace_get_perpkt_count(trace) == 2);
     119                printf("\tLooks like %d threads are being used!\n\tcounts(", libtrace_get_perpkt_count(trace));
     120                break;
     121        case MESSAGE_STOPPING:
     122                printf(")\n");
     123                assert(totalthreads == libtrace_get_perpkt_count(trace));
     124                break;
    124125        }
    125126}
  • test/test-format-parallel-reporter.c

    r98dc1ba r62b3c4e  
    9494int globalcount = 0;
    9595
    96 static void reporter(libtrace_t *libtrace, libtrace_result_t *res, libtrace_message_t *mesg) {
     96static void reporter(libtrace_t *libtrace UNUSED, int mesg,
     97                     libtrace_generic_t data,
     98                     libtrace_thread_t *sender UNUSED) {
    9799        static uint64_t last = -1;
    98100        static int pktcount = 0;
    99         if (res) {
    100                 libtrace_packet_t *packet = libtrace_result_get_value(res).pkt;
    101                 assert(libtrace_result_get_key(res) == trace_packet_get_order(packet));
     101        libtrace_packet_t *packet;
     102        switch (mesg) {
     103        case MESSAGE_RESULT:
     104                packet = libtrace_result_get_value(data.res).pkt;
     105                assert(libtrace_result_get_key(data.res) == trace_packet_get_order(packet));
    102106                if(last == (uint64_t)-1) {
    103                         last = libtrace_result_get_key(res);
     107                        last = libtrace_result_get_key(data.res);
    104108                } else {
    105                 assert (last < libtrace_result_get_key(res));
    106                 last = libtrace_result_get_key(res);
     109                assert (last < libtrace_result_get_key(data.res));
     110                last = libtrace_result_get_key(data.res);
    107111                }
    108112                pktcount++;
    109113                trace_free_result_packet(libtrace, packet);
    110         } else {
    111                 // Mesg
    112                 switch (mesg->code) {
    113                 case MESSAGE_STOPPING:
    114                         globalcount = pktcount;
    115                 default:
    116                         break;
    117                 }
     114                break;
     115        case MESSAGE_STOPPING:
     116                globalcount = pktcount;
     117                break;
    118118        }
    119119}
  • test/test-format-parallel-singlethreaded-hasher.c

    r98dc1ba r62b3c4e  
    102102static int totalpkts = 0;
    103103static int expected;
    104 static void report_result(libtrace_t *trace, libtrace_result_t *result, libtrace_message_t *mesg) {
     104static void report_result(libtrace_t *trace UNUSED, int mesg,
     105                          libtrace_generic_t data,
     106                          libtrace_thread_t *sender UNUSED) {
    105107        static int totalthreads = 0;
    106         if (result) {
    107                 assert(libtrace_result_get_key(result) == 0);
    108                 printf("%d,", libtrace_result_get_value(result).sint);
     108        switch (mesg) {
     109        case MESSAGE_RESULT:
     110                assert(libtrace_result_get_key(data.res) == 0);
     111                printf("%d,", libtrace_result_get_value(data.res).sint);
    109112                totalthreads++;
    110                 totalpkts += libtrace_result_get_value(result).sint;
    111         } else {
    112                 switch(mesg->code) {
    113                         case MESSAGE_STARTING:
    114                                 // Should have a single thread here
    115                                 assert(libtrace_get_perpkt_count(trace) == 1);
    116                                 printf("\tLooks like %d threads are being used!\n\tcounts(", libtrace_get_perpkt_count(trace));
    117                                 break;
    118                         case MESSAGE_STOPPING:
    119                                 printf(")\n");
    120                                 assert(totalthreads == libtrace_get_perpkt_count(trace));
    121                                 break;
    122                 }
     113                totalpkts += libtrace_result_get_value(data.res).sint;
     114                break;
     115        case MESSAGE_STARTING:
     116                // Should have a single thread here
     117                assert(libtrace_get_perpkt_count(trace) == 1);
     118                printf("\tLooks like %d threads are being used!\n\tcounts(", libtrace_get_perpkt_count(trace));
     119                break;
     120        case MESSAGE_STOPPING:
     121                printf(")\n");
     122                assert(totalthreads == libtrace_get_perpkt_count(trace));
     123                break;
    123124        }
    124125}
  • test/test-format-parallel-singlethreaded.c

    r98dc1ba r62b3c4e  
    101101
    102102static int totalpkts = 0;
    103 static void report_result(libtrace_t *trace, libtrace_result_t *result, libtrace_message_t *mesg) {
     103static void report_result(libtrace_t *trace UNUSED, int mesg,
     104                          libtrace_generic_t data,
     105                          libtrace_thread_t *sender UNUSED) {
    104106        static int totalthreads = 0;
    105         if (result) {
    106                 assert(libtrace_result_get_key(result) == 0);
    107                 printf("%d,", libtrace_result_get_value(result).sint);
     107        switch (mesg) {
     108        case MESSAGE_RESULT:
     109                assert(libtrace_result_get_key(data.res) == 0);
     110                printf("%d,", libtrace_result_get_value(data.res).sint);
    108111                totalthreads++;
    109                 totalpkts += libtrace_result_get_value(result).sint;
    110         } else {
    111                 switch(mesg->code) {
    112                         case MESSAGE_STARTING:
    113                                 // Should have a single thread here
    114                                 assert(libtrace_get_perpkt_count(trace) == 1);
    115                                 printf("\tLooks like %d threads are being used!\n\tcounts(", libtrace_get_perpkt_count(trace));
    116                                 break;
    117                         case MESSAGE_STOPPING:
    118                                 printf(")\n");
    119                                 assert(totalthreads == libtrace_get_perpkt_count(trace));
    120                                 break;
    121                 }
     112                totalpkts += libtrace_result_get_value(data.res).sint;
     113                break;
     114        case MESSAGE_STARTING:
     115                // Should have a single thread here
     116                assert(libtrace_get_perpkt_count(trace) == 1);
     117                printf("\tLooks like %d threads are being used!\n\tcounts(", libtrace_get_perpkt_count(trace));
     118                break;
     119        case MESSAGE_STOPPING:
     120                printf(")\n");
     121                assert(totalthreads == libtrace_get_perpkt_count(trace));
     122                break;
    122123        }
    123124}
  • test/test-format-parallel-stressthreads.c

    re7d3bdc r62b3c4e  
    101101
    102102static int totalpkts = 0;
    103 static void report_result(libtrace_t *trace, libtrace_result_t *result, libtrace_message_t *mesg) {
     103static void report_result(libtrace_t *trace UNUSED, int mesg,
     104                          libtrace_generic_t data,
     105                          libtrace_thread_t *sender UNUSED) {
    104106        static int totalthreads = 0;
    105         if (result) {
    106                 assert(libtrace_result_get_key(result) == 0);
    107                 printf("%d,", libtrace_result_get_value(result).sint);
     107        switch (mesg) {
     108        case MESSAGE_RESULT:
     109                assert(libtrace_result_get_key(data.res) == 0);
     110                printf("%d,", libtrace_result_get_value(data.res).sint);
    108111                totalthreads++;
    109                 totalpkts += libtrace_result_get_value(result).sint;
    110         } else {
    111                 switch(mesg->code) {
    112                         case MESSAGE_STARTING:
    113                                 // Should have a single thread here
    114                                 assert(libtrace_get_perpkt_count(trace) == 100);
    115                                 printf("\tLooks like %d threads are being used!\n\tcounts(", libtrace_get_perpkt_count(trace));
    116                                 break;
    117                         case MESSAGE_STOPPING:
    118                                 printf(")\n");
    119                                 assert(totalthreads == libtrace_get_perpkt_count(trace));
    120                                 break;
    121                 }
     112                totalpkts += libtrace_result_get_value(data.res).sint;
     113                break;
     114        case MESSAGE_STARTING:
     115                // Should have a single thread here
     116                assert(libtrace_get_perpkt_count(trace) == 100);
     117                printf("\tLooks like %d threads are being used!\n\tcounts(", libtrace_get_perpkt_count(trace));
     118                break;
     119        case MESSAGE_STOPPING:
     120                printf(")\n");
     121                assert(totalthreads == libtrace_get_perpkt_count(trace));
     122                break;
    122123        }
    123124}
  • test/test-format-parallel.c

    r98dc1ba r62b3c4e  
    100100
    101101static int totalpkts = 0;
    102 static void report_result(libtrace_t *trace, libtrace_result_t *result, libtrace_message_t *mesg) {
     102static void report_result(libtrace_t *trace UNUSED, int mesg,
     103                          libtrace_generic_t data,
     104                          libtrace_thread_t *sender UNUSED) {
    103105        static int totalthreads = 0;
    104         if (result) {
    105                 assert(libtrace_result_get_key(result) == 0);
    106                 printf("%d,", libtrace_result_get_value(result).sint);
     106        switch (mesg) {
     107        case MESSAGE_RESULT:
     108                assert(libtrace_result_get_key(data.res) == 0);
     109                printf("%d,", libtrace_result_get_value(data.res).sint);
    107110                totalthreads++;
    108                 totalpkts += libtrace_result_get_value(result).sint;
    109         } else {
    110                 switch(mesg->code) {
    111                         case MESSAGE_STARTING:
    112                                 printf("\tLooks like %d threads are being used!\n\tcounts(", libtrace_get_perpkt_count(trace));
    113                                 break;
    114                         case MESSAGE_STOPPING:
    115                                 printf(")\n");
    116                                 assert(totalthreads == libtrace_get_perpkt_count(trace));
    117                                 break;
    118                 }
     111                totalpkts += libtrace_result_get_value(data.res).sint;
     112                break;
     113        case MESSAGE_STARTING:
     114                printf("\tLooks like %d threads are being used!\n\tcounts(", libtrace_get_perpkt_count(trace));
     115                break;
     116        case MESSAGE_STOPPING:
     117                printf(")\n");
     118                assert(totalthreads == libtrace_get_perpkt_count(trace));
     119                break;
    119120        }
    120121}
  • tools/traceanon/traceanon_parallel.c

    r0ec8a7c r62b3c4e  
    208208struct libtrace_out_t *writer = 0;
    209209
    210 static void write_out(libtrace_t *trace, libtrace_result_t *result, UNUSED libtrace_message_t *mesg) {
     210static void write_out(libtrace_t *trace UNUSED, int mesg,
     211                      libtrace_generic_t data,
     212                      libtrace_thread_t *sender UNUSED) {
    211213        static uint64_t packet_count = 0; // TESTING PURPOSES, this is not going to work with a live format
    212214
    213         if (result) {
    214                 if (result->type == RESULT_PACKET) {
    215                         libtrace_packet_t *packet = (libtrace_packet_t*) libtrace_result_get_value(result).pkt;
    216                         assert(libtrace_result_get_key(result) == packet_count++);
     215        switch (mesg) {
     216        case MESSAGE_RESULT:
     217                if (data.res->type == RESULT_PACKET) {
     218                        libtrace_packet_t *packet = (libtrace_packet_t*) libtrace_result_get_value(data.res).pkt;
     219                        assert(libtrace_result_get_key(data.res) == packet_count++);
    217220                        if (trace_write_packet(writer,packet)==-1) {
    218221                                trace_perror_output(writer,"writer");
     
    222225
    223226                } else {
    224                         assert(result->type == RESULT_TICK);
     227                        assert(data.res->type == RESULT_TICK);
    225228                        // Ignore it
    226229                }
  • tools/tracertstats/tracertstats_parallel.c

    rb023181 r62b3c4e  
    138138
    139139static uint64_t last_ts = 0;
    140 static void process_result(libtrace_t *trace UNUSED, libtrace_result_t *result, libtrace_message_t *mesg UNUSED)  {
     140static void process_result(libtrace_t *trace UNUSED, int mesg,
     141                           libtrace_generic_t data,
     142                           libtrace_thread_t *sender UNUSED) {
    141143        static uint64_t ts = 0;
    142 
    143         if (result) {
    144                 int j;
    145                 result_t *res;
    146                 ts = libtrace_result_get_key(result);
    147                 res = libtrace_result_get_value(result).ptr;
     144        int j;
     145        result_t *res;
     146
     147        switch (mesg) {
     148                case MESSAGE_RESULT:
     149                ts = libtrace_result_get_key(data.res);
     150                res = libtrace_result_get_value(data.res).ptr;
    148151                if (last_ts == 0)
    149152                        last_ts = ts;
     
    274277                return;
    275278
    276         trace = trace_create(uri);
     279        trace = trace_create(uri);
    277280        if (trace_is_err(trace)) {
    278281                trace_perror(trace,"trace_create");
     
    291294        }*/
    292295        int i = 1;
    293         trace_set_combiner(trace, &combiner_ordered, (libtrace_generic_types_t){0});
     296        trace_set_combiner(trace, &combiner_ordered, (libtrace_generic_t){0});
    294297        /* trace_parallel_config(trace, TRACE_OPTION_TRACETIME, &i); */
    295298        //trace_set_hasher(trace, HASHER_CUSTOM, &bad_hash, NULL);
  • tools/tracestats/tracestats_parallel.c

    r0ec8a7c r62b3c4e  
    105105static void* per_packet(libtrace_t *trace, libtrace_thread_t *t,
    106106                        int mesg, libtrace_generic_t data,
    107                         libtrace_thread_t *sender)
     107                        libtrace_thread_t *sender UNUSED)
    108108{
    109109        // Using first entry as total and those after for filter counts
     
    158158}
    159159
    160 static void report_result(libtrace_t *trace UNUSED, libtrace_result_t *result, libtrace_message_t *mesg) {
     160static void report_result(libtrace_t *trace UNUSED, int mesg,
     161                          libtrace_generic_t data,
     162                          libtrace_thread_t *sender UNUSED) {
    161163        static uint64_t count=0, bytes=0;
    162         uint64_t packets;
    163164        int i;
    164         if (result) {
    165                 int j;
     165        libtrace_stat_t *stats;
     166
     167        switch (mesg) {
     168        case MESSAGE_RESULT:
    166169                /* Get the results from each core and sum 'em up */
    167                 assert(libtrace_result_get_key(result) == 0);
    168                 statistics_t * res = libtrace_result_get_value(result).ptr;
     170                assert(libtrace_result_get_key(data.res) == 0);
     171                statistics_t * res = libtrace_result_get_value(data.res).ptr;
    169172                count += res[0].count;
    170173                bytes += res[0].bytes;
    171                 for (j = 0; j < filter_count; j++) {
    172                         filters[j].count += res[j+1].count;
    173                         filters[j].bytes += res[j+1].bytes;
     174                for (i = 0; i < filter_count; i++) {
     175                        filters[i].count += res[i+1].count;
     176                        filters[i].bytes += res[i+1].bytes;
    174177                }
    175178                free(res);
    176         } else switch (mesg->code) {
    177                 libtrace_stat_t *stats;
    178                 case MESSAGE_STOPPING:
    179                         stats = trace_get_statistics(trace, NULL);
    180                         printf("%-30s\t%12s\t%12s\t%7s\n","filter","count","bytes","%");
    181                         for(i=0;i<filter_count;++i) {
    182                                 printf("%30s:\t%12"PRIu64"\t%12"PRIu64"\t%7.03f\n",filters[i].expr,filters[i].count,filters[i].bytes,filters[i].count*100.0/count);
    183                                 filters[i].bytes=0;
    184                                 filters[i].count=0;
    185                         }
    186                         if (stats->received_valid)
    187                                 fprintf(stderr,"%30s:\t%12" PRIu64"\n",
    188                                                 "Input packets", stats->received);
    189                         if (stats->filtered_valid)
    190                                 fprintf(stderr,"%30s:\t%12" PRIu64"\n",
    191                                                 "Filtered packets", stats->filtered);
    192                         if (stats->dropped_valid)
    193                                 fprintf(stderr,"%30s:\t%12" PRIu64"\n",
    194                                                 "Dropped packets",stats->dropped);
    195                         if (stats->accepted_valid)
    196                                 fprintf(stderr,"%30s:\t%12" PRIu64 "\n",
    197                                                 "Accepted packets", stats->accepted);
    198                         if (stats->errors_valid)
    199                                 fprintf(stderr,"%30s:\t%12" PRIu64 "\n",
    200                                                 "Erred packets", stats->errors);
    201                         printf("%30s:\t%12"PRIu64"\t%12" PRIu64 "\n","Total",count,bytes);
    202                         totcount+=count;
    203                         totbytes+=bytes;
    204         }
    205 }
    206 
    207 static uint64_t rand_hash(libtrace_packet_t * pkt, void *data) {
     179                break;
     180        case MESSAGE_STOPPING:
     181                stats = trace_get_statistics(trace, NULL);
     182                printf("%-30s\t%12s\t%12s\t%7s\n","filter","count","bytes","%");
     183                for(i=0;i<filter_count;++i) {
     184                        printf("%30s:\t%12"PRIu64"\t%12"PRIu64"\t%7.03f\n",filters[i].expr,filters[i].count,filters[i].bytes,filters[i].count*100.0/count);
     185                        filters[i].bytes=0;
     186                        filters[i].count=0;
     187                }
     188                if (stats->received_valid)
     189                        fprintf(stderr,"%30s:\t%12" PRIu64"\n",
     190                                "Input packets", stats->received);
     191                if (stats->filtered_valid)
     192                        fprintf(stderr,"%30s:\t%12" PRIu64"\n",
     193                                "Filtered packets", stats->filtered);
     194                if (stats->dropped_valid)
     195                        fprintf(stderr,"%30s:\t%12" PRIu64"\n",
     196                                "Dropped packets",stats->dropped);
     197                if (stats->accepted_valid)
     198                        fprintf(stderr,"%30s:\t%12" PRIu64 "\n",
     199                                "Accepted packets", stats->accepted);
     200                if (stats->errors_valid)
     201                        fprintf(stderr,"%30s:\t%12" PRIu64 "\n",
     202                                "Erred packets", stats->errors);
     203                printf("%30s:\t%12"PRIu64"\t%12" PRIu64 "\n","Total",count,bytes);
     204                totcount+=count;
     205                totbytes+=bytes;
     206        }
     207}
     208
     209static uint64_t rand_hash(libtrace_packet_t * pkt UNUSED, void *data UNUSED) {
    208210        return rand();
    209211}
    210212
    211 static uint64_t bad_hash(libtrace_packet_t * pkt, void *data) {
     213static uint64_t bad_hash(libtrace_packet_t * pkt UNUSED, void *data UNUSED) {
    212214        return 0;
    213215}
     
    234236        //trace_parallel_config(trace, TRACE_OPTION_SET_PERPKT_THREAD_COUNT, &option);
    235237        trace_parallel_config(trace, TRACE_OPTION_SET_CONFIG, &uc);
    236         trace_set_combiner(trace, &combiner_ordered, (libtrace_generic_types_t){0});
     238        trace_set_combiner(trace, &combiner_ordered, (libtrace_generic_t){0});
    237239
    238240        //trace_parallel_config(trace, TRACE_OPTION_SET_MAPPER_BUFFER_SIZE, &option);
Note: See TracChangeset for help on using the changeset viewer.