GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 2, or (at your
+ by the Free Software Foundation; either version 3, or (at your
option) any later version.
GNUnet is distributed in the hope that it will be useful, but
* @author Christian Grothoff
*/
#include "platform.h"
-#include "gnunet_client_lib.h"
+#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
-#include "gnunet_container_lib.h"
#include "gnunet_protocols.h"
-#include "gnunet_server_lib.h"
#include "gnunet_statistics_service.h"
-#include "gnunet_strings_lib.h"
#include "statistics.h"
/**
*/
struct GNUNET_TIME_Relative backoff;
+ /**
+ * Maximum heap size observed so far (if available).
+ */
+ uint64_t peak_heap_size;
+
+ /**
+ * Maximum resident set side observed so far (if available).
+ */
+ uint64_t peak_rss;
+
/**
* Size of the 'watches' array.
*/
};
+/**
+ * Obtain statistics about this process's memory consumption and
+ * report those as well (if they changed).
+ */
+static void
+update_memory_statistics (struct GNUNET_STATISTICS_Handle *h)
+{
+#if ENABLE_HEAP_STATISTICS
+ uint64_t current_heap_size = 0;
+ uint64_t current_rss = 0;
+
+ if (GNUNET_NO != h->do_destroy)
+ return;
+#if HAVE_MALLINFO
+ {
+ struct mallinfo mi;
+
+ mi = mallinfo();
+ current_heap_size = mi.uordblks + mi.fordblks;
+ }
+#endif
+#if HAVE_GETRUSAGE
+ {
+ struct rusage ru;
+
+ if (0 == getrusage (RUSAGE_SELF, &ru))
+ {
+ current_rss = 1024LL * ru.ru_maxrss;
+ }
+ }
+#endif
+ if (current_heap_size > h->peak_heap_size)
+ {
+ h->peak_heap_size = current_heap_size;
+ GNUNET_STATISTICS_set (h, "# peak heap size", current_heap_size, GNUNET_NO);
+ }
+ if (current_rss > h->peak_rss)
+ {
+ h->peak_rss = current_rss;
+ GNUNET_STATISTICS_set (h, "# peak resident set size", current_rss, GNUNET_NO);
+ }
+#endif
+}
+
+
/**
* Schedule the next action to be performed.
*
size_t nlen;
size_t nsize;
- GNUNET_assert (h != NULL);
- GNUNET_assert (watch != NULL);
+ GNUNET_assert (NULL != h);
+ GNUNET_assert (NULL != watch);
slen = strlen (watch->subsystem) + 1;
nlen = strlen (watch->name) + 1;
GNUNET_break (0);
return;
}
- ai = GNUNET_malloc (sizeof (struct GNUNET_STATISTICS_GetHandle));
+ ai = GNUNET_new (struct GNUNET_STATISTICS_GetHandle);
ai->sh = h;
ai->subsystem = GNUNET_strdup (watch->subsystem);
ai->name = GNUNET_strdup (watch->name);
do_disconnect (struct GNUNET_STATISTICS_Handle *h)
{
struct GNUNET_STATISTICS_GetHandle *c;
-
+
if (NULL != h->th)
{
GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
h->th = NULL;
- }
- if (NULL != h->client)
- {
- GNUNET_CLIENT_disconnect (h->client);
- h->client = NULL;
}
h->receiving = GNUNET_NO;
if (NULL != (c = h->current))
{
h->current = NULL;
- if (c->cont != NULL)
+ if ( (NULL != c->cont) &&
+ (GNUNET_YES != c->aborted) )
c->cont (c->cls, GNUNET_SYSERR);
free_action_item (c);
}
+ if (NULL != h->client)
+ {
+ GNUNET_CLIENT_disconnect (h->client);
+ h->client = NULL;
+ }
}
* Try to (re)connect to the statistics service.
*
* @param h statistics handle to reconnect
- * @return GNUNET_YES on success, GNUNET_NO on failure.
+ * @return #GNUNET_YES on success, #GNUNET_NO on failure.
*/
static int
try_connect (struct GNUNET_STATISTICS_Handle *h)
struct GNUNET_STATISTICS_GetHandle *gn;
unsigned int i;
- if (h->backoff_task != GNUNET_SCHEDULER_NO_TASK)
+ if (GNUNET_SCHEDULER_NO_TASK != h->backoff_task)
return GNUNET_NO;
- if (h->client != NULL)
+ if (NULL != h->client)
return GNUNET_YES;
- h->client = GNUNET_CLIENT_connect ("statistics", h->cfg);
- if (h->client != NULL)
+ h->client = GNUNET_CLIENT_connect ("statistics", h->cfg);
+ if (NULL != h->client)
{
- gn = h->action_head;
+ gn = h->action_head;
while (NULL != (gh = gn))
{
gn = gh->next;
GNUNET_CONTAINER_DLL_remove (h->action_head,
h->action_tail,
gh);
- free_action_item (gh);
+ free_action_item (gh);
}
}
for (i = 0; i < h->watches_size; i++)
}
-
/**
* Task used by 'reconnect_later' to shutdown the handle
*
GNUNET_STATISTICS_destroy (h, GNUNET_NO);
}
+
/**
* Reconnect at a later time, respecting back-off.
*
struct GNUNET_STATISTICS_GetHandle *gh;
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->backoff_task);
- if (h->do_destroy)
+ if (GNUNET_YES == h->do_destroy)
{
/* So we are shutting down and the service is not reachable.
* Chances are that it's down for good and we are not going to connect to
*/
loss = GNUNET_NO;
for (gh = h->action_head; NULL != gh; gh = gh->next)
- if ( (gh->make_persistent) && (gh->type == ACTION_SET) )
+ if ( (gh->make_persistent) && (ACTION_SET == gh->type) )
loss = GNUNET_YES;
if (GNUNET_YES == loss)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
}
h->backoff_task =
GNUNET_SCHEDULER_add_delayed (h->backoff, &reconnect_task, h);
- h->backoff = GNUNET_TIME_relative_multiply (h->backoff, 2);
- h->backoff =
- GNUNET_TIME_relative_min (h->backoff, GNUNET_CONSTANTS_SERVICE_TIMEOUT);
+ h->backoff = GNUNET_TIME_STD_BACKOFF (h->backoff);
}
return GNUNET_SYSERR;
}
w = h->watches[wid];
- if (NULL == w)
- return GNUNET_NO;
+ if (NULL == w)
+ return GNUNET_NO;
(void) w->proc (w->proc_cls, w->subsystem, w->name,
GNUNET_ntohll (wvm->value),
0 != (ntohl (wvm->flags) & GNUNET_STATISTICS_PERSIST_BIT));
{
struct GNUNET_STATISTICS_Handle *h = cls;
- GNUNET_STATISTICS_destroy (h, GNUNET_YES);
+ GNUNET_STATISTICS_destroy (h, GNUNET_NO);
}
struct GNUNET_STATISTICS_GetHandle *c;
int ret;
- if (msg == NULL)
+ if (NULL == msg)
{
LOG (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
"Error receiving statistics from service, is the service running?\n");
else
{
h->receiving = GNUNET_NO;
- }
+ }
h->current = NULL;
schedule_action (h);
- if (c->cont != NULL)
+ if (NULL != c->cont)
c->cont (c->cls, GNUNET_OK);
free_action_item (c);
return;
{
do_disconnect (h);
reconnect_later (h);
- return;
+ return;
}
/* finally, look for more! */
LOG (GNUNET_ERROR_TYPE_DEBUG,
h->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
return;
case GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE:
- if (GNUNET_OK !=
+ if (GNUNET_OK !=
(ret = process_watch_value (h, msg)))
{
do_disconnect (h);
if (GNUNET_NO == ret)
- h->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
+ h->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
reconnect_later (h);
return;
}
GNUNET_assert (h->watches_size > 0);
GNUNET_CLIENT_receive (h->client, &receive_stats, h,
GNUNET_TIME_UNIT_FOREVER_REL);
- return;
+ return;
default:
GNUNET_break (0);
do_disconnect (h);
uint16_t msize;
GNUNET_assert (NULL != (c = handle->current));
- if (buf == NULL)
+ if (NULL == buf)
{
/* timeout / error */
LOG (GNUNET_ERROR_TYPE_DEBUG,
size_t slen2;
uint16_t msize;
- if (buf == NULL)
+ if (NULL == buf)
{
/* timeout / error */
LOG (GNUNET_ERROR_TYPE_DEBUG,
GNUNET_assert (NULL == handle->current->cont);
free_action_item (handle->current);
handle->current = NULL;
+ update_memory_statistics (handle);
return nsize;
}
{
struct GNUNET_STATISTICS_Handle *ret;
- GNUNET_assert (subsystem != NULL);
- GNUNET_assert (cfg != NULL);
- ret = GNUNET_malloc (sizeof (struct GNUNET_STATISTICS_Handle));
+ if (GNUNET_YES ==
+ GNUNET_CONFIGURATION_get_value_yesno (cfg, "statistics", "DISABLE"))
+ return NULL;
+ GNUNET_assert (NULL != subsystem);
+ GNUNET_assert (NULL != cfg);
+ ret = GNUNET_new (struct GNUNET_STATISTICS_Handle);
ret->cfg = cfg;
ret->subsystem = GNUNET_strdup (subsystem);
ret->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
struct GNUNET_TIME_Relative timeout;
int i;
- if (h == NULL)
+ if (NULL == h)
return;
GNUNET_assert (GNUNET_NO == h->do_destroy); // Don't call twice.
if (GNUNET_SCHEDULER_NO_TASK != h->backoff_task)
}
if (sync_first)
{
- if (h->current != NULL)
+ if (NULL != h->current)
{
- if (h->current->type == ACTION_GET)
+ if (ACTION_GET == h->current->type)
{
GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
h->th = NULL;
h->current = NULL;
}
}
- next = h->action_head;
+ next = h->action_head;
while (NULL != (pos = next))
{
next = pos->next;
- if (pos->type == ACTION_GET)
+ if (ACTION_GET == pos->type)
{
GNUNET_CONTAINER_DLL_remove (h->action_head,
h->action_tail,
h->action_tail,
h->current);
h->do_destroy = GNUNET_YES;
- if ((h->current != NULL) && (h->th == NULL) &&
+ if ((NULL != h->current) && (NULL == h->th) &&
(NULL != h->client))
{
timeout = GNUNET_TIME_absolute_get_remaining (h->current->timeout);
GNUNET_CLIENT_notify_transmit_ready (h->client, h->current->msize,
timeout, GNUNET_YES,
&transmit_action, h);
- GNUNET_assert (NULL != h->th);
+ GNUNET_assert (NULL != h->th);
}
- if (h->th != NULL)
+ if (NULL != h->th)
return; /* do not finish destruction just yet */
}
while (NULL != (pos = h->action_head))
for (i = 0; i < h->watches_size; i++)
{
if (NULL == h->watches[i])
- continue;
+ continue;
GNUNET_free (h->watches[i]->subsystem);
GNUNET_free (h->watches[i]->name);
GNUNET_free (h->watches[i]);
struct GNUNET_STATISTICS_Handle *h = cls;
struct GNUNET_MessageHeader hdr;
+ h->th = NULL;
if (NULL == buf)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
hdr.type = htons (GNUNET_MESSAGE_TYPE_TEST);
hdr.size = htons (sizeof (struct GNUNET_MessageHeader));
memcpy (buf, &hdr, sizeof (hdr));
+ if (GNUNET_YES != h->receiving)
+ {
+ h->receiving = GNUNET_YES;
+ GNUNET_CLIENT_receive (h->client, &receive_stats, h,
+ GNUNET_TIME_UNIT_FOREVER_REL);
+ }
return sizeof (struct GNUNET_MessageHeader);
}
{
struct GNUNET_TIME_Relative timeout;
- if ( (h->th != NULL) ||
- (h->backoff_task != GNUNET_SCHEDULER_NO_TASK) )
+ if ( (NULL != h->th) ||
+ (GNUNET_SCHEDULER_NO_TASK != h->backoff_task) )
return; /* action already pending */
if (GNUNET_YES != try_connect (h))
{
h->current = h->action_head;
if (NULL == h->current)
{
- if (h->do_destroy)
+ if (GNUNET_YES == h->do_destroy)
{
h->do_destroy = GNUNET_SYSERR; /* in 'TEST' mode */
h->th = GNUNET_CLIENT_notify_transmit_ready (h->client,
* @param timeout after how long should we give up (and call
* cont with an error code)?
* @param cont continuation to call when done (can be NULL)
+ * This callback CANNOT destroy the statistics handle in the same call.
* @param proc function to call on each value
* @param cls closure for cont and proc
* @return NULL on error
if (NULL == handle)
return NULL;
- GNUNET_assert (proc != NULL);
+ GNUNET_assert (NULL != proc);
GNUNET_assert (GNUNET_NO == handle->do_destroy);
- if (subsystem == NULL)
+ if (NULL == subsystem)
subsystem = "";
- if (name == NULL)
+ if (NULL == name)
name = "";
slen1 = strlen (subsystem) + 1;
slen2 = strlen (name) + 1;
GNUNET_assert (slen1 + slen2 + sizeof (struct GNUNET_MessageHeader) <
GNUNET_SERVER_MAX_MESSAGE_SIZE);
- ai = GNUNET_malloc (sizeof (struct GNUNET_STATISTICS_GetHandle));
+ ai = GNUNET_new (struct GNUNET_STATISTICS_GetHandle);
ai->sh = handle;
ai->subsystem = GNUNET_strdup (subsystem);
ai->name = GNUNET_strdup (name);
{
if (NULL == gh)
return;
+ gh->cont = NULL;
if (gh->sh->current == gh)
{
gh->aborted = GNUNET_YES;
{
struct GNUNET_STATISTICS_WatchEntry *w;
- if (handle == NULL)
+ if (NULL == handle)
return GNUNET_SYSERR;
- w = GNUNET_malloc (sizeof (struct GNUNET_STATISTICS_WatchEntry));
+ w = GNUNET_new (struct GNUNET_STATISTICS_WatchEntry);
w->subsystem = GNUNET_strdup (subsystem);
w->name = GNUNET_strdup (name);
w->proc = proc;
/**
- * Stop watching statistics from the peer.
+ * Stop watching statistics from the peer.
*
* @param handle identification of the statistics service
* @param subsystem limit to the specified subsystem, never NULL
struct GNUNET_STATISTICS_WatchEntry *w;
unsigned int i;
- if (handle == NULL)
+ if (NULL == handle)
return GNUNET_SYSERR;
for (i=0;i<handle->watches_size;i++)
{
GNUNET_free (w->name);
GNUNET_free (w->subsystem);
GNUNET_free (w);
- handle->watches[i] = NULL;
+ handle->watches[i] = NULL;
return GNUNET_OK;
- }
+ }
}
return GNUNET_SYSERR;
}
size_t nsize;
int64_t delta;
- GNUNET_assert (h != NULL);
- GNUNET_assert (name != NULL);
+ GNUNET_assert (NULL != h);
+ GNUNET_assert (NULL != name);
slen = strlen (h->subsystem) + 1;
nlen = strlen (name) + 1;
nsize = sizeof (struct GNUNET_STATISTICS_SetMessage) + slen + nlen;
GNUNET_break (0);
return;
}
- for (ai = h->action_head; ai != NULL; ai = ai->next)
+ for (ai = h->action_head; NULL != ai; ai = ai->next)
{
if (! ( (0 == strcmp (ai->subsystem, h->subsystem)) &&
- (0 == strcmp (ai->name, name)) &&
- ( (ai->type == ACTION_UPDATE) ||
- (ai->type == ACTION_SET) ) ) )
+ (0 == strcmp (ai->name, name)) &&
+ ( (ACTION_UPDATE == ai->type) ||
+ (ACTION_SET == ai->type) ) ) )
continue;
- if (ai->type == ACTION_SET)
+ if (ACTION_SET == ai->type)
{
- if (type == ACTION_UPDATE)
+ if (ACTION_UPDATE == type)
{
delta = (int64_t) value;
if (delta > 0)
}
else
{
- if (type == ACTION_UPDATE)
+ if (ACTION_UPDATE == type)
{
/* make delta cummulative */
delta = (int64_t) value;
}
ai->timeout = GNUNET_TIME_relative_to_absolute (SET_TRANSMIT_TIMEOUT);
ai->make_persistent = make_persistent;
- return;
+ return;
}
/* no existing entry matches, create a fresh one */
- ai = GNUNET_malloc (sizeof (struct GNUNET_STATISTICS_GetHandle));
+ ai = GNUNET_new (struct GNUNET_STATISTICS_GetHandle);
ai->sh = h;
ai->subsystem = GNUNET_strdup (h->subsystem);
ai->name = GNUNET_strdup (name);
GNUNET_STATISTICS_set (struct GNUNET_STATISTICS_Handle *handle,
const char *name, uint64_t value, int make_persistent)
{
- if (handle == NULL)
+ if (NULL == handle)
return;
GNUNET_assert (GNUNET_NO == handle->do_destroy);
add_setter_action (handle, name, make_persistent, value, ACTION_SET);
GNUNET_STATISTICS_update (struct GNUNET_STATISTICS_Handle *handle,
const char *name, int64_t delta, int make_persistent)
{
- if (handle == NULL)
+ if (NULL == handle)
return;
- if (delta == 0)
+ if (0 == delta)
return;
GNUNET_assert (GNUNET_NO == handle->do_destroy);
add_setter_action (handle, name, make_persistent, (uint64_t) delta,
projects / oweals / gnunet.git / blobdiff