Changeset 62b3c4e for test


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.

Location:
test
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • 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}
Note: See TracChangeset for help on using the changeset viewer.