Changeset 2498008 for test


Ignore:
Timestamp:
09/16/14 02:35:10 (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:
d994324
Parents:
50b1bee
Message:

Refactor the combining step to allow user defined functions here.

Remove the old trace_get_results, now instead simply provide a reporter function which gets called as soon as results are ready.
The combiner function used determines the order of these results and when they are released etc.
The combiner function can be selected from those built-in or a custom version can be defined results are provided when ready.
Quickly hacked the parallel tests to work with this update, these are still a bit messy.

Also some fixes some compile warnings.

Location:
test
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • test/test-format-parallel-hasher.c

    rf051c1b r2498008  
    9999        int count;
    100100};
    101 int x;
    102 
     101
     102static int totalpkts = 0;
     103static int expected;
     104static void report_result(libtrace_t *trace, libtrace_result_t *result, libtrace_message_t *mesg) {
     105        static int totalthreads = 0;
     106        if (result) {
     107                assert(libtrace_result_get_key(result) == 0);
     108                printf("%d,", (int) libtrace_result_get_value(result));
     109                totalthreads++;
     110                totalpkts += (int) libtrace_result_get_value(result);
     111                assert(libtrace_result_get_value(result) == 25 ||
     112                        libtrace_result_get_value(result) == expected - 25);
     113        } else {
     114                switch(mesg->code) {
     115                        case MESSAGE_STARTING:
     116                                // Should have two threads here
     117                                assert(libtrace_get_perpkt_count(trace) == 2);
     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;
     124                }
     125        }
     126}
     127
     128static int x;
    103129static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
    104130                                                libtrace_message_t *mesg,
     
    177203 * Test that the hasher function works
    178204 */
    179 int test_hasher(const char *tracename, int expected) {
     205int test_hasher(const char *tracename) {
    180206        libtrace_t *trace;
    181207        int error = 0;
    182         int count = 0;
    183208        int i;
    184209        int hashercount = 0;
     
    195220
    196221        // Start it
    197         trace_pstart(trace, NULL, per_packet, NULL);
     222        trace_pstart(trace, NULL, per_packet, report_result);
    198223        iferr(trace,tracename);
    199224        /* Make sure traces survive a pause and restart */
     
    205230        /* Wait for all threads to stop */
    206231        trace_join(trace);
    207         libtrace_vector_t results;
    208 
    209         /* Now lets check the results */
    210         libtrace_vector_init(&results, sizeof(libtrace_result_t));
    211         trace_get_results(trace, &results);
    212         // Should have two results/threads here
    213         assert(libtrace_vector_get_size(&results) == 2);
    214         for (i = 0; i < libtrace_vector_get_size(&results); i++) {
    215                 int ret;
    216                 libtrace_result_t result;
    217                 ret = libtrace_vector_get(&results, i, (void *) &result);
    218                 assert(ret == 1);
    219                 assert(libtrace_result_get_key(&result) == 0);
    220                 count += (int) libtrace_result_get_value(&result);
    221                 printf("%d,", (int) libtrace_result_get_value(&result));
    222                
    223         }
    224         printf(")\n");
    225         for (i = 0; i < libtrace_vector_get_size(&results); i++) {
    226                 int ret;
    227                 libtrace_result_t result;
    228                 ret = libtrace_vector_get(&results, i, (void *) &result);
    229                 assert(libtrace_result_get_value(&result) == 25 ||
    230                         libtrace_result_get_value(&result) == expected - 25);
    231         }
    232         libtrace_vector_destroy(&results);
    233 
     232
     233        /* Now check we have all received all the packets */
    234234        if (error == 0) {
    235                 if (count == expected) {
     235                if (totalpkts == expected) {
    236236                        printf("success: %d packets read\n",expected);
    237237                } else {
    238                         printf("failure: %d packets expected, %d seen\n",expected,count);
     238                        printf("failure: %d packets expected, %d seen\n",expected,totalpkts);
    239239                        error = 1;
    240240                }
     
    250250int main(int argc, char *argv[]) {
    251251        int error = 0;
    252         int expected = 100;
    253252        const char *tracename;
     253        expected = 100;
    254254
    255255        if (argc<2) {
     
    262262        if (strcmp(argv[1],"rtclient")==0) expected=101;
    263263
    264         error = test_hasher(tracename, expected);
     264        error = test_hasher(tracename);
    265265
    266266    return error;
  • test/test-format-parallel-singlethreaded-hasher.c

    rf051c1b r2498008  
    9999        int count;
    100100};
    101 int x;
    102 
     101
     102static int totalpkts = 0;
     103static int expected;
     104static void report_result(libtrace_t *trace, libtrace_result_t *result, libtrace_message_t *mesg) {
     105        static int totalthreads = 0;
     106        if (result) {
     107                assert(libtrace_result_get_key(result) == 0);
     108                printf("%d,", (int) libtrace_result_get_value(result));
     109                totalthreads++;
     110                totalpkts += (int) libtrace_result_get_value(result);
     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                }
     123        }
     124}
     125
     126static int x;
    103127static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
    104128                                                libtrace_message_t *mesg,
     
    177201 * It might not be called but this ensures consistency
    178202 */
    179 int test_hasher_singlethreaded(const char *tracename, int expected) {
     203int test_hasher_singlethreaded(const char *tracename) {
    180204        libtrace_t *trace;
    181205        int error = 0;
    182         int count = 0;
    183206        int i;
    184207        int hashercount = 0;
     
    195218
    196219        // Start it
    197         trace_pstart(trace, NULL, per_packet, NULL);
     220        trace_pstart(trace, NULL, per_packet, report_result);
    198221        iferr(trace,tracename);
    199222
     
    206229        /* Wait for all threads to stop */
    207230        trace_join(trace);
    208         libtrace_vector_t results;
    209 
    210         /* Now lets check the results */
    211         libtrace_vector_init(&results, sizeof(libtrace_result_t));
    212         trace_get_results(trace, &results);
    213         // Should have one result/thread here
    214         assert(libtrace_vector_get_size(&results) == 1);
    215         for (i = 0; i < libtrace_vector_get_size(&results); i++) {
    216                 int ret;
    217                 libtrace_result_t result;
    218                 ret = libtrace_vector_get(&results, i, (void *) &result);
    219                 assert(ret == 1);
    220                 assert(libtrace_result_get_key(&result) == 0);
    221                 count += (int) libtrace_result_get_value(&result);
    222                 printf("%d,", (int) libtrace_result_get_value(&result));
    223         }
    224         printf(")\n");
    225         libtrace_vector_destroy(&results);
     231
     232        /* Now check we have all received all the packets */
    226233        if (error == 0) {
    227                 if (count == expected) {
     234                if (totalpkts == expected) {
    228235                        printf("success: %d packets read\n",expected);
    229236                } else {
    230                         printf("failure: %d packets expected, %d seen\n",expected,count);
     237                        printf("failure: %d packets expected, %d seen\n",expected,totalpkts);
    231238                        error = 1;
    232239                }
     
    241248int main(int argc, char *argv[]) {
    242249        int error = 0;
    243         int expected = 100;
    244250        const char *tracename;
     251        expected = 100;
    245252
    246253        if (argc<2) {
     
    253260        if (strcmp(argv[1],"rtclient")==0) expected=101;
    254261
    255         error = test_hasher_singlethreaded(tracename, expected);
     262        error = test_hasher_singlethreaded(tracename);
    256263    return error;
    257264}
  • test/test-format-parallel-singlethreaded.c

    rf051c1b r2498008  
    9999        int count;
    100100};
    101 int x;
    102 
     101
     102static int totalpkts = 0;
     103static void report_result(libtrace_t *trace, libtrace_result_t *result, libtrace_message_t *mesg) {
     104        static int totalthreads = 0;
     105        if (result) {
     106                assert(libtrace_result_get_key(result) == 0);
     107                printf("%d,", (int) libtrace_result_get_value(result));
     108                totalthreads++;
     109                totalpkts += (int) libtrace_result_get_value(result);
     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                }
     122        }
     123}
     124
     125static int x;
    103126static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
    104127                                                libtrace_message_t *mesg,
     
    167190        libtrace_t *trace;
    168191        int error = 0;
    169         int count = 0;
    170192        int i;
    171193        printf("Testing single threaded\n");
     
    180202
    181203        // Start it
    182         trace_pstart(trace, NULL, per_packet, NULL);
     204        trace_pstart(trace, NULL, per_packet, report_result);
    183205        iferr(trace,tracename);
    184206
     
    191213        /* Wait for all threads to stop */
    192214        trace_join(trace);
    193         libtrace_vector_t results;
    194 
    195         /* Now lets check the results */
    196         libtrace_vector_init(&results, sizeof(libtrace_result_t));
    197         trace_get_results(trace, &results);
    198         // Should have one result/thread here
    199         assert(libtrace_vector_get_size(&results) == 1);
    200         for (i = 0; i < libtrace_vector_get_size(&results); i++) {
    201                 int ret;
    202                 libtrace_result_t result;
    203                 ret = libtrace_vector_get(&results, i, (void *) &result);
    204                 assert(ret == 1);
    205                 assert(libtrace_result_get_key(&result) == 0);
    206                 count += (int) libtrace_result_get_value(&result);
    207                 printf("%d,", (int) libtrace_result_get_value(&result));
    208         }
    209         printf(")\n");
    210         libtrace_vector_destroy(&results);
    211 
     215
     216        /* Now check we have all received all the packets */
    212217        if (error == 0) {
    213                 if (count == expected) {
     218                if (totalpkts == expected) {
    214219                        printf("success: %d packets read\n",expected);
    215220                } else {
    216                         printf("failure: %d packets expected, %d seen\n",expected,count);
     221                        printf("failure: %d packets expected, %d seen\n",expected,totalpkts);
    217222                        error = 1;
    218223                }
  • test/test-format-parallel-stressthreads.c

    rf051c1b r2498008  
    9999        int count;
    100100};
    101 int x;
    102 
     101
     102static int totalpkts = 0;
     103static void report_result(libtrace_t *trace, libtrace_result_t *result, libtrace_message_t *mesg) {
     104        static int totalthreads = 0;
     105        if (result) {
     106                assert(libtrace_result_get_key(result) == 0);
     107                printf("%d,", (int) libtrace_result_get_value(result));
     108                totalthreads++;
     109                totalpkts += (int) libtrace_result_get_value(result);
     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                }
     122        }
     123}
     124
     125static int x;
    103126static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
    104127                                                libtrace_message_t *mesg,
     
    167190        libtrace_t *trace;
    168191        int error = 0;
    169         int count = 0;
    170192        int i;
    171193        printf("Testing single threaded\n");
     
    180202
    181203        // Start it
    182         trace_pstart(trace, NULL, per_packet, NULL);
     204        trace_pstart(trace, NULL, per_packet, report_result);
    183205        iferr(trace,tracename);
    184206
     
    191213        /* Wait for all threads to stop */
    192214        trace_join(trace);
    193         libtrace_vector_t results;
    194 
    195         /* Now lets check the results */
    196         libtrace_vector_init(&results, sizeof(libtrace_result_t));
    197         trace_get_results(trace, &results);
    198         // Should have 100 results/threads here
    199         assert(libtrace_vector_get_size(&results) == 100);
    200         for (i = 0; i < libtrace_vector_get_size(&results); i++) {
    201                 int ret;
    202                 libtrace_result_t result;
    203                 ret = libtrace_vector_get(&results, i, (void *) &result);
    204                 assert(ret == 1);
    205                 assert(libtrace_result_get_key(&result) == 0);
    206                 count += (int) libtrace_result_get_value(&result);
    207                 printf("%d,", (int) libtrace_result_get_value(&result));
    208         }
    209         printf(")\n");
    210         libtrace_vector_destroy(&results);
    211 
     215
     216        /* Now check we have all received all the packets */
    212217        if (error == 0) {
    213                 if (count == expected) {
     218                if (totalpkts == expected) {
    214219                        printf("success: %d packets read\n",expected);
    215220                } else {
    216                         printf("failure: %d packets expected, %d seen\n",expected,count);
     221                        printf("failure: %d packets expected, %d seen\n",expected,totalpkts);
    217222                        error = 1;
    218223                }
  • test/test-format-parallel.c

    rf051c1b r2498008  
    9191}
    9292
    93 
    9493struct TLS {
    9594        bool seen_start_message;
     
    9998        int count;
    10099};
     100
     101static int totalpkts = 0;
     102static void report_result(libtrace_t *trace, libtrace_result_t *result, libtrace_message_t *mesg) {
     103        static int totalthreads = 0;
     104        if (result) {
     105                assert(libtrace_result_get_key(result) == 0);
     106                printf("%d,", (int) libtrace_result_get_value(result));
     107                totalthreads++;
     108                totalpkts += (int) libtrace_result_get_value(result);
     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                }
     119        }
     120}
     121
    101122int x;
    102 
    103 static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
     123static void* per_packet(libtrace_t *trace, libtrace_packet_t *pkt,
    104124                                                libtrace_message_t *mesg,
    105125                                                libtrace_thread_t *t) {
     
    111131        static __thread bool seen_paused_message = false;
    112132        static __thread bool seen_pausing_message = false;
    113         static __thread count = 0;
     133        static __thread int count = 0;
    114134        tls = trace_get_tls(t);
    115135
     
    176196int main(int argc, char *argv[]) {
    177197        int error = 0;
    178         int count = 0;
    179198        int expected = 100;
    180         int i;
    181199        const char *tracename;
    182200        libtrace_t *trace;
     
    194212        if (strcmp(argv[1],"rtclient")==0) expected=101;
    195213
    196         trace_pstart(trace, NULL, per_packet, NULL);
     214        trace_pstart(trace, NULL, per_packet, report_result);
    197215        iferr(trace,tracename);
    198216
     
    205223        /* Wait for all threads to stop */
    206224        trace_join(trace);
    207         libtrace_vector_t results;
    208 
    209         /* Now lets check the results */
    210         libtrace_vector_init(&results, sizeof(libtrace_result_t));
    211         trace_get_results(trace, &results);
    212         printf("\tLooks like %d threads were used!\n\tcounts(", libtrace_vector_get_size(&results));
    213         for (i = 0; i < libtrace_vector_get_size(&results); i++) {
    214                 int ret;
    215                 libtrace_result_t result;
    216                 ret = libtrace_vector_get(&results, i, (void *) &result);
    217                 assert(ret == 1);
    218                 assert(libtrace_result_get_key(&result) == 0);
    219                 count += (int) libtrace_result_get_value(&result);
    220                 printf("%d,", (int) libtrace_result_get_value(&result));
    221         }
    222         printf(")\n");
    223         libtrace_vector_destroy(&results);
    224 
     225
     226        /* Now check we have all received all the packets */
    225227        if (error == 0) {
    226                 if (count == expected) {
     228                if (totalpkts == expected) {
    227229                        printf("success: %d packets read\n",expected);
    228230                } else {
    229                         printf("failure: %d packets expected, %d seen\n",expected,count);
     231                        printf("failure: %d packets expected, %d seen\n",expected,totalpkts);
    230232                        error = 1;
    231233                }
     
    233235                iferr(trace,tracename);
    234236        }
     237
    235238    trace_destroy(trace);
    236239    return error;
Note: See TracChangeset for help on using the changeset viewer.