*/
#define UTIL_TRANSMISSION_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
-#define DEBUG_MALLOC GNUNET_NO
-
-#if DEBUG_MALLOC
-
-struct Allocator
-{
- struct Allocator *prev;
- struct Allocator *next;
-
- unsigned int bytes_alloced;
- unsigned int max_alloced;
- unsigned int diff;
- unsigned int line;
-
- struct GNUNET_TIME_Absolute max_alloced_when;
- struct GNUNET_TIME_Absolute last_alloced_when;
-
-};
-
-struct Allocator *aehead;
-struct Allocator *aetail;
-
-struct Allocation
-{
- struct Allocation *prev;
- struct Allocation *next;
-
- struct Allocator *alloc;
- unsigned int bytes_alloced;
- void *p;
- unsigned int line;
-};
-
-struct Allocation *ahead;
-struct Allocation *atail;
-
-static int bytes_alloced;
-
-static struct Allocator *
-find_allocator (int line)
-{
- struct Allocator *cur = aehead;
- while (NULL != cur)
- {
- if (line == cur->line)
- return cur;
- cur = cur->next;
- }
- return cur;
-}
-
-static void
-print_allocators ()
-{
- static int start = GNUNET_YES;
- static struct GNUNET_TIME_Absolute next;
- static struct GNUNET_TIME_Relative rem;
- struct Allocator *cur = aehead;
- if (start)
- {
- next = GNUNET_TIME_UNIT_ZERO_ABS;
- start = GNUNET_NO;
- }
- if (0 == (rem = GNUNET_TIME_absolute_get_remaining(next)).rel_value_us)
- {
- fprintf (stderr, "Allocated in `%s' total: %5u bytes\n", __FILE__, bytes_alloced);
- while (NULL != cur)
- {
- char *last_alloc = GNUNET_strdup (GNUNET_STRINGS_absolute_time_to_string(cur->max_alloced_when));
- fprintf (stderr, "Allocated from line %4u :%5u bytes (diff %5i bytes, max alloc: %5u @ %s, last alloc %s)\n",
- cur->line, cur->bytes_alloced, cur->diff, cur->max_alloced,
- last_alloc,
- GNUNET_STRINGS_absolute_time_to_string(cur->last_alloced_when));
- GNUNET_free (last_alloc);
- cur->diff = 0;
- cur = cur->next;
- }
- fprintf (stderr, "\n");
- next = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_SECONDS);
- }
-}
-
-#endif
-
-static void
-MEMDEBUG_add_alloc (void *p, size_t size, int line)
-{
-#if DEBUG_MALLOC
- struct Allocation *alloc = GNUNET_malloc (sizeof (struct Allocation));
- struct Allocator *allocator = find_allocator(line);
- if (NULL == allocator)
- {
- allocator = GNUNET_malloc (sizeof (struct Allocator));
- allocator->line = line;
- GNUNET_CONTAINER_DLL_insert (aehead, aetail, allocator);
- }
- alloc->alloc = allocator;
- alloc->p = p;
- alloc->line = line;
- alloc->bytes_alloced = size;
- allocator->bytes_alloced += size;
- allocator->last_alloced_when = GNUNET_TIME_absolute_get();
- if (allocator->bytes_alloced >= allocator->max_alloced)
- {
- allocator->max_alloced = allocator->bytes_alloced;
- allocator->max_alloced_when = allocator->last_alloced_when;
- }
- allocator->diff += size;
- GNUNET_CONTAINER_DLL_insert (ahead, atail, alloc);
- print_allocators ();
- bytes_alloced += size;
-#endif
-}
-
-
-static void *
-MEMDEBUG_malloc (size_t size, int line)
-{
- void * ret;
-
- ret = GNUNET_malloc (size);
-#if DEBUG_MALLOC
- if (NULL != ret)
- MEMDEBUG_add_alloc (ret, size, line);
-#endif
- return ret;
-
-}
-
-static void
-MEMDEBUG_free (void * alloc, int line)
-{
-#if DEBUG_MALLOC
- struct Allocation *cur;
- struct Allocator *allocator;
- cur = ahead;
- while (NULL != cur)
- {
- if (alloc == cur->p)
- break;
- cur = cur->next;
- }
- if (NULL == cur)
- {
- fprintf (stderr, "Unmonitored free from line %4u\n", line);
- GNUNET_break (0);
- return;
- }
- allocator = cur->alloc;
- if (NULL == allocator)
- {
- GNUNET_break (0);
- }
- GNUNET_CONTAINER_DLL_remove (ahead, atail, cur);
- allocator->bytes_alloced -= cur->bytes_alloced;
- allocator->diff -= cur->bytes_alloced;
- GNUNET_assert (allocator->bytes_alloced >= 0);
- bytes_alloced -= cur->bytes_alloced;
- GNUNET_assert (bytes_alloced >= 0);
- GNUNET_free (cur);
-#endif
- GNUNET_free (alloc);
-}
-
-static void
-MEMDEBUG_free_non_null (void * alloc, int line)
-{
- if (alloc != NULL)
- MEMDEBUG_free (alloc, line);
-}
-
-
GNUNET_NETWORK_STRUCT_BEGIN
/**
/**
* Tracking utilization of outbound bandwidth
*/
- unsigned int util_bytes_sent;
+ uint32_t util_payload_bytes_sent;
/**
* Tracking utilization of inbound bandwidth
*/
- unsigned int util_bytes_recv;
+ uint32_t util_payload_bytes_recv;
+
+ /**
+ * Tracking utilization of outbound bandwidth
+ */
+ uint32_t util_total_bytes_sent;
+
+ /**
+ * Tracking utilization of inbound bandwidth
+ */
+ uint32_t util_total_bytes_recv;
+
+
/**
na->ats_active = GNUNET_NO;
if (NULL != na->address)
{
- MEMDEBUG_free (na->address, __LINE__);
- //GNUNET_HELLO_address_free (na->address);
+ GNUNET_HELLO_address_free (na->address);
na->address = NULL;
}
na->session = NULL;
return;
}
na->address = GNUNET_HELLO_address_copy (address);
- MEMDEBUG_add_alloc (na->address, GNUNET_HELLO_address_get_size (na->address), __LINE__);
na->bandwidth_in = bandwidth_in;
na->bandwidth_out = bandwidth_out;
na->session = session;
GNUNET_CONTAINER_DLL_remove (n->messages_head, n->messages_tail, mq);
if (NULL != mq->cont)
mq->cont (mq->cont_cls, GNUNET_SYSERR, mq->message_buf_size, 0);
- MEMDEBUG_free (mq, __LINE__);
+ GNUNET_free (mq);
}
/* It is too late to send other peer disconnect notifications, but at
least internally we need to get clean... */
if (NULL != n->primary_address.address)
{
backup_primary = GNUNET_HELLO_address_copy(n->primary_address.address);
- MEMDEBUG_add_alloc (backup_primary, GNUNET_HELLO_address_get_size(backup_primary), __LINE__);
}
else
backup_primary = NULL;
(NULL != (papi = GST_plugins_find (backup_primary->transport_name))))
papi->disconnect (papi->cls, &n->id);
- MEMDEBUG_free_non_null (backup_primary, __LINE__);
+ GNUNET_free_non_null (backup_primary);
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multipeermap_remove (neighbours,
n->task = GNUNET_SCHEDULER_NO_TASK;
}
/* free rest of memory */
- MEMDEBUG_free (n, __LINE__);
+ GNUNET_free (n);
}
/**
if (NULL == (n = lookup_neighbour (receiver)))
{
- MEMDEBUG_free (mq, __LINE__);
+ GNUNET_free (mq);
return; /* disconnect or other error while transmitting, can happen */
}
if (n->is_active == mq)
("# bytes in message queue for other peers"),
bytes_in_send_queue, GNUNET_NO);
if (GNUNET_OK == success)
- {
- n->util_bytes_sent += size_payload;
GNUNET_STATISTICS_update (GST_stats,
gettext_noop
("# messages transmitted to other peers"),
1, GNUNET_NO);
- }
else
GNUNET_STATISTICS_update (GST_stats,
gettext_noop
(success == GNUNET_OK) ? "success" : "FAILURE");
if (NULL != mq->cont)
mq->cont (mq->cont_cls, success, size_payload, physical);
- MEMDEBUG_free (mq, __LINE__);
+ GNUNET_free (mq);
}
gettext_noop
("# bytes in message queue for other peers"),
bytes_in_send_queue, GNUNET_NO);
- mq = MEMDEBUG_malloc (sizeof (struct MessageQueue) + msg_size, __LINE__);
+ mq = GNUNET_malloc (sizeof (struct MessageQueue) + msg_size);
mq->cont = cont;
mq->cont_cls = cont_cls;
memcpy (&mq[1], msg, msg_size);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Creating new neighbour entry for `%s'\n",
GNUNET_i2s (peer));
- n = MEMDEBUG_malloc (sizeof (struct NeighbourMapEntry), __LINE__);
+ n = GNUNET_malloc (sizeof (struct NeighbourMapEntry));
n->id = *peer;
n->state = S_NOT_CONNECTED;
n->latency = GNUNET_TIME_UNIT_FOREVER_REL;
n->last_util_transmission = GNUNET_TIME_absolute_get();
- n->util_bytes_recv = 0;
- n->util_bytes_sent = 0;
+ n->util_payload_bytes_recv = 0;
+ n->util_payload_bytes_sent = 0;
+ n->util_total_bytes_recv = 0;
+ n->util_total_bytes_sent = 0;
GNUNET_BANDWIDTH_tracker_init (&n->in_tracker,
GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
MAX_BANDWIDTH_CARRY_S);
break;
}
cleanup:
- MEMDEBUG_free (bcc->na.address, __LINE__);
- //GNUNET_HELLO_address_free (bcc->na.address);
+ GNUNET_HELLO_address_free (bcc->na.address);
GNUNET_CONTAINER_DLL_remove (bc_head,
bc_tail,
bcc);
- MEMDEBUG_free (bcc, __LINE__);
+ GNUNET_free (bcc);
}
struct BlackListCheckContext *bcc;
struct GST_BlacklistCheck *bc;
- bcc =
- MEMDEBUG_malloc (sizeof (struct BlackListCheckContext), __LINE__);
+ bcc = GNUNET_malloc (sizeof (struct BlackListCheckContext));
bcc->na.address = GNUNET_HELLO_address_copy (address);
- MEMDEBUG_add_alloc (bcc->na.address, GNUNET_HELLO_address_get_size (address), __LINE__);
bcc->na.session = session;
bcc->na.connect_timestamp = ts;
GNUNET_CONTAINER_DLL_insert (bc_head,
if (NULL == (papi = GST_plugins_find (address->transport_name)))
{
/* we don't have the plugin for this address */
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "2348 : `%s' \n", address->transport_name);
GNUNET_ATS_address_destroyed (GST_ats, address, NULL);
return;
}
}
static int
-util_it (void *cls,
+send_utilization_data (void *cls,
const struct GNUNET_PeerIdentity *key,
void *value)
{
struct NeighbourMapEntry *n = value;
- struct GNUNET_ATS_Information atsi[2];
+ struct GNUNET_ATS_Information atsi[4];
+ uint32_t bps_pl_in;
+ uint32_t bps_pl_out;
uint32_t bps_in;
uint32_t bps_out;
struct GNUNET_TIME_Relative delta;
delta = GNUNET_TIME_absolute_get_difference(n->last_util_transmission, GNUNET_TIME_absolute_get());
+
+ bps_pl_in = 0;
+ if (0 != n->util_payload_bytes_recv)
+ bps_pl_in = (1000LL * 1000LL * n->util_payload_bytes_recv) / (delta.rel_value_us);
+ bps_pl_out = 0;
+ if (0 != n->util_payload_bytes_sent)
+ bps_pl_out = (1000LL * 1000LL * n->util_payload_bytes_sent) / delta.rel_value_us;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s' payload: received %u Bytes/s, sent %u Bytes/s \n",
+ GNUNET_i2s (key), bps_pl_in, bps_pl_out);
+
bps_in = 0;
- if (0 != n->util_bytes_recv)
- bps_in = ((1000 * 1000) * n->util_bytes_recv) / (delta.rel_value_us);
+ if (0 != n->util_total_bytes_recv)
+ bps_in = (1000LL * 1000LL * n->util_total_bytes_recv) / (delta.rel_value_us);
bps_out = 0;
- if (0 != n->util_bytes_sent)
- bps_out = ((1000 * 1000) * n->util_bytes_sent) / (delta.rel_value_us);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s': Bytes sent: %u recv %u in %llu sec.\n",
- GNUNET_i2s (key), bps_out, bps_in, delta.rel_value_us / (1000 * 1000));
- atsi[0].type = htonl (GNUNET_ATS_UTILIZATION_UP);
+ if (0 != n->util_total_bytes_sent)
+ bps_out = (1000LL * 1000LL * n->util_total_bytes_sent) / delta.rel_value_us;
+
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s' total: received %u Bytes/s, sent %u Bytes/s \n",
+ GNUNET_i2s (key), bps_in, bps_out);
+
+ atsi[0].type = htonl (GNUNET_ATS_UTILIZATION_OUT);
atsi[0].value = htonl (bps_out);
- atsi[1].type = htonl (GNUNET_ATS_UTILIZATION_DOWN);
+ atsi[1].type = htonl (GNUNET_ATS_UTILIZATION_IN);
atsi[1].value = htonl (bps_in);
- GNUNET_ATS_address_update (GST_ats, n->primary_address.address,
- n->primary_address.session, atsi, 2);
- n->util_bytes_recv = 0;
- n->util_bytes_sent = 0;
+
+ atsi[2].type = htonl (GNUNET_ATS_UTILIZATION_PAYLOAD_OUT);
+ atsi[2].value = htonl (bps_pl_out);
+ atsi[3].type = htonl (GNUNET_ATS_UTILIZATION_PAYLOAD_IN);
+ atsi[3].value = htonl (bps_pl_in);
+
+ GST_ats_update_metrics (key, n->primary_address.address,
+ n->primary_address.session, atsi, 4);
+ n->util_payload_bytes_recv = 0;
+ n->util_payload_bytes_sent = 0;
+ n->util_total_bytes_recv = 0;
+ n->util_total_bytes_sent = 0;
n->last_util_transmission = GNUNET_TIME_absolute_get();
return GNUNET_OK;
}
util_transmission_tk = GNUNET_SCHEDULER_NO_TASK;
if (0 < GNUNET_CONTAINER_multipeermap_size (neighbours))
- GNUNET_CONTAINER_multipeermap_iterate (neighbours, util_it, NULL);
+ GNUNET_CONTAINER_multipeermap_iterate (neighbours, send_utilization_data, NULL);
util_transmission_tk = GNUNET_SCHEDULER_add_delayed (UTIL_TRANSMISSION_INTERVAL,
utilization_transmission, NULL);
}
void
-GST_neighbours_notify_payload (const struct GNUNET_PeerIdentity *peer,
+GST_neighbours_notify_data_recv (const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HELLO_Address *address,
struct Session *session,
const struct GNUNET_MessageHeader *message)
n = lookup_neighbour (peer);
if (NULL == n)
{
- GNUNET_break (0);
return;
}
- n->util_bytes_recv += ntohs(message->size);
+ n->util_total_bytes_recv += ntohs(message->size);
+}
+
+void
+GST_neighbours_notify_payload_recv (const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_HELLO_Address *address,
+ struct Session *session,
+ const struct GNUNET_MessageHeader *message)
+{
+ struct NeighbourMapEntry *n;
+ n = lookup_neighbour (peer);
+ if (NULL == n)
+ {
+ return;
+ }
+ n->util_payload_bytes_recv += ntohs(message->size);
+}
+
+
+void
+GST_neighbours_notify_data_sent (const struct GNUNET_PeerIdentity *peer,
+ size_t size)
+{
+ struct NeighbourMapEntry *n;
+ n = lookup_neighbour (peer);
+ if (NULL == n)
+ {
+ return;
+ }
+ n->util_total_bytes_sent += size;
+}
+
+void
+GST_neighbours_notify_payload_sent (const struct GNUNET_PeerIdentity *peer,
+ size_t size)
+{
+ struct NeighbourMapEntry *n;
+ n = lookup_neighbour (peer);
+ if (NULL == n)
+ {
+ return;
+ }
+ n->util_payload_bytes_sent += size;
}
if (bcc->na.session == session)
{
GST_blacklist_test_cancel (bcc->bc);
- MEMDEBUG_free (bcc->na.address, __LINE__);
- //GNUNET_HELLO_address_free (bcc->na.address);
+ GNUNET_HELLO_address_free (bcc->na.address);
GNUNET_CONTAINER_DLL_remove (bc_head,
bc_tail,
bcc);
- MEMDEBUG_free (bcc, __LINE__);
+ GNUNET_free (bcc);
}
}
if (NULL == (n = lookup_neighbour (peer)))
projects / oweals / gnunet.git / blobdiff