aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorSree Harsha Totakura <totakura@in.tum.de>2012-09-18 15:46:24 +0000
committerSree Harsha Totakura <totakura@in.tum.de>2012-09-18 15:46:24 +0000
commit32039d08a7fd13dfcbe5d5d1548a1482afc29187 (patch)
tree213eb7804cb2b74273ebcfff514cf0f99d21a1fd
parentdb93dcf5dd2c9ec06a7375ed250f842c62bc8905 (diff)
downloadgnunet-32039d08a7fd13dfcbe5d5d1548a1482afc29187.tar.gz
gnunet-32039d08a7fd13dfcbe5d5d1548a1482afc29187.zip
1 hop performance testing
-rw-r--r--src/stream/perf_stream_api.c305
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;
152static struct PeerData peer_data[3]; 165static struct PeerData peer_data[3];
153 166
154/** 167/**
168 * Handle to common operations while using testbed
169 */
170static struct GNUNET_TESTBED_Operation *common_op;
171
172/**
155 * Task ID for abort task 173 * Task ID for abort task
156 */ 174 */
157static GNUNET_SCHEDULER_TaskIdentifier abort_task; 175static 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 */
187static uint16_t payload_size[] = 205static 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 */
193static 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;
203static unsigned int payload_size_index; 216static unsigned int payload_size_index;
204 217
205/** 218/**
219 * Number of peers we want to create while using the testbed service
220 */
221static int num_peers;
222
223/**
206 * Testing result of a major test 224 * Testing result of a major test
207 */ 225 */
208static int result; 226static int result;
@@ -316,11 +334,27 @@ free_meter (struct ProgressMeter *meter)
316static void 334static void
317do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 335do_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,
515static void 549static void
516stream_connect (void) 550stream_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 */
602static void *
603stream_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 */
613static void
614stream_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 */
634static void
635stream_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 */
655static void *
656stream_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 */
695static void
696peerinfo_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 */
736static void
737controller_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 */
771static void
772test_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 */
561int main (int argc, char **argv) 797int 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;