X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fcore%2Ftest_core_quota_compliance.c;h=d951113fc908c14dd4a99ea4e72cd4f9bb126286;hb=5b79d2a877b71d5e718328784fd69725efa1d38d;hp=d42149099dedc4ee4ff0b14cb96cf3d1ccb3c150;hpb=cd3497d84532959a26c05342d01ea7107b146358;p=oweals%2Fgnunet.git diff --git a/src/core/test_core_quota_compliance.c b/src/core/test_core_quota_compliance.c index d42149099..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,10 +31,15 @@ #include "gnunet_program_lib.h" #include "gnunet_scheduler_lib.h" #include "gnunet_transport_service.h" +#include "gnunet_statistics_service.h" -#define VERBOSE GNUNET_YES +#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 /** @@ -45,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? @@ -60,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; @@ -79,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; @@ -94,7 +98,7 @@ 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; @@ -115,10 +119,14 @@ struct TestMessage static void terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - GNUNET_CORE_disconnect (p1.ch); + struct GNUNET_CORE_Handle *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); @@ -129,8 +137,9 @@ terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 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); @@ -146,11 +155,43 @@ 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; + 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; @@ -160,7 +201,10 @@ measurement_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) running = GNUNET_NO; delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value; - throughput = total_bytes * 1000 / 1024 / delta; + + 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 @@ -175,18 +219,87 @@ measurement_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) else quota_delta = max_quota_out / 10; - if ((throughput < (max_quota_out/1024)) && (throughput < (max_quota_in/1024))) - { - ok = 0; - } + 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) { - ok = 1; + kind = GNUNET_ERROR_TYPE_ERROR; } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Throughput: %llu kb/s\n",throughput); - 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); - + 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); @@ -197,26 +310,25 @@ 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 @@ -225,28 +337,27 @@ transmit_ready (void *cls, size_t size, void *buf) 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); - total_bytes += ret; + total_bytes_sent += ret; return ret; } @@ -259,6 +370,10 @@ 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) @@ -271,6 +386,7 @@ connect_notify (void *cls, "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); @@ -282,7 +398,7 @@ connect_notify (void *cls, 0, TIMEOUT, &p2.id, - MSIZE, + MESSAGESIZE, &transmit_ready, &p1)); } } @@ -293,6 +409,11 @@ 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, @@ -309,8 +430,9 @@ inbound_notify (void *cls, { #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; } @@ -345,11 +467,11 @@ process_mtype (void *cls, hdr = (const struct TestMessage*) message; if (MTYPE != ntohs (message->type)) return GNUNET_SYSERR; - if (ntohs (message->size) != MSIZE) + 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, MSIZE, + n, MESSAGESIZE, ntohs (message->size), ntohl (hdr->num)); GNUNET_SCHEDULER_cancel (err_task); @@ -360,7 +482,7 @@ process_mtype (void *cls, { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Expected message %u of size %u, got %u bytes of message %u\n", - n, MSIZE, + n, MESSAGESIZE, ntohs (message->size), ntohl (hdr->num)); GNUNET_SCHEDULER_cancel (err_task); @@ -374,24 +496,18 @@ process_mtype (void *cls, 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; } @@ -492,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); @@ -506,9 +624,26 @@ 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", @@ -556,6 +691,8 @@ stop_arm (struct PeerContext *p) static int check () { + + char *const argv[] = { "test-core-quota-compliance", "-c", "test_core_api_data.conf", @@ -580,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", @@ -588,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; }