diff options
author | Sree Harsha Totakura <totakura@in.tum.de> | 2012-09-18 15:46:24 +0000 |
---|---|---|
committer | Sree Harsha Totakura <totakura@in.tum.de> | 2012-09-18 15:46:24 +0000 |
commit | 32039d08a7fd13dfcbe5d5d1548a1482afc29187 (patch) | |
tree | 213eb7804cb2b74273ebcfff514cf0f99d21a1fd | |
parent | db93dcf5dd2c9ec06a7375ed250f842c62bc8905 (diff) | |
download | gnunet-32039d08a7fd13dfcbe5d5d1548a1482afc29187.tar.gz gnunet-32039d08a7fd13dfcbe5d5d1548a1482afc29187.zip |
1 hop performance testing
-rw-r--r-- | src/stream/perf_stream_api.c | 305 |
1 files changed, 280 insertions, 25 deletions
diff --git a/src/stream/perf_stream_api.c b/src/stream/perf_stream_api.c index f9f91b5f9..96507834c 100644 --- a/src/stream/perf_stream_api.c +++ b/src/stream/perf_stream_api.c | |||
@@ -102,8 +102,6 @@ struct PeerData | |||
102 | */ | 102 | */ |
103 | struct GNUNET_STREAM_Socket *socket; | 103 | struct GNUNET_STREAM_Socket *socket; |
104 | 104 | ||
105 | struct GNUNET_PeerIdentity self; | ||
106 | |||
107 | /** | 105 | /** |
108 | * Peer's io write handle | 106 | * Peer's io write handle |
109 | */ | 107 | */ |
@@ -115,6 +113,21 @@ struct PeerData | |||
115 | struct GNUNET_STREAM_IOReadHandle *io_read_handle; | 113 | struct GNUNET_STREAM_IOReadHandle *io_read_handle; |
116 | 114 | ||
117 | /** | 115 | /** |
116 | * The peer handle when we use the testbed servie | ||
117 | */ | ||
118 | struct GNUNET_TESTBED_Peer *peer; | ||
119 | |||
120 | /** | ||
121 | * Handle to peer specific opearations while using testbed service | ||
122 | */ | ||
123 | struct GNUNET_TESTBED_Operation *op; | ||
124 | |||
125 | /** | ||
126 | * The identity of this peer | ||
127 | */ | ||
128 | struct GNUNET_PeerIdentity id; | ||
129 | |||
130 | /** | ||
118 | * Bytes the peer has written | 131 | * Bytes the peer has written |
119 | */ | 132 | */ |
120 | unsigned int bytes_wrote; | 133 | unsigned int bytes_wrote; |
@@ -152,6 +165,11 @@ static struct ProgressMeter *meter; | |||
152 | static struct PeerData peer_data[3]; | 165 | static struct PeerData peer_data[3]; |
153 | 166 | ||
154 | /** | 167 | /** |
168 | * Handle to common operations while using testbed | ||
169 | */ | ||
170 | static struct GNUNET_TESTBED_Operation *common_op; | ||
171 | |||
172 | /** | ||
155 | * Task ID for abort task | 173 | * Task ID for abort task |
156 | */ | 174 | */ |
157 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 175 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; |
@@ -185,12 +203,7 @@ static uint32_t data[DATA_SIZE / 4]; | |||
185 | * Payload sizes to test each major test with | 203 | * Payload sizes to test each major test with |
186 | */ | 204 | */ |
187 | static uint16_t payload_size[] = | 205 | static uint16_t payload_size[] = |
188 | { 20, 500, 2000, 7000, 13000, 25000, 50000, 60000, 63000, 64000 }; | 206 | { 50000 }; //{ 20, 500, 2000, 7000, 13000, 25000, 50000, 60000, 63000, 64000 }; |
189 | |||
190 | /** | ||
191 | * Handle for the progress meter | ||
192 | */ | ||
193 | static struct ProgressMeter *meter; | ||
194 | 207 | ||
195 | /** | 208 | /** |
196 | * Current step of testing | 209 | * Current step of testing |
@@ -203,6 +216,11 @@ static enum TestStep test_step; | |||
203 | static unsigned int payload_size_index; | 216 | static unsigned int payload_size_index; |
204 | 217 | ||
205 | /** | 218 | /** |
219 | * Number of peers we want to create while using the testbed service | ||
220 | */ | ||
221 | static int num_peers; | ||
222 | |||
223 | /** | ||
206 | * Testing result of a major test | 224 | * Testing result of a major test |
207 | */ | 225 | */ |
208 | static int result; | 226 | static int result; |
@@ -316,11 +334,27 @@ free_meter (struct ProgressMeter *meter) | |||
316 | static void | 334 | static void |
317 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 335 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
318 | { | 336 | { |
319 | GNUNET_STREAM_close (peer_data[1].socket); | 337 | switch (test_step) |
320 | if (NULL != peer_data[2].socket) | 338 | { |
321 | GNUNET_STREAM_close (peer_data[2].socket); | 339 | case TEST_STEP_1_HOP: |
322 | if (NULL != peer2_listen_socket) | 340 | if (NULL != peer_data[0].socket) |
323 | GNUNET_STREAM_listen_close (peer2_listen_socket); /* Close listen socket */ | 341 | GNUNET_STREAM_close (peer_data[0].socket); |
342 | if (NULL != peer_data[1].socket) | ||
343 | GNUNET_STREAM_close (peer_data[1].socket); | ||
344 | if (NULL != peer2_listen_socket) | ||
345 | GNUNET_STREAM_listen_close (peer2_listen_socket); /* Close listen socket */ | ||
346 | break; | ||
347 | case TEST_STEP_2_HOP: | ||
348 | if (NULL != peer_data[1].socket) | ||
349 | GNUNET_STREAM_close (peer_data[1].socket); | ||
350 | if (NULL != peer_data[0].op) | ||
351 | GNUNET_TESTBED_operation_done (peer_data[0].op); | ||
352 | if (NULL != peer_data[1].op) | ||
353 | GNUNET_TESTBED_operation_done (peer_data[1].op); | ||
354 | break; | ||
355 | case TEST_STEP_3_HOP: | ||
356 | GNUNET_break (0); | ||
357 | } | ||
324 | if (GNUNET_SCHEDULER_NO_TASK != abort_task) | 358 | if (GNUNET_SCHEDULER_NO_TASK != abort_task) |
325 | GNUNET_SCHEDULER_cancel (abort_task); | 359 | GNUNET_SCHEDULER_cancel (abort_task); |
326 | if (GNUNET_SCHEDULER_NO_TASK != write_task) | 360 | if (GNUNET_SCHEDULER_NO_TASK != write_task) |
@@ -482,8 +516,8 @@ stream_listen_cb (void *cls, struct GNUNET_STREAM_Socket *socket, | |||
482 | struct PeerData *pdata = cls; | 516 | struct PeerData *pdata = cls; |
483 | 517 | ||
484 | GNUNET_assert (NULL != socket); | 518 | GNUNET_assert (NULL != socket); |
485 | GNUNET_assert (pdata == &peer_data[2]); | 519 | GNUNET_assert (pdata == &peer_data[1]); |
486 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer connected: %s\n", | 520 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer connected: %s\n", |
487 | GNUNET_i2s(initiator)); | 521 | GNUNET_i2s(initiator)); |
488 | pdata->socket = socket; | 522 | pdata->socket = socket; |
489 | pdata->bytes_read = 0; | 523 | pdata->bytes_read = 0; |
@@ -515,13 +549,13 @@ stream_open_cb (void *cls, | |||
515 | static void | 549 | static void |
516 | stream_connect (void) | 550 | stream_connect (void) |
517 | { | 551 | { |
518 | peer_data[1].socket = | 552 | peer_data[0].socket = |
519 | GNUNET_STREAM_open (config, &peer_data[2].self, 10, &stream_open_cb, | 553 | GNUNET_STREAM_open (config, &peer_data[1].id, 10, &stream_open_cb, |
520 | &peer_data[1], | 554 | &peer_data[0], |
521 | GNUNET_STREAM_OPTION_MAX_PAYLOAD_SIZE, | 555 | GNUNET_STREAM_OPTION_MAX_PAYLOAD_SIZE, |
522 | payload_size[payload_size_index], | 556 | payload_size[payload_size_index], |
523 | GNUNET_STREAM_OPTION_END); | 557 | GNUNET_STREAM_OPTION_END); |
524 | GNUNET_assert (NULL != peer_data[1].socket); | 558 | GNUNET_assert (NULL != peer_data[0].socket); |
525 | } | 559 | } |
526 | 560 | ||
527 | 561 | ||
@@ -537,17 +571,17 @@ run (void *cls, | |||
537 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 571 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
538 | struct GNUNET_TESTING_Peer *peer) | 572 | struct GNUNET_TESTING_Peer *peer) |
539 | { | 573 | { |
540 | struct GNUNET_PeerIdentity self; | 574 | struct GNUNET_PeerIdentity id; |
541 | 575 | ||
542 | GNUNET_TESTING_peer_get_identity (peer, &self); | 576 | GNUNET_TESTING_peer_get_identity (peer, &id); |
543 | config = cfg; | 577 | config = cfg; |
544 | peer2_listen_socket = | 578 | peer2_listen_socket = |
545 | GNUNET_STREAM_listen (config, 10, &stream_listen_cb, &peer_data[2], | 579 | GNUNET_STREAM_listen (config, 10, &stream_listen_cb, &peer_data[1], |
546 | GNUNET_STREAM_OPTION_SIGNAL_LISTEN_SUCCESS, | 580 | GNUNET_STREAM_OPTION_SIGNAL_LISTEN_SUCCESS, |
547 | &stream_connect, GNUNET_STREAM_OPTION_END); | 581 | &stream_connect, GNUNET_STREAM_OPTION_END); |
548 | GNUNET_assert (NULL != peer2_listen_socket); | 582 | GNUNET_assert (NULL != peer2_listen_socket); |
549 | peer_data[1].self = self; | 583 | peer_data[0].id = id; |
550 | peer_data[2].self = self; | 584 | peer_data[1].id = id; |
551 | abort_task = | 585 | abort_task = |
552 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | 586 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply |
553 | (GNUNET_TIME_UNIT_SECONDS, 300), &do_abort, | 587 | (GNUNET_TIME_UNIT_SECONDS, 300), &do_abort, |
@@ -556,6 +590,208 @@ run (void *cls, | |||
556 | 590 | ||
557 | 591 | ||
558 | /** | 592 | /** |
593 | * Adapter function called to establish a connection to | ||
594 | * a service. | ||
595 | * | ||
596 | * @param cls closure | ||
597 | * @param cfg configuration of the peer to connect to; will be available until | ||
598 | * GNUNET_TESTBED_operation_done() is called on the operation returned | ||
599 | * from GNUNET_TESTBED_service_connect() | ||
600 | * @return service handle to return in 'op_result', NULL on error | ||
601 | */ | ||
602 | static void * | ||
603 | stream_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg); | ||
604 | |||
605 | |||
606 | /** | ||
607 | * Adapter function called to destroy a connection to | ||
608 | * a service. | ||
609 | * | ||
610 | * @param cls closure | ||
611 | * @param op_result service handle returned from the connect adapter | ||
612 | */ | ||
613 | static void | ||
614 | stream_da (void *cls, void *op_result) | ||
615 | { | ||
616 | if (&peer_data[1] == cls) | ||
617 | { | ||
618 | GNUNET_STREAM_listen_close (op_result); | ||
619 | return; | ||
620 | } | ||
621 | else if (&peer_data[0] == cls) | ||
622 | { | ||
623 | GNUNET_STREAM_close (op_result); | ||
624 | return; | ||
625 | } | ||
626 | GNUNET_assert (0); | ||
627 | } | ||
628 | |||
629 | |||
630 | /** | ||
631 | * Listen success callback; connects a peer to stream as client. Called from | ||
632 | * testbed stream_ca | ||
633 | */ | ||
634 | static void | ||
635 | stream_connect2 (void) | ||
636 | { | ||
637 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stream listen open successful\n"); | ||
638 | peer_data[0].op = | ||
639 | GNUNET_TESTBED_service_connect (&peer_data[0], peer_data[0].peer, | ||
640 | "stream", NULL, NULL, stream_ca, | ||
641 | stream_da, &peer_data[0]); | ||
642 | } | ||
643 | |||
644 | |||
645 | /** | ||
646 | * Adapter function called to establish a connection to | ||
647 | * a service. | ||
648 | * | ||
649 | * @param cls closure | ||
650 | * @param cfg configuration of the peer to connect to; will be available until | ||
651 | * GNUNET_TESTBED_operation_done() is called on the operation returned | ||
652 | * from GNUNET_TESTBED_service_connect() | ||
653 | * @return service handle to return in 'op_result', NULL on error | ||
654 | */ | ||
655 | static void * | ||
656 | stream_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
657 | { | ||
658 | struct PeerData *pdata = cls; | ||
659 | |||
660 | if (&peer_data[1] == pdata) | ||
661 | { | ||
662 | peer2_listen_socket = NULL; | ||
663 | peer2_listen_socket = | ||
664 | GNUNET_STREAM_listen (cfg, 10, &stream_listen_cb, &peer_data[1], | ||
665 | GNUNET_STREAM_OPTION_SIGNAL_LISTEN_SUCCESS, | ||
666 | &stream_connect2, GNUNET_STREAM_OPTION_END); | ||
667 | GNUNET_assert (NULL != peer2_listen_socket); | ||
668 | return peer2_listen_socket; | ||
669 | } | ||
670 | if (&peer_data[0] == pdata) | ||
671 | { | ||
672 | pdata->socket = | ||
673 | GNUNET_STREAM_open (cfg, &peer_data[1].id, 10, &stream_open_cb, | ||
674 | &peer_data[0], | ||
675 | GNUNET_STREAM_OPTION_MAX_PAYLOAD_SIZE, | ||
676 | payload_size[payload_size_index], | ||
677 | GNUNET_STREAM_OPTION_END); | ||
678 | GNUNET_assert (NULL != pdata->socket); | ||
679 | return pdata->socket; | ||
680 | } | ||
681 | GNUNET_assert (0); | ||
682 | return NULL; | ||
683 | } | ||
684 | |||
685 | |||
686 | /** | ||
687 | * Callback to be called when the requested peer information is available | ||
688 | * | ||
689 | * @param cb_cls the closure from GNUNET_TETSBED_peer_get_information() | ||
690 | * @param op the operation this callback corresponds to | ||
691 | * @param pinfo the result; will be NULL if the operation has failed | ||
692 | * @param emsg error message if the operation has failed; will be NULL if the | ||
693 | * operation is successfull | ||
694 | */ | ||
695 | static void | ||
696 | peerinfo_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op, | ||
697 | const struct GNUNET_TESTBED_PeerInformation *pinfo, | ||
698 | const char *emsg) | ||
699 | { | ||
700 | struct PeerData *pdata = cb_cls; | ||
701 | |||
702 | GNUNET_assert (NULL == emsg); | ||
703 | GNUNET_assert (common_op == op); | ||
704 | GNUNET_assert (NULL != pdata); | ||
705 | memcpy (&pdata->id, pinfo->result.id, sizeof (struct GNUNET_PeerIdentity)); | ||
706 | GNUNET_TESTBED_operation_done (op); | ||
707 | if (pdata == &peer_data[0]) | ||
708 | { | ||
709 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer 1 id: %s\n", | ||
710 | GNUNET_i2s (&pdata->id)); | ||
711 | common_op = GNUNET_TESTBED_peer_get_information (peer_data[1].peer, | ||
712 | GNUNET_TESTBED_PIT_IDENTITY, | ||
713 | &peerinfo_cb, &peer_data[1]); | ||
714 | } | ||
715 | else if (pdata == &peer_data[1]) | ||
716 | { | ||
717 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer 2 id: %s\n", | ||
718 | GNUNET_i2s (&pdata->id)); | ||
719 | if (TEST_STEP_2_HOP == test_step) | ||
720 | peer_data[1].op = | ||
721 | GNUNET_TESTBED_service_connect (&peer_data[1], peer_data[1].peer, | ||
722 | "stream", NULL, NULL, stream_ca, | ||
723 | stream_da, &peer_data[1]); | ||
724 | else | ||
725 | GNUNET_break (0); /* FIXME: 3 hop test case here... */ | ||
726 | } | ||
727 | } | ||
728 | |||
729 | |||
730 | /** | ||
731 | * Controller event callback | ||
732 | * | ||
733 | * @param cls NULL | ||
734 | * @param event the controller event | ||
735 | */ | ||
736 | static void | ||
737 | controller_event_cb (void *cls, | ||
738 | const struct GNUNET_TESTBED_EventInformation *event) | ||
739 | { | ||
740 | switch (event->type) | ||
741 | { | ||
742 | case GNUNET_TESTBED_ET_OPERATION_FINISHED: | ||
743 | if (NULL != event->details.operation_finished.emsg) | ||
744 | { | ||
745 | FPRINTF (stderr, "Error while expecting an operation to succeed:%s \n", | ||
746 | event->details.operation_finished.emsg); | ||
747 | GNUNET_assert (0); | ||
748 | } | ||
749 | break; | ||
750 | case GNUNET_TESTBED_ET_CONNECT: | ||
751 | GNUNET_TESTBED_operation_done (common_op); | ||
752 | /* Get the peer identity and configuration of peers */ | ||
753 | common_op = | ||
754 | GNUNET_TESTBED_peer_get_information (peer_data[0].peer, | ||
755 | GNUNET_TESTBED_PIT_IDENTITY, | ||
756 | &peerinfo_cb, &peer_data[0]); | ||
757 | break; | ||
758 | default: | ||
759 | GNUNET_assert (0); | ||
760 | } | ||
761 | } | ||
762 | |||
763 | |||
764 | /** | ||
765 | * Signature of a main function for a testcase. | ||
766 | * | ||
767 | * @param cls closure | ||
768 | * @param num_peers number of peers in 'peers' | ||
769 | * @param peers handle to peers run in the testbed | ||
770 | */ | ||
771 | static void | ||
772 | test_master (void *cls, unsigned int num_peers_, | ||
773 | struct GNUNET_TESTBED_Peer **peers) | ||
774 | { | ||
775 | GNUNET_assert (NULL != peers); | ||
776 | GNUNET_assert (NULL != peers[0]); | ||
777 | GNUNET_assert (NULL != peers[1]); | ||
778 | GNUNET_assert (num_peers_ == num_peers); | ||
779 | peer_data[0].peer = peers[0]; | ||
780 | peer_data[1].peer = peers[1]; | ||
781 | if (2 == num_peers) | ||
782 | common_op = GNUNET_TESTBED_overlay_connect (NULL, NULL, NULL, | ||
783 | peer_data[0].peer, | ||
784 | peer_data[1].peer); | ||
785 | else | ||
786 | GNUNET_break (0); | ||
787 | abort_task = | ||
788 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | ||
789 | (GNUNET_TIME_UNIT_SECONDS, 40), &do_abort, | ||
790 | NULL); | ||
791 | } | ||
792 | |||
793 | |||
794 | /** | ||
559 | * Main function | 795 | * Main function |
560 | */ | 796 | */ |
561 | int main (int argc, char **argv) | 797 | int main (int argc, char **argv) |
@@ -563,6 +799,7 @@ int main (int argc, char **argv) | |||
563 | char *pmsg; | 799 | char *pmsg; |
564 | char *test_name = "perf_stream_api"; | 800 | char *test_name = "perf_stream_api"; |
565 | char *cfg_file = "test_stream_local.conf"; | 801 | char *cfg_file = "test_stream_local.conf"; |
802 | uint64_t event_mask; | ||
566 | double throughput; | 803 | double throughput; |
567 | double prof_time_sec; | 804 | double prof_time_sec; |
568 | unsigned int count; | 805 | unsigned int count; |
@@ -584,6 +821,7 @@ int main (int argc, char **argv) | |||
584 | { | 821 | { |
585 | GNUNET_asprintf (&pmsg, "\nTesting over loopback with payload size %hu\n", | 822 | GNUNET_asprintf (&pmsg, "\nTesting over loopback with payload size %hu\n", |
586 | payload_size[payload_size_index]); | 823 | payload_size[payload_size_index]); |
824 | (void) memset (peer_data, 0, sizeof (peer_data)); | ||
587 | meter = create_meter (sizeof (data), pmsg, GNUNET_YES); | 825 | meter = create_meter (sizeof (data), pmsg, GNUNET_YES); |
588 | GNUNET_free (pmsg); | 826 | GNUNET_free (pmsg); |
589 | result = GNUNET_SYSERR; | 827 | result = GNUNET_SYSERR; |
@@ -597,11 +835,28 @@ int main (int argc, char **argv) | |||
597 | PRINTF ("Throughput %.2f kB/sec\n", throughput / 1000.00); | 835 | PRINTF ("Throughput %.2f kB/sec\n", throughput / 1000.00); |
598 | } | 836 | } |
599 | test_step = TEST_STEP_2_HOP; | 837 | test_step = TEST_STEP_2_HOP; |
838 | num_peers = 2; | ||
839 | event_mask = 0; | ||
840 | event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT); | ||
841 | event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED); | ||
600 | for (payload_size_index = 0; | 842 | for (payload_size_index = 0; |
601 | payload_size_index < (sizeof (payload_size) / sizeof (uint16_t)); | 843 | payload_size_index < (sizeof (payload_size) / sizeof (uint16_t)); |
602 | payload_size_index++) | 844 | payload_size_index++) |
603 | { | 845 | { |
604 | /* Initialize testbed here */ | 846 | (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; | ||
852 | GNUNET_TESTBED_test_run (test_name, cfg_file, num_peers, event_mask, | ||
853 | &controller_event_cb, NULL, &test_master, NULL); | ||
854 | free_meter (meter); | ||
855 | if (GNUNET_OK != result) | ||
856 | 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); | ||
605 | } | 860 | } |
606 | test_step = TEST_STEP_3_HOP; | 861 | test_step = TEST_STEP_3_HOP; |
607 | for (payload_size_index = 0; | 862 | for (payload_size_index = 0; |