diff options
author | Sree Harsha Totakura <totakura@in.tum.de> | 2012-09-23 07:38:26 +0000 |
---|---|---|
committer | Sree Harsha Totakura <totakura@in.tum.de> | 2012-09-23 07:38:26 +0000 |
commit | f5194cbf71d48721d6d9d53d601d6519812d76a3 (patch) | |
tree | eaac3cbda788374eb15eed5343b66e2e8009d99c /src/stream | |
parent | 352999acf6e0f360bbbdb4ed05d2a3a18b2c8fe4 (diff) | |
download | gnunet-f5194cbf71d48721d6d9d53d601d6519812d76a3.tar.gz gnunet-f5194cbf71d48721d6d9d53d601d6519812d76a3.zip |
measuring uplink and downlink
Diffstat (limited to 'src/stream')
-rw-r--r-- | src/stream/perf_stream_api.c | 153 |
1 files changed, 109 insertions, 44 deletions
diff --git a/src/stream/perf_stream_api.c b/src/stream/perf_stream_api.c index 96507834c..3dbdda256 100644 --- a/src/stream/perf_stream_api.c +++ b/src/stream/perf_stream_api.c | |||
@@ -140,6 +140,28 @@ struct PeerData | |||
140 | 140 | ||
141 | 141 | ||
142 | /** | 142 | /** |
143 | * Enumeration of stages in this testing | ||
144 | */ | ||
145 | enum TestStage | ||
146 | { | ||
147 | /** | ||
148 | * The initial stage | ||
149 | */ | ||
150 | INIT, | ||
151 | |||
152 | /** | ||
153 | * Uplink testing stage | ||
154 | */ | ||
155 | UPLINK_OK, | ||
156 | |||
157 | /** | ||
158 | * Downlink testing stage | ||
159 | */ | ||
160 | DOWNLINK_OK | ||
161 | }; | ||
162 | |||
163 | |||
164 | /** | ||
143 | * Maximum size of the data which we will transfer during tests | 165 | * Maximum size of the data which we will transfer during tests |
144 | */ | 166 | */ |
145 | #define DATA_SIZE 5000000 /* 5mB */ | 167 | #define DATA_SIZE 5000000 /* 5mB */ |
@@ -203,7 +225,7 @@ static uint32_t data[DATA_SIZE / 4]; | |||
203 | * Payload sizes to test each major test with | 225 | * Payload sizes to test each major test with |
204 | */ | 226 | */ |
205 | static uint16_t payload_size[] = | 227 | static uint16_t payload_size[] = |
206 | { 50000 }; //{ 20, 500, 2000, 7000, 13000, 25000, 50000, 60000, 63000, 64000 }; | 228 | { 20, 500, 2000, 7000, 13000, 25000, 50000, 60000, 63000, 64000 }; |
207 | 229 | ||
208 | /** | 230 | /** |
209 | * Current step of testing | 231 | * Current step of testing |
@@ -223,7 +245,7 @@ static int num_peers; | |||
223 | /** | 245 | /** |
224 | * Testing result of a major test | 246 | * Testing result of a major test |
225 | */ | 247 | */ |
226 | static int result; | 248 | static enum TestStage result; |
227 | 249 | ||
228 | /** | 250 | /** |
229 | * Create a meter to keep track of the progress of some task. | 251 | * Create a meter to keep track of the progress of some task. |
@@ -360,6 +382,11 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
360 | if (GNUNET_SCHEDULER_NO_TASK != write_task) | 382 | if (GNUNET_SCHEDULER_NO_TASK != write_task) |
361 | GNUNET_SCHEDULER_cancel (write_task); | 383 | GNUNET_SCHEDULER_cancel (write_task); |
362 | GNUNET_SCHEDULER_shutdown (); /* Shutdown this testcase */ | 384 | GNUNET_SCHEDULER_shutdown (); /* Shutdown this testcase */ |
385 | if (NULL != meter) | ||
386 | { | ||
387 | free_meter (meter); | ||
388 | meter = NULL; | ||
389 | } | ||
363 | } | 390 | } |
364 | 391 | ||
365 | 392 | ||
@@ -377,6 +404,24 @@ do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
377 | do_shutdown (cls, tc); | 404 | do_shutdown (cls, tc); |
378 | } | 405 | } |
379 | 406 | ||
407 | |||
408 | /** | ||
409 | * Scheduler call back; to be executed when a new stream is connected | ||
410 | * Called from listen connect for peer2 | ||
411 | */ | ||
412 | static void | ||
413 | stream_read_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); | ||
414 | |||
415 | |||
416 | /** | ||
417 | * Task for calling STREAM_write with a chunk of random data | ||
418 | * | ||
419 | * @param cls the peer data entity | ||
420 | * @param tc the task context | ||
421 | */ | ||
422 | static void | ||
423 | stream_write_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); | ||
424 | |||
380 | 425 | ||
381 | /** | 426 | /** |
382 | * The write completion function; called upon writing some data to stream or | 427 | * The write completion function; called upon writing some data to stream or |
@@ -390,10 +435,14 @@ static void | |||
390 | write_completion (void *cls, enum GNUNET_STREAM_Status status, size_t size) | 435 | write_completion (void *cls, enum GNUNET_STREAM_Status status, size_t size) |
391 | { | 436 | { |
392 | struct PeerData *pdata = cls; | 437 | struct PeerData *pdata = cls; |
438 | double throughput; | ||
439 | double prof_time_sec; | ||
393 | 440 | ||
394 | GNUNET_assert (GNUNET_STREAM_OK == status); | 441 | GNUNET_assert (GNUNET_STREAM_OK == status); |
395 | GNUNET_assert (size <= DATA_SIZE); | 442 | GNUNET_assert (size <= DATA_SIZE); |
396 | pdata->bytes_wrote += size; | 443 | pdata->bytes_wrote += size; |
444 | for (;size > 0; size--) | ||
445 | update_meter (meter); | ||
397 | if (pdata->bytes_wrote < DATA_SIZE) /* Have more data to send */ | 446 | if (pdata->bytes_wrote < DATA_SIZE) /* Have more data to send */ |
398 | { | 447 | { |
399 | pdata->io_write_handle = | 448 | pdata->io_write_handle = |
@@ -406,12 +455,31 @@ write_completion (void *cls, enum GNUNET_STREAM_Status status, size_t size) | |||
406 | } | 455 | } |
407 | else | 456 | else |
408 | { | 457 | { |
458 | free_meter (meter); | ||
459 | meter = NULL; | ||
409 | prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time); | 460 | prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time); |
410 | result = GNUNET_OK; | 461 | prof_time_sec = (((double) prof_time.rel_value)/ ((double) 1000)); |
411 | GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); | 462 | throughput = (((float) sizeof (data)) / prof_time_sec); |
463 | PRINTF ("Throughput %.2f kB/sec\n", throughput / 1000.00); | ||
464 | switch (result) | ||
465 | { | ||
466 | case INIT: | ||
467 | result = UPLINK_OK; | ||
468 | GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == read_task); | ||
469 | GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == write_task); | ||
470 | pdata->bytes_read = 0; | ||
471 | meter = create_meter (sizeof (data), "Testing Downlink\n", GNUNET_YES); | ||
472 | read_task = GNUNET_SCHEDULER_add_now (&stream_read_task, &peer_data[0]); | ||
473 | write_task = GNUNET_SCHEDULER_add_now (&stream_write_task, &peer_data[1]); | ||
474 | break; | ||
475 | case UPLINK_OK: | ||
476 | result = DOWNLINK_OK; | ||
477 | GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); | ||
478 | break; | ||
479 | case DOWNLINK_OK: | ||
480 | GNUNET_assert (0); | ||
481 | } | ||
412 | } | 482 | } |
413 | for (;size > 0; size--) | ||
414 | update_meter (meter); | ||
415 | } | 483 | } |
416 | 484 | ||
417 | 485 | ||
@@ -422,11 +490,18 @@ write_completion (void *cls, enum GNUNET_STREAM_Status status, size_t size) | |||
422 | * @param tc the task context | 490 | * @param tc the task context |
423 | */ | 491 | */ |
424 | static void | 492 | static void |
425 | stream_write_task (void *cls, | 493 | stream_write_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
426 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
427 | { | 494 | { |
428 | struct PeerData *pdata = cls; | 495 | struct PeerData *pdata = cls; |
429 | 496 | ||
497 | if (GNUNET_SCHEDULER_NO_TASK != abort_task) | ||
498 | { | ||
499 | GNUNET_SCHEDULER_cancel (abort_task); | ||
500 | abort_task = | ||
501 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | ||
502 | (GNUNET_TIME_UNIT_SECONDS, 300), &do_abort, | ||
503 | NULL); | ||
504 | } | ||
430 | write_task = GNUNET_SCHEDULER_NO_TASK; | 505 | write_task = GNUNET_SCHEDULER_NO_TASK; |
431 | prof_start_time = GNUNET_TIME_absolute_get (); | 506 | prof_start_time = GNUNET_TIME_absolute_get (); |
432 | pdata->bytes_wrote = 0; | 507 | pdata->bytes_wrote = 0; |
@@ -466,8 +541,7 @@ input_processor (void *cls, enum GNUNET_STREAM_Status status, | |||
466 | GNUNET_assert (size < DATA_SIZE); | 541 | GNUNET_assert (size < DATA_SIZE); |
467 | GNUNET_assert (0 == memcmp (((void *)data ) + pdata->bytes_read, | 542 | GNUNET_assert (0 == memcmp (((void *)data ) + pdata->bytes_read, |
468 | input_data, size)); | 543 | input_data, size)); |
469 | pdata->bytes_read += size; | 544 | pdata->bytes_read += size; |
470 | |||
471 | if (pdata->bytes_read < DATA_SIZE) | 545 | if (pdata->bytes_read < DATA_SIZE) |
472 | { | 546 | { |
473 | GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == read_task); | 547 | GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == read_task); |
@@ -475,7 +549,6 @@ input_processor (void *cls, enum GNUNET_STREAM_Status status, | |||
475 | } | 549 | } |
476 | else | 550 | else |
477 | { | 551 | { |
478 | /* Peer2 has completed reading*/ | ||
479 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Reading finished successfully\n"); | 552 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Reading finished successfully\n"); |
480 | } | 553 | } |
481 | return size; | 554 | return size; |
@@ -539,6 +612,7 @@ stream_open_cb (void *cls, | |||
539 | struct PeerData *pdata = cls; | 612 | struct PeerData *pdata = cls; |
540 | 613 | ||
541 | GNUNET_assert (socket == pdata->socket); | 614 | GNUNET_assert (socket == pdata->socket); |
615 | meter = create_meter (sizeof (data), "Testing Uplink\n", GNUNET_YES); | ||
542 | write_task = GNUNET_SCHEDULER_add_now (&stream_write_task, pdata); | 616 | write_task = GNUNET_SCHEDULER_add_now (&stream_write_task, pdata); |
543 | } | 617 | } |
544 | 618 | ||
@@ -578,14 +652,17 @@ run (void *cls, | |||
578 | peer2_listen_socket = | 652 | peer2_listen_socket = |
579 | GNUNET_STREAM_listen (config, 10, &stream_listen_cb, &peer_data[1], | 653 | GNUNET_STREAM_listen (config, 10, &stream_listen_cb, &peer_data[1], |
580 | GNUNET_STREAM_OPTION_SIGNAL_LISTEN_SUCCESS, | 654 | GNUNET_STREAM_OPTION_SIGNAL_LISTEN_SUCCESS, |
581 | &stream_connect, GNUNET_STREAM_OPTION_END); | 655 | &stream_connect, |
656 | GNUNET_STREAM_OPTION_MAX_PAYLOAD_SIZE, | ||
657 | payload_size[payload_size_index], | ||
658 | GNUNET_STREAM_OPTION_END); | ||
582 | GNUNET_assert (NULL != peer2_listen_socket); | 659 | GNUNET_assert (NULL != peer2_listen_socket); |
583 | peer_data[0].id = id; | 660 | peer_data[0].id = id; |
584 | peer_data[1].id = id; | 661 | peer_data[1].id = id; |
585 | abort_task = | 662 | abort_task = |
586 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | 663 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply |
587 | (GNUNET_TIME_UNIT_SECONDS, 300), &do_abort, | 664 | (GNUNET_TIME_UNIT_SECONDS, 300), &do_abort, |
588 | NULL); | 665 | NULL); |
589 | } | 666 | } |
590 | 667 | ||
591 | 668 | ||
@@ -663,7 +740,10 @@ stream_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg) | |||
663 | peer2_listen_socket = | 740 | peer2_listen_socket = |
664 | GNUNET_STREAM_listen (cfg, 10, &stream_listen_cb, &peer_data[1], | 741 | GNUNET_STREAM_listen (cfg, 10, &stream_listen_cb, &peer_data[1], |
665 | GNUNET_STREAM_OPTION_SIGNAL_LISTEN_SUCCESS, | 742 | GNUNET_STREAM_OPTION_SIGNAL_LISTEN_SUCCESS, |
666 | &stream_connect2, GNUNET_STREAM_OPTION_END); | 743 | &stream_connect2, |
744 | GNUNET_STREAM_OPTION_MAX_PAYLOAD_SIZE, | ||
745 | payload_size[payload_size_index], | ||
746 | GNUNET_STREAM_OPTION_END); | ||
667 | GNUNET_assert (NULL != peer2_listen_socket); | 747 | GNUNET_assert (NULL != peer2_listen_socket); |
668 | return peer2_listen_socket; | 748 | return peer2_listen_socket; |
669 | } | 749 | } |
@@ -786,7 +866,7 @@ test_master (void *cls, unsigned int num_peers_, | |||
786 | GNUNET_break (0); | 866 | GNUNET_break (0); |
787 | abort_task = | 867 | abort_task = |
788 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | 868 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply |
789 | (GNUNET_TIME_UNIT_SECONDS, 40), &do_abort, | 869 | (GNUNET_TIME_UNIT_SECONDS, 120), &do_abort, |
790 | NULL); | 870 | NULL); |
791 | } | 871 | } |
792 | 872 | ||
@@ -796,12 +876,9 @@ test_master (void *cls, unsigned int num_peers_, | |||
796 | */ | 876 | */ |
797 | int main (int argc, char **argv) | 877 | int main (int argc, char **argv) |
798 | { | 878 | { |
799 | char *pmsg; | ||
800 | char *test_name = "perf_stream_api"; | 879 | char *test_name = "perf_stream_api"; |
801 | char *cfg_file = "test_stream_local.conf"; | 880 | char *cfg_file = "test_stream_local.conf"; |
802 | uint64_t event_mask; | 881 | uint64_t event_mask; |
803 | double throughput; | ||
804 | double prof_time_sec; | ||
805 | unsigned int count; | 882 | unsigned int count; |
806 | int ret; | 883 | int ret; |
807 | 884 | ||
@@ -814,49 +891,37 @@ int main (int argc, char **argv) | |||
814 | } | 891 | } |
815 | reset_meter (meter); | 892 | reset_meter (meter); |
816 | free_meter (meter); | 893 | free_meter (meter); |
894 | meter = NULL; | ||
817 | test_step = TEST_STEP_1_HOP; | 895 | test_step = TEST_STEP_1_HOP; |
818 | for (payload_size_index = 0; | 896 | for (payload_size_index = 0; |
819 | payload_size_index < (sizeof (payload_size) / sizeof (uint16_t)); | 897 | payload_size_index < (sizeof (payload_size) / sizeof (uint16_t)); |
820 | payload_size_index++) | 898 | payload_size_index++) |
821 | { | 899 | { |
822 | GNUNET_asprintf (&pmsg, "\nTesting over loopback with payload size %hu\n", | 900 | PRINTF ("\nTesting over loopback with payload size %hu\n", |
823 | payload_size[payload_size_index]); | 901 | payload_size[payload_size_index]); |
824 | (void) memset (peer_data, 0, sizeof (peer_data)); | 902 | (void) memset (peer_data, 0, sizeof (peer_data)); |
825 | meter = create_meter (sizeof (data), pmsg, GNUNET_YES); | 903 | result = INIT; |
826 | GNUNET_free (pmsg); | ||
827 | result = GNUNET_SYSERR; | ||
828 | ret = GNUNET_TESTING_peer_run (test_name, cfg_file, &run, NULL); | 904 | ret = GNUNET_TESTING_peer_run (test_name, cfg_file, &run, NULL); |
829 | free_meter (meter); | 905 | if ((0 != ret) || (DOWNLINK_OK != result)) |
830 | if ((0 != ret) || (GNUNET_OK != result)) | ||
831 | goto return_fail; | 906 | goto return_fail; |
832 | prof_time_sec = (((double) prof_time.rel_value)/ ((double) 1000)); | ||
833 | throughput = (((float) sizeof (data)) / prof_time_sec); | ||
834 | //PRINTF ("Profiling time %llu ms = %.2f sec\n", prof_time.rel_value, prof_time_sec); | ||
835 | PRINTF ("Throughput %.2f kB/sec\n", throughput / 1000.00); | ||
836 | } | 907 | } |
837 | test_step = TEST_STEP_2_HOP; | 908 | test_step = TEST_STEP_2_HOP; |
838 | num_peers = 2; | 909 | num_peers = 2; |
839 | event_mask = 0; | 910 | event_mask = 0; |
840 | event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT); | 911 | event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT); |
841 | event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED); | 912 | event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED); |
842 | for (payload_size_index = 0; | 913 | for (payload_size_index = 0; |
843 | payload_size_index < (sizeof (payload_size) / sizeof (uint16_t)); | 914 | payload_size_index < (sizeof (payload_size) / sizeof (uint16_t)); |
844 | payload_size_index++) | 915 | payload_size_index++) |
845 | { | 916 | { |
917 | PRINTF ("\nTesting over 1 hop with payload size %hu\n", | ||
918 | payload_size[payload_size_index]); | ||
846 | (void) memset (peer_data, 0, sizeof (peer_data)); | 919 | (void) memset (peer_data, 0, sizeof (peer_data)); |
847 | GNUNET_asprintf (&pmsg, "\nTesting over 1 hop with payload size %hu\n", | ||
848 | payload_size[payload_size_index]); | ||
849 | meter = create_meter (sizeof (data), pmsg, GNUNET_YES); | ||
850 | GNUNET_free (pmsg); | ||
851 | result = GNUNET_SYSERR; | 920 | result = GNUNET_SYSERR; |
852 | GNUNET_TESTBED_test_run (test_name, cfg_file, num_peers, event_mask, | 921 | GNUNET_TESTBED_test_run (test_name, cfg_file, num_peers, event_mask, |
853 | &controller_event_cb, NULL, &test_master, NULL); | 922 | &controller_event_cb, NULL, &test_master, NULL); |
854 | free_meter (meter); | 923 | if (DOWNLINK_OK != result) |
855 | if (GNUNET_OK != result) | ||
856 | goto return_fail; | 924 | goto return_fail; |
857 | prof_time_sec = (((double) prof_time.rel_value)/ ((double) 1000)); | ||
858 | throughput = (((float) sizeof (data)) / prof_time_sec); | ||
859 | PRINTF ("Throughput %.2f kB/sec\n", throughput / 1000.00); | ||
860 | } | 925 | } |
861 | test_step = TEST_STEP_3_HOP; | 926 | test_step = TEST_STEP_3_HOP; |
862 | for (payload_size_index = 0; | 927 | for (payload_size_index = 0; |
@@ -865,7 +930,7 @@ int main (int argc, char **argv) | |||
865 | { | 930 | { |
866 | /* Initialize testbed here */ | 931 | /* Initialize testbed here */ |
867 | } | 932 | } |
868 | return ret; | 933 | return 0; |
869 | 934 | ||
870 | return_fail: | 935 | return_fail: |
871 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test failed\n"); | 936 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test failed\n"); |