X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fcore%2Ftest_core_quota_compliance.c;h=d951113fc908c14dd4a99ea4e72cd4f9bb126286;hb=5b79d2a877b71d5e718328784fd69725efa1d38d;hp=d144dd4b3b02102aa615b74354d4e97207f765a1;hpb=b65e40508cbfd1eef561529e110efcace93037e2;p=oweals%2Fgnunet.git diff --git a/src/core/test_core_quota_compliance.c b/src/core/test_core_quota_compliance.c index d144dd4b3..d951113fc 100644 --- a/src/core/test_core_quota_compliance.c +++ b/src/core/test_core_quota_compliance.c @@ -20,9 +20,6 @@ /** * @file core/test_core_quota_compliance.c * @brief testcase for core_api.c focusing quota compliance on core level - * - * FIXME: - * - make sure connect callback is invoked properly as well! */ #include "platform.h" #include "gnunet_common.h" @@ -34,8 +31,14 @@ #include "gnunet_program_lib.h" #include "gnunet_scheduler_lib.h" #include "gnunet_transport_service.h" +#include "gnunet_statistics_service.h" #define VERBOSE GNUNET_NO +#define DEBUG_TRANSMISSION GNUNET_NO + +#define SYMMETRIC 0 +#define ASYMMETRIC_SEND_LIMITED 1 +#define ASYMMETRIC_RECV_LIMITED 2 #define START_ARM GNUNET_YES @@ -44,12 +47,12 @@ * 'MAX_PENDING' in 'gnunet-service-transport.c', otherwise * messages may be dropped even for a reliable transport. */ -#define TOTAL_MSGS (60 * 10) +#define TOTAL_MSGS (60000 * 10) /** * How long until we give up on transmitting the message? */ -#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) +#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 180) /** * What delay do we request from the core service for transmission? @@ -59,10 +62,11 @@ #define FAST_TIMEOUT GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_MAX_CORK_DELAY, 2) #define MTYPE 12345 -#define MSIZE 1024 +#define MESSAGESIZE 1024 #define MEASUREMENT_LENGTH GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) -static unsigned long long total_bytes; +static unsigned long long total_bytes_sent; +static unsigned long long total_bytes_recv; static struct GNUNET_TIME_Absolute start_time; @@ -78,6 +82,7 @@ struct PeerContext struct GNUNET_PeerIdentity id; struct GNUNET_TRANSPORT_Handle *th; struct GNUNET_MessageHeader *hello; + struct GNUNET_STATISTICS_Handle *stats; int connect_status; #if START_ARM struct GNUNET_OS_Process *arm_proc; @@ -85,11 +90,15 @@ struct PeerContext }; static struct PeerContext p1; - static struct PeerContext p2; -static int ok; +static unsigned long long current_quota_p1_in; +static unsigned long long current_quota_p1_out; +static unsigned long long current_quota_p2_in; +static unsigned long long current_quota_p2_out; +static int ok; +static int test; static int32_t tr_n; static int running; @@ -110,29 +119,27 @@ struct TestMessage static void terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - unsigned long long delta; + struct GNUNET_CORE_Handle *ch; - GNUNET_CORE_disconnect (p1.ch); + ch = p1.ch; p1.ch = NULL; - GNUNET_CORE_disconnect (p2.ch); + GNUNET_CORE_disconnect (ch); + ch = p2.ch; p2.ch = NULL; + GNUNET_CORE_disconnect (ch); GNUNET_TRANSPORT_disconnect (p1.th); p1.th = NULL; GNUNET_TRANSPORT_disconnect (p2.th); p2.th = NULL; - delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value; - fprintf (stderr, - "\nThroughput was %llu kb/s\n", - total_bytes * 1000 / 1024 / delta); - ok = 0; } static void terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Testcase timout, exit!\n"); - GNUNET_break (0); + if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Testcase failed!\n"); + //GNUNET_break (0); if (measure_task != GNUNET_SCHEDULER_NO_TASK) GNUNET_SCHEDULER_cancel(measure_task); @@ -148,14 +155,151 @@ terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) ok = 42; } + +/** + * Callback function to process statistic values. + * + * @param cls closure + * @param subsystem name of subsystem that created the statistic + * @param name the name of the datum + * @param value the current value + * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not + * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration + */ +static int +print_stat (void *cls, + const char *subsystem, + const char *name, + uint64_t value, + int is_persistent) +{ + if (cls==&p1) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Peer1 %50s = %12llu\n", + name, + (unsigned long long) value); + if (cls==&p2) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Peer2 %50s = %12llu\n", + name, + (unsigned long long) value); + return GNUNET_OK; +} + static void measurement_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { + unsigned long long int delta; + unsigned long long int throughput_out; + unsigned long long int throughput_in; + unsigned long long int max_quota_in; + unsigned long long int max_quota_out; + unsigned long long int quota_delta; + measure_task = GNUNET_SCHEDULER_NO_TASK; fprintf(stdout,"\n"); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "FINIIISH!\n"); running = GNUNET_NO; + delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value; + + throughput_out = total_bytes_sent * 1000 / 1024 / delta; + throughput_in = total_bytes_recv * 1000 / 1024 / delta; + + if (current_quota_p1_in < current_quota_p2_in) + max_quota_in = current_quota_p1_in; + else + max_quota_in = current_quota_p2_in; + if (current_quota_p1_out < current_quota_p2_out) + max_quota_out = current_quota_p1_out; + else + max_quota_out = current_quota_p2_out; + + if (max_quota_out < max_quota_in) + quota_delta = max_quota_in / 10; + else + quota_delta = max_quota_out / 10; + + if ((throughput_out > (max_quota_out+quota_delta)/1024) || (throughput_in > (max_quota_in+quota_delta)/1024)) + ok = 1; + else + ok = 0; + + GNUNET_STATISTICS_get (p1.stats, + "core", + "# discarded CORE_SEND requests", + GNUNET_TIME_UNIT_FOREVER_REL, + NULL, + &print_stat, &p1); + + GNUNET_STATISTICS_get (p1.stats, + "core", + "# discarded CORE_SEND request bytes", + GNUNET_TIME_UNIT_FOREVER_REL, + NULL, + &print_stat, &p1); + GNUNET_STATISTICS_get (p1.stats, + "core", + "# discarded lower priority CORE_SEND requests", + GNUNET_TIME_UNIT_FOREVER_REL, + NULL, + &print_stat, NULL); + GNUNET_STATISTICS_get (p1.stats, + "core", + "# discarded lower priority CORE_SEND request bytes", + GNUNET_TIME_UNIT_FOREVER_REL, + NULL, + &print_stat, &p1); + GNUNET_STATISTICS_get (p2.stats, + "core", + "# discarded CORE_SEND requests", + GNUNET_TIME_UNIT_FOREVER_REL, + NULL, + &print_stat, &p2); + + GNUNET_STATISTICS_get (p2.stats, + "core", + "# discarded CORE_SEND request bytes", + GNUNET_TIME_UNIT_FOREVER_REL, + NULL, + &print_stat, &p2); + GNUNET_STATISTICS_get (p2.stats, + "core", + "# discarded lower priority CORE_SEND requests", + GNUNET_TIME_UNIT_FOREVER_REL, + NULL, + &print_stat, &p2); + GNUNET_STATISTICS_get (p2.stats, + "core", + "# discarded lower priority CORE_SEND request bytes", + GNUNET_TIME_UNIT_FOREVER_REL, + NULL, + &print_stat, &p2); + + enum GNUNET_ErrorType kind = GNUNET_ERROR_TYPE_DEBUG; + if (ok==1) + { + kind = GNUNET_ERROR_TYPE_ERROR; + } + switch (test) + { + case SYMMETRIC: + GNUNET_log (kind,"Core quota compliance test with symmetric quotas: %s\n", (ok==0)?"PASSED":"FAILED"); + break; + case ASYMMETRIC_SEND_LIMITED: + GNUNET_log (kind,"Core quota compliance test with limited sender quota: %s\n", (ok==0)?"PASSED":"FAILED"); + break; + case ASYMMETRIC_RECV_LIMITED: + GNUNET_log (kind,"Core quota compliance test with limited receiver quota: %s\n", (ok==0)?"PASSED":"FAILED"); + break; + }; + GNUNET_log (kind,"Peer 1 send rate: %llu kB/s (%llu Bytes in %u sec.)\n",throughput_out,total_bytes_sent, delta/1000); + GNUNET_log (kind,"Peer 1 send quota: %llu kB/s\n",current_quota_p1_out / 1024); + GNUNET_log (kind,"Peer 2 receive rate: %llu kB/s (%llu Bytes in %u sec.)\n",throughput_in,total_bytes_recv, delta/1000); + GNUNET_log (kind,"Peer 2 receive quota: %llu kB/s\n",current_quota_p2_in / 1024); +/* + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Max. inbound quota allowed: %llu kB/s\n",max_quota_in /1024); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Max. outbound quota allowed: %llu kB/s\n",max_quota_out/1024); +*/ GNUNET_SCHEDULER_cancel (err_task); GNUNET_SCHEDULER_add_now (&terminate_task, NULL); @@ -166,59 +310,54 @@ transmit_ready (void *cls, size_t size, void *buf) { char *cbuf = buf; struct TestMessage hdr; - unsigned int s; unsigned int ret; GNUNET_assert (size <= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE); if (buf == NULL) { - if (p1.ch != NULL) + if ( (p1.ch != NULL) && + (p1.connect_status == 1) ) GNUNET_break (NULL != GNUNET_CORE_notify_transmit_ready (p1.ch, 0, FAST_TIMEOUT, &p2.id, - MSIZE, + MESSAGESIZE, &transmit_ready, &p1)); return 0; } GNUNET_assert (tr_n < TOTAL_MSGS); ret = 0; - s = MSIZE; - GNUNET_assert (size >= s); + GNUNET_assert (size >= MESSAGESIZE); GNUNET_assert (buf != NULL); cbuf = buf; do { -#if VERBOSE +#if DEBUG_TRANSMISSION GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending message %u of size %u at offset %u\n", tr_n, - s, + MESSAGESIZE, ret); #endif - hdr.header.size = htons (s); + hdr.header.size = htons (MESSAGESIZE); hdr.header.type = htons (MTYPE); hdr.num = htonl (tr_n); memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage)); ret += sizeof (struct TestMessage); - memset (&cbuf[ret], tr_n, s - sizeof (struct TestMessage)); - ret += s - sizeof (struct TestMessage); + memset (&cbuf[ret], tr_n, MESSAGESIZE - sizeof (struct TestMessage)); + ret += MESSAGESIZE - sizeof (struct TestMessage); tr_n++; - s = MSIZE; if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16)) break; /* sometimes pack buffer full, sometimes not */ } - while (size - ret >= s); + while (size - ret >= MESSAGESIZE); GNUNET_SCHEDULER_cancel (err_task); err_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &terminate_task_error, NULL); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Returning total message block of size %u\n", - ret); - total_bytes += ret; + total_bytes_sent += ret; return ret; } @@ -231,16 +370,23 @@ connect_notify (void *cls, { struct PeerContext *pc = cls; + if (0 == memcmp (&pc->id, + peer, + sizeof (struct GNUNET_PeerIdentity))) + return; GNUNET_assert (pc->connect_status == 0); pc->connect_status = 1; if (pc == &p1) { +#if DEBUG_TRANSMISSION GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypted connection established to peer `%4s'\n", GNUNET_i2s (peer)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking core (1) for transmission to peer `%4s'\n", GNUNET_i2s (&p2.id)); +#endif + if (err_task != GNUNET_SCHEDULER_NO_TASK) GNUNET_SCHEDULER_cancel (err_task); err_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &terminate_task_error, NULL); @@ -252,7 +398,7 @@ connect_notify (void *cls, 0, TIMEOUT, &p2.id, - MSIZE, + MESSAGESIZE, &transmit_ready, &p1)); } } @@ -263,9 +409,16 @@ disconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer) { struct PeerContext *pc = cls; + + if (0 == memcmp (&pc->id, + peer, + sizeof (struct GNUNET_PeerIdentity))) + return; pc->connect_status = 0; +#if DEBUG_TRANSMISSION GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypted connection to `%4s' cut\n", GNUNET_i2s (peer)); +#endif } @@ -275,10 +428,11 @@ inbound_notify (void *cls, const struct GNUNET_MessageHeader *message, const struct GNUNET_TRANSPORT_ATS_Information *atsi) { -#if VERBOSE +#if DEBUG_TRANSMISSION GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Core provides inbound data from `%4s'.\n", GNUNET_i2s (other)); + "Core provides inbound data from `%4s' %llu.\n", GNUNET_i2s (other), ntohs(message->size)); #endif + total_bytes_recv += ntohs(message->size); return GNUNET_OK; } @@ -289,7 +443,7 @@ outbound_notify (void *cls, const struct GNUNET_MessageHeader *message, const struct GNUNET_TRANSPORT_ATS_Information *atsi) { -#if VERBOSE +#if DEBUG_TRANSMISSION GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Core notifies about outbound data for `%4s'.\n", GNUNET_i2s (other)); @@ -308,18 +462,16 @@ process_mtype (void *cls, const struct GNUNET_TRANSPORT_ATS_Information *atsi) { static int n; - unsigned int s; const struct TestMessage *hdr; hdr = (const struct TestMessage*) message; - s = MSIZE; if (MTYPE != ntohs (message->type)) return GNUNET_SYSERR; - if (ntohs (message->size) != s) + if (ntohs (message->size) != MESSAGESIZE) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Expected message %u of size %u, got %u bytes of message %u\n", - n, s, + n, MESSAGESIZE, ntohs (message->size), ntohl (hdr->num)); GNUNET_SCHEDULER_cancel (err_task); @@ -330,38 +482,32 @@ process_mtype (void *cls, { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Expected message %u of size %u, got %u bytes of message %u\n", - n, s, + n, MESSAGESIZE, ntohs (message->size), ntohl (hdr->num)); GNUNET_SCHEDULER_cancel (err_task); err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL); return GNUNET_SYSERR; } -#if VERBOSE +#if DEBUG_TRANSMISSION GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got message %u of size %u\n", ntohl (hdr->num), ntohs (message->size)); #endif n++; - if (0 == (n % (TOTAL_MSGS/100))) + if (0 == (n % 10)) fprintf (stderr, "."); - if (n == TOTAL_MSGS) - { - GNUNET_SCHEDULER_cancel (err_task); - GNUNET_SCHEDULER_add_now (&terminate_task, NULL); - } - else - { - if (running == GNUNET_YES) + + + if (running == GNUNET_YES) GNUNET_break (NULL != GNUNET_CORE_notify_transmit_ready (p1.ch, 0, FAST_TIMEOUT, &p2.id, - MSIZE, + MESSAGESIZE, &transmit_ready, &p1)); - } return GNUNET_OK; } @@ -407,9 +553,11 @@ init_notify (void *cls, GNUNET_assert (ok == 3); OKPP; GNUNET_assert (cls == &p2); +#if DEBUG_TRANSMISSION GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking core (1) to connect to peer `%4s'\n", GNUNET_i2s (&p2.id)); +#endif GNUNET_CORE_peer_request_connect (p1.ch, GNUNET_TIME_UNIT_SECONDS, &p2.id, @@ -425,9 +573,12 @@ process_hello (void *cls, struct PeerContext *p = cls; GNUNET_TRANSPORT_get_hello_cancel (p->th, &process_hello, p); + +#if DEBUG_TRANSMISSION GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received (my) `%s' from transport service\n", "HELLO"); +#endif GNUNET_assert (message != NULL); p->hello = GNUNET_malloc (ntohs (message->size)); memcpy (p->hello, message, ntohs (message->size)); @@ -457,6 +608,8 @@ setup_peer (struct PeerContext *p, const char *cfgname) "-c", cfgname, NULL); #endif GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); + p->stats = GNUNET_STATISTICS_create ("core",p->cfg); + GNUNET_assert (p->stats!=NULL); p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL, NULL, NULL); GNUNET_assert (p->th != NULL); GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p); @@ -471,8 +624,43 @@ run (void *cls, { GNUNET_assert (ok == 1); OKPP; - setup_peer (&p1, "test_core_quota_peer1.conf"); - setup_peer (&p2, "test_core_quota_peer2.conf"); + err_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, + &terminate_task_error, + NULL); + if (test == SYMMETRIC) + { + setup_peer (&p1, "test_core_quota_peer1.conf"); + setup_peer (&p2, "test_core_quota_peer2.conf"); + } + else if (test == ASYMMETRIC_SEND_LIMITED) + { + setup_peer (&p1, "test_core_quota_asymmetric_send_limit_peer1.conf"); + setup_peer (&p2, "test_core_quota_asymmetric_send_limit_peer2.conf"); + } + else if (test == ASYMMETRIC_RECV_LIMITED) + { + setup_peer (&p1, "test_core_quota_asymmetric_recv_limited_peer1.conf"); + setup_peer (&p2, "test_core_quota_asymmetric_recv_limited_peer2.conf"); + } + + GNUNET_assert (test != -1); + GNUNET_assert (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_number (p1.cfg, + "CORE", + "TOTAL_QUOTA_IN", + ¤t_quota_p1_in)); + GNUNET_assert (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_number (p2.cfg, + "CORE", + "TOTAL_QUOTA_IN", + ¤t_quota_p2_in)); + GNUNET_assert (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_number (p1.cfg, + "CORE", + "TOTAL_QUOTA_OUT", + ¤t_quota_p1_out)); + GNUNET_assert (GNUNET_SYSERR != GNUNET_CONFIGURATION_get_value_number (p2.cfg, + "CORE", + "TOTAL_QUOTA_OUT", + ¤t_quota_p2_out)); + GNUNET_CORE_connect (p1.cfg, 1, &p1, &init_notify, @@ -503,6 +691,8 @@ stop_arm (struct PeerContext *p) static int check () { + + char *const argv[] = { "test-core-quota-compliance", "-c", "test_core_api_data.conf", @@ -527,6 +717,36 @@ main (int argc, char *argv[]) { int ret; + test = -1; + if (strstr(argv[0], "_symmetric") != NULL) + { + test = SYMMETRIC; + } + else if (strstr(argv[0], "_asymmetric_send") != NULL) + { + test = ASYMMETRIC_SEND_LIMITED; + } + else if (strstr(argv[0], "_asymmetric_recv") != NULL) + { + test = ASYMMETRIC_RECV_LIMITED; + } + GNUNET_assert (test != -1); + if (test == SYMMETRIC) + { + GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-sym-peer-1/"); + GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-sym-peer-2/"); + } + else if (test == ASYMMETRIC_SEND_LIMITED) + { + GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-send-lim-peer-1/"); + GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-send-lim-peer-2/"); + } + else if (test == ASYMMETRIC_RECV_LIMITED) + { + GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-recv-lim-peer-1/"); + GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-recv-lim-peer-2/"); + } + GNUNET_log_setup ("test-core-quota-compliance", #if VERBOSE "DEBUG", @@ -535,8 +755,23 @@ main (int argc, char *argv[]) #endif NULL); ret = check (); - GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1"); - GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-2"); + if (test == SYMMETRIC) + { + GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-sym-peer-1/"); + GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-sym-peer-2/"); + } + else if (test == ASYMMETRIC_SEND_LIMITED) + { + GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-send-lim-peer-1/"); + GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-send-lim-peer-2/"); + } + else if (test == ASYMMETRIC_RECV_LIMITED) + { + GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-recv-lim-peer-1/"); + GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-quota-asym-recv-lim-peer-2/"); + } + + return ret; }