2 This file is part of GNUnet.
3 (C) 2011, 2012 Christian Grothoff (and other contributing authors)
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
22 * @file stream/perf_stream_api.c
23 * @brief performance benchmarks for stream api
24 * @author Sree Harsha Totakura
27 #define LOG(kind, ...) \
28 GNUNET_log (kind, __VA_ARGS__);
30 /****************************************************************************************/
31 /* Test is setup into the following major steps: */
32 /* 1. Measurements over loopback (1 hop). i.e. we use only one peer and open */
33 /* stream connections over loopback. Messages will go through */
34 /* STREAM_API->MESH_API->MESH_SERVICE->MESH_API->STREAM_API. */
35 /* 2. Measurements over 2 peers (2 hops). We use testbed to create 2 peers, */
36 /* connect them and then create stream connections. Messages will go through */
37 /* STREAM_API->MESH_API->MESH_SERVICE->CORE1.....CORE2->MESH_API->STREAM_API */
38 /* 3. Measurements over 3 peers (3 hops). We use testbed to create 3 peers, */
39 /* connect them in a line topology: peer1->peer2->peer3. Messages will go */
41 /* STREAM_API->MESH_API->MESH_SERVICE->CORE1..CORE2..CORE3->MESH_API->STREAM_API. */
42 /****************************************************************************************/
45 #include "gnunet_common.h"
46 #include "gnunet_util_lib.h"
47 #include "gnunet_testing_lib.h"
48 #include "gnunet_testbed_service.h"
49 #include "gnunet_stream_lib.h"
52 * Simple struct to keep track of progress, and print a
53 * nice little percentage meter for long running tasks.
63 unsigned int completed;
77 * Single hop loopback testing
82 * Testing with 2 peers
87 * Testing with 3 peers
94 * Structure for holding peer's sockets and IO Handles
99 * Peer's stream socket
101 struct GNUNET_STREAM_Socket *socket;
104 * Peer's io write handle
106 struct GNUNET_STREAM_IOWriteHandle *io_write_handle;
109 * Peer's io read handle
111 struct GNUNET_STREAM_IOReadHandle *io_read_handle;
114 * The peer handle when we use the testbed servie
116 struct GNUNET_TESTBED_Peer *peer;
119 * Handle to peer specific opearations while using testbed service
121 struct GNUNET_TESTBED_Operation *op;
124 * The identity of this peer
126 struct GNUNET_PeerIdentity id;
129 * Bytes the peer has written
134 * Byte the peer has read
139 * number of packets sent
141 unsigned int packets_wrote;
144 * number of packets read
146 unsigned int packets_read;
151 * Enumeration of stages in this testing
161 * Uplink testing stage
166 * Downlink testing stage
173 * Maximum size of the data which we will transfer during tests
175 #define DATA_SIZE 5000000 /* 5mB */
178 * Fixed number of packets we send in each direction during each subtest
180 #define MAX_PACKETS 1000
183 * Listen socket of peer2
185 struct GNUNET_STREAM_ListenSocket *peer2_listen_socket;
188 * Handle to configuration during TEST_STEP_1_HOP
190 const struct GNUNET_CONFIGURATION_Handle *config;
193 * Handle for the progress meter
195 static struct ProgressMeter *meter;
198 * Placeholder for peer data
200 static struct PeerData peer_data[3];
203 * Handle to common operations while using testbed
205 static struct GNUNET_TESTBED_Operation *common_op;
208 * Task ID for abort task
210 static GNUNET_SCHEDULER_TaskIdentifier abort_task;
213 * Task ID for write task
215 static GNUNET_SCHEDULER_TaskIdentifier write_task;
218 * Task ID for read task
220 static GNUNET_SCHEDULER_TaskIdentifier read_task;
223 * Absolute time when profiling starts
225 static struct GNUNET_TIME_Absolute prof_start_time;
228 * Test time taken for sending the data
230 static struct GNUNET_TIME_Relative prof_time;
233 * Random data block. Should generate data first
235 static uint32_t data[DATA_SIZE / 4];
238 * Payload sizes to test each major test with
240 static uint16_t payload_size[] =
241 { 20, 500, 2000, 7000, 13000, 25000, 50000};//, 60000, 63000, 64000 };
244 * Current step of testing
246 static enum TestStep test_step;
249 * Index for choosing payload size
251 static unsigned int payload_size_index;
254 * Number of peers we want to create while using the testbed service
256 static int num_peers;
259 * Flag to indicate that the other peer should reset its data read source index
261 static int reset_read;
264 * Testing result of a major test
266 static enum TestStage result;
269 * Create a meter to keep track of the progress of some task.
271 * @param total the total number of items to complete
272 * @param start_string a string to prefix the meter with (if printing)
273 * @param print GNUNET_YES to print the meter, GNUNET_NO to count
276 * @return the progress meter
278 static struct ProgressMeter *
279 create_meter (unsigned int total, char *start_string, int print)
281 struct ProgressMeter *ret;
283 ret = GNUNET_malloc (sizeof (struct ProgressMeter));
286 ret->modnum = total / 4;
287 if (ret->modnum == 0) /* Divide by zero check */
289 ret->dotnum = (total / 50) + 1;
290 if (start_string != NULL)
291 ret->startup_string = GNUNET_strdup (start_string);
293 ret->startup_string = GNUNET_strdup ("");
300 * Update progress meter (increment by one).
302 * @param meter the meter to update and print info for
304 * @return GNUNET_YES if called the total requested,
305 * GNUNET_NO if more items expected
308 update_meter (struct ProgressMeter *meter)
310 if (meter->print == GNUNET_YES)
312 if (meter->completed % meter->modnum == 0)
314 if (meter->completed == 0)
316 FPRINTF (stdout, "%sProgress: [0%%", meter->startup_string);
319 FPRINTF (stdout, "%d%%",
320 (int) (((float) meter->completed / meter->total) * 100));
322 else if (meter->completed % meter->dotnum == 0)
323 FPRINTF (stdout, "%s", ".");
325 if (meter->completed + 1 == meter->total)
326 FPRINTF (stdout, "%d%%]\n", 100);
331 if (meter->completed == meter->total)
333 if (meter->completed > meter->total)
334 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Progress meter overflow!!\n");
340 * Reset progress meter.
342 * @param meter the meter to reset
344 * @return GNUNET_YES if meter reset,
345 * GNUNET_SYSERR on error
348 reset_meter (struct ProgressMeter *meter)
351 return GNUNET_SYSERR;
353 meter->completed = 0;
359 * Release resources for meter
361 * @param meter the meter to free
364 free_meter (struct ProgressMeter *meter)
366 GNUNET_free_non_null (meter->startup_string);
375 do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
379 case TEST_STEP_1_HOP:
380 if (NULL != peer_data[0].socket)
381 GNUNET_STREAM_close (peer_data[0].socket);
382 if (NULL != peer_data[1].socket)
383 GNUNET_STREAM_close (peer_data[1].socket);
384 if (NULL != peer2_listen_socket)
385 GNUNET_STREAM_listen_close (peer2_listen_socket); /* Close listen socket */
387 case TEST_STEP_2_HOP:
388 if (NULL != peer_data[1].socket)
389 GNUNET_STREAM_close (peer_data[1].socket);
390 if (NULL != peer_data[0].op)
391 GNUNET_TESTBED_operation_done (peer_data[0].op);
392 if (NULL != peer_data[1].op)
393 GNUNET_TESTBED_operation_done (peer_data[1].op);
395 case TEST_STEP_3_HOP:
398 if (GNUNET_SCHEDULER_NO_TASK != abort_task)
399 GNUNET_SCHEDULER_cancel (abort_task);
400 if (GNUNET_SCHEDULER_NO_TASK != write_task)
401 GNUNET_SCHEDULER_cancel (write_task);
402 GNUNET_SCHEDULER_shutdown (); /* Shutdown this testcase */
412 * Something went wrong and timed out. Kill everything and set error flag
415 do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
417 abort_task = GNUNET_SCHEDULER_NO_TASK;
418 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "test: ABORT\n");
419 if (GNUNET_SCHEDULER_NO_TASK != read_task)
420 GNUNET_SCHEDULER_cancel (read_task);
421 result = GNUNET_SYSERR;
422 do_shutdown (cls, tc);
427 * Scheduler call back; to be executed when a new stream is connected
428 * Called from listen connect for peer2
431 stream_read_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
435 * Task for calling STREAM_write with a chunk of random data
437 * @param cls the peer data entity
438 * @param tc the task context
441 stream_write_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
445 * The write completion function; called upon writing some data to stream or
448 * @param cls the closure from GNUNET_STREAM_write/read
449 * @param status the status of the stream at the time this function is called
450 * @param size the number of bytes written
453 write_completion (void *cls, enum GNUNET_STREAM_Status status, size_t size)
455 struct PeerData *pdata = cls;
457 double prof_time_sec;
458 unsigned int packets_wrote;
460 if (GNUNET_STREAM_OK != status)
462 GNUNET_SCHEDULER_cancel (abort_task);
463 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
466 GNUNET_assert (size <= DATA_SIZE);
467 packets_wrote = (size + payload_size[payload_size_index] - 1)
468 / payload_size[payload_size_index];
469 pdata->bytes_wrote += size;
470 for (;packets_wrote > 0; packets_wrote--)
472 update_meter (meter);
473 pdata->packets_wrote++;
475 if (pdata->packets_wrote < MAX_PACKETS) /* Have more data to send */
479 if (GNUNET_SCHEDULER_NO_TASK != abort_task)
481 GNUNET_SCHEDULER_cancel (abort_task);
483 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
484 (GNUNET_TIME_UNIT_SECONDS, 300), &do_abort,
487 write_amount = (MAX_PACKETS - pdata->packets_wrote) *
488 payload_size[payload_size_index];
489 if (write_amount > DATA_SIZE)
490 write_amount = DATA_SIZE;
491 reset_read = GNUNET_YES;
492 pdata->io_write_handle = GNUNET_STREAM_write (pdata->socket, data,
494 GNUNET_TIME_UNIT_FOREVER_REL,
495 &write_completion, pdata);
496 GNUNET_assert (NULL != pdata->io_write_handle);
502 prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
503 prof_time_sec = (((double) prof_time.rel_value)/ ((double) 1000));
504 throughput = ((float) pdata->bytes_wrote) / prof_time_sec;
505 PRINTF ("Throughput %.2f kB/sec\n", throughput / 1000.00);
510 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == read_task);
511 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == write_task);
512 pdata->bytes_read = 0;
513 pdata->packets_read = 0;
514 meter = create_meter (MAX_PACKETS, "Testing Downlink\n", GNUNET_YES);
515 read_task = GNUNET_SCHEDULER_add_now (&stream_read_task, &peer_data[0]);
516 write_task = GNUNET_SCHEDULER_add_now (&stream_write_task, &peer_data[1]);
519 result = DOWNLINK_OK;
520 GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
530 * Task for calling STREAM_write with a chunk of random data
532 * @param cls the peer data entity
533 * @param tc the task context
536 stream_write_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
538 struct PeerData *pdata = cls;
541 if (GNUNET_SCHEDULER_NO_TASK != abort_task)
543 GNUNET_SCHEDULER_cancel (abort_task);
545 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
546 (GNUNET_TIME_UNIT_SECONDS, 300), &do_abort,
549 write_task = GNUNET_SCHEDULER_NO_TASK;
550 prof_start_time = GNUNET_TIME_absolute_get ();
551 pdata->bytes_wrote = 0;
552 pdata->packets_wrote = 0;
553 write_amount = MAX_PACKETS * payload_size[payload_size_index];
554 if (write_amount > DATA_SIZE)
555 write_amount = DATA_SIZE;
556 reset_read = GNUNET_YES;
557 pdata->io_write_handle = GNUNET_STREAM_write (pdata->socket, data,
559 GNUNET_TIME_UNIT_FOREVER_REL,
560 &write_completion, pdata);
561 GNUNET_assert (NULL != pdata->io_write_handle);
566 * Scheduler call back; to be executed when a new stream is connected
567 * Called from listen connect for peer2
570 stream_read_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
577 * @param status the status of the stream at the time this function is called
578 * @param data traffic from the other side
579 * @param size the number of bytes available in data read
580 * @return number of bytes of processed from 'data' (any data remaining should be
581 * given to the next time the read processor is called).
584 input_processor (void *cls, enum GNUNET_STREAM_Status status,
585 const void *input_data, size_t size)
587 struct PeerData *pdata = cls;
589 if (GNUNET_STREAM_OK != status)
591 GNUNET_SCHEDULER_cancel (abort_task);
592 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
595 GNUNET_assert (size <= DATA_SIZE);
596 if (GNUNET_YES == reset_read)
598 pdata->bytes_read = 0;
599 reset_read = GNUNET_NO;
601 GNUNET_assert ((pdata->bytes_read + size) <= DATA_SIZE);
602 GNUNET_assert (0 == memcmp (((void *)data ) + pdata->bytes_read,
604 pdata->bytes_read += size;
605 pdata->packets_read += (size + payload_size[payload_size_index] - 1)
606 / payload_size[payload_size_index];
607 if (pdata->packets_read < MAX_PACKETS)
609 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == read_task);
610 read_task = GNUNET_SCHEDULER_add_now (&stream_read_task, pdata);
614 LOG (GNUNET_ERROR_TYPE_DEBUG, "Reading finished successfully\n");
621 * Scheduler call back; to be executed when a new stream is connected
622 * Called from listen connect for peer2
625 stream_read_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
627 struct PeerData *pdata = cls;
629 read_task = GNUNET_SCHEDULER_NO_TASK;
630 pdata->io_read_handle =
631 GNUNET_STREAM_read (pdata->socket, GNUNET_TIME_UNIT_FOREVER_REL,
632 &input_processor, pdata);
633 GNUNET_assert (NULL != pdata->io_read_handle);
638 * Functions of this type are called upon new stream connection from other peers
640 * @param cls the closure from GNUNET_STREAM_listen
641 * @param socket the socket representing the stream
642 * @param initiator the identity of the peer who wants to establish a stream
644 * @return GNUNET_OK to keep the socket open, GNUNET_SYSERR to close the
645 * stream (the socket will be invalid after the call)
648 stream_listen_cb (void *cls, struct GNUNET_STREAM_Socket *socket,
649 const struct GNUNET_PeerIdentity *initiator)
651 struct PeerData *pdata = cls;
654 if ((NULL == socket) || (NULL == initiator))
656 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Binding error\n");
657 if (GNUNET_SCHEDULER_NO_TASK != abort_task)
658 GNUNET_SCHEDULER_cancel (abort_task);
659 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
662 GNUNET_assert (NULL != socket);
663 GNUNET_assert (pdata == &peer_data[1]);
664 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer connected: %s\n",
665 GNUNET_i2s(initiator));
666 pdata->socket = socket;
667 pdata->bytes_read = 0;
668 read_task = GNUNET_SCHEDULER_add_now (&stream_read_task, pdata);
674 * Function executed after stream has been established
676 * @param cls the closure from GNUNET_STREAM_open
677 * @param socket socket to use to communicate with the other side (read/write)
680 stream_open_cb (void *cls,
681 struct GNUNET_STREAM_Socket *socket)
683 struct PeerData *pdata = cls;
685 GNUNET_assert (socket == pdata->socket);
686 meter = create_meter (MAX_PACKETS, "Testing Uplink\n", GNUNET_YES);
687 write_task = GNUNET_SCHEDULER_add_now (&stream_write_task, pdata);
692 * Listen success callback; connects a peer to stream as client
695 stream_connect (void)
697 peer_data[0].socket =
698 GNUNET_STREAM_open (config, &peer_data[1].id, 10, &stream_open_cb,
700 GNUNET_STREAM_OPTION_MAX_PAYLOAD_SIZE,
701 payload_size[payload_size_index],
702 GNUNET_STREAM_OPTION_END);
703 GNUNET_assert (NULL != peer_data[0].socket);
708 * Initialize framework and start test
711 * @param cfg configuration of the peer that was started
712 * @param peer identity of the peer that was created
716 const struct GNUNET_CONFIGURATION_Handle *cfg,
717 struct GNUNET_TESTING_Peer *peer)
719 struct GNUNET_PeerIdentity id;
721 GNUNET_TESTING_peer_get_identity (peer, &id);
723 peer2_listen_socket =
724 GNUNET_STREAM_listen (config, 10, &stream_listen_cb, &peer_data[1],
725 GNUNET_STREAM_OPTION_SIGNAL_LISTEN_SUCCESS,
727 GNUNET_STREAM_OPTION_MAX_PAYLOAD_SIZE,
728 payload_size[payload_size_index],
729 GNUNET_STREAM_OPTION_END);
730 GNUNET_assert (NULL != peer2_listen_socket);
731 peer_data[0].id = id;
732 peer_data[1].id = id;
734 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
735 (GNUNET_TIME_UNIT_SECONDS, 300), &do_abort,
741 * Adapter function called to establish a connection to
745 * @param cfg configuration of the peer to connect to; will be available until
746 * GNUNET_TESTBED_operation_done() is called on the operation returned
747 * from GNUNET_TESTBED_service_connect()
748 * @return service handle to return in 'op_result', NULL on error
751 stream_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg);
755 * Adapter function called to destroy a connection to
759 * @param op_result service handle returned from the connect adapter
762 stream_da (void *cls, void *op_result)
764 if (&peer_data[1] == cls)
766 GNUNET_STREAM_listen_close (op_result);
769 else if (&peer_data[0] == cls)
771 GNUNET_STREAM_close (op_result);
779 * Listen success callback; connects a peer to stream as client. Called from
783 stream_connect2 (void)
785 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stream listen open successful\n");
787 GNUNET_TESTBED_service_connect (&peer_data[0], peer_data[0].peer,
788 "stream", NULL, NULL, stream_ca,
789 stream_da, &peer_data[0]);
794 * Adapter function called to establish a connection to
798 * @param cfg configuration of the peer to connect to; will be available until
799 * GNUNET_TESTBED_operation_done() is called on the operation returned
800 * from GNUNET_TESTBED_service_connect()
801 * @return service handle to return in 'op_result', NULL on error
804 stream_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
806 struct PeerData *pdata = cls;
808 if (&peer_data[1] == pdata)
810 peer2_listen_socket = NULL;
811 peer2_listen_socket =
812 GNUNET_STREAM_listen (cfg, 10, &stream_listen_cb, &peer_data[1],
813 GNUNET_STREAM_OPTION_SIGNAL_LISTEN_SUCCESS,
815 GNUNET_STREAM_OPTION_MAX_PAYLOAD_SIZE,
816 payload_size[payload_size_index],
817 GNUNET_STREAM_OPTION_END);
818 GNUNET_assert (NULL != peer2_listen_socket);
819 return peer2_listen_socket;
821 if (&peer_data[0] == pdata)
824 GNUNET_STREAM_open (cfg, &peer_data[1].id, 10, &stream_open_cb,
826 GNUNET_STREAM_OPTION_MAX_PAYLOAD_SIZE,
827 payload_size[payload_size_index],
828 GNUNET_STREAM_OPTION_END);
829 GNUNET_assert (NULL != pdata->socket);
830 return pdata->socket;
838 * Callback to be called when the requested peer information is available
840 * @param cb_cls the closure from GNUNET_TETSBED_peer_get_information()
841 * @param op the operation this callback corresponds to
842 * @param pinfo the result; will be NULL if the operation has failed
843 * @param emsg error message if the operation has failed; will be NULL if the
844 * operation is successfull
847 peerinfo_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op,
848 const struct GNUNET_TESTBED_PeerInformation *pinfo,
851 struct PeerData *pdata = cb_cls;
853 GNUNET_assert (NULL == emsg);
854 GNUNET_assert (common_op == op);
855 GNUNET_assert (NULL != pdata);
856 memcpy (&pdata->id, pinfo->result.id, sizeof (struct GNUNET_PeerIdentity));
857 GNUNET_TESTBED_operation_done (op);
858 if (pdata == &peer_data[0])
860 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer 1 id: %s\n",
861 GNUNET_i2s (&pdata->id));
862 common_op = GNUNET_TESTBED_peer_get_information (peer_data[1].peer,
863 GNUNET_TESTBED_PIT_IDENTITY,
864 &peerinfo_cb, &peer_data[1]);
866 else if (pdata == &peer_data[1])
868 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer 2 id: %s\n",
869 GNUNET_i2s (&pdata->id));
870 if (TEST_STEP_2_HOP == test_step)
872 GNUNET_TESTBED_service_connect (&peer_data[1], peer_data[1].peer,
873 "stream", NULL, NULL, stream_ca,
874 stream_da, &peer_data[1]);
876 GNUNET_break (0); /* FIXME: 3 hop test case here... */
882 * Controller event callback
885 * @param event the controller event
888 controller_event_cb (void *cls,
889 const struct GNUNET_TESTBED_EventInformation *event)
893 case GNUNET_TESTBED_ET_OPERATION_FINISHED:
894 if (NULL != event->details.operation_finished.emsg)
896 FPRINTF (stderr, "Error while expecting an operation to succeed:%s \n",
897 event->details.operation_finished.emsg);
901 case GNUNET_TESTBED_ET_CONNECT:
902 GNUNET_TESTBED_operation_done (common_op);
903 /* Get the peer identity and configuration of peers */
905 GNUNET_TESTBED_peer_get_information (peer_data[0].peer,
906 GNUNET_TESTBED_PIT_IDENTITY,
907 &peerinfo_cb, &peer_data[0]);
916 * Signature of a main function for a testcase.
919 * @param num_peers number of peers in 'peers'
920 * @param peers handle to peers run in the testbed
923 test_master (void *cls, unsigned int num_peers_,
924 struct GNUNET_TESTBED_Peer **peers)
926 GNUNET_assert (NULL != peers);
927 GNUNET_assert (NULL != peers[0]);
928 GNUNET_assert (NULL != peers[1]);
929 GNUNET_assert (num_peers_ == num_peers);
930 peer_data[0].peer = peers[0];
931 peer_data[1].peer = peers[1];
933 common_op = GNUNET_TESTBED_overlay_connect (NULL, NULL, NULL,
939 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
940 (GNUNET_TIME_UNIT_SECONDS, 120), &do_abort,
948 int main (int argc, char **argv)
950 char *test_name = "perf_stream_api";
951 char *cfg_file = "test_stream_local.conf";
956 meter = create_meter ((sizeof (data) / 4), "Generating random data\n", GNUNET_YES);
957 for (count=0; count < (sizeof (data) / 4); count++)
959 data[count] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
961 update_meter (meter);
966 test_step = TEST_STEP_1_HOP;
967 for (payload_size_index = 0;
968 payload_size_index < (sizeof (payload_size) / sizeof (uint16_t));
969 payload_size_index++)
971 PRINTF ("\nTesting over loopback with payload size %hu\n",
972 payload_size[payload_size_index]);
973 (void) memset (peer_data, 0, sizeof (peer_data));
975 reset_read = GNUNET_NO;
976 ret = GNUNET_TESTING_peer_run (test_name, cfg_file, &run, NULL);
977 if ((0 != ret) || (DOWNLINK_OK != result))
980 test_step = TEST_STEP_2_HOP;
983 event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
984 event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
985 for (payload_size_index = 0;
986 payload_size_index < (sizeof (payload_size) / sizeof (uint16_t));
987 payload_size_index++)
989 PRINTF ("\nTesting over 1 hop with payload size %hu\n",
990 payload_size[payload_size_index]);
991 (void) memset (peer_data, 0, sizeof (peer_data));
993 reset_read = GNUNET_NO;
994 GNUNET_TESTBED_test_run (test_name, cfg_file, num_peers, event_mask,
995 &controller_event_cb, NULL, &test_master, NULL);
996 if (DOWNLINK_OK != result)
999 test_step = TEST_STEP_3_HOP;
1000 for (payload_size_index = 0;
1001 payload_size_index < (sizeof (payload_size) / sizeof (uint16_t));
1002 payload_size_index++)
1004 /* Initialize testbed here */
1009 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test failed\n");
1013 /* end of perf_stream_api.c */