defragmentation.c File Reference

library to help defragment messages More...

#include "platform.h"
#include "gnunet_fragmentation_lib.h"
#include "fragmentation.h"

Include dependency graph for defragmentation.c:

Go to the source code of this file.

Data Structures
struct	FragTimes
	Timestamps for fragments. More...
struct	MessageContext
	Information we keep for one message that is being assembled. More...
struct	GNUNET_DEFRAGMENT_Context
	Defragmentation context (one per connection). More...

Functions
struct GNUNET_DEFRAGMENT_Context *	GNUNET_DEFRAGMENT_context_create (struct GNUNET_STATISTICS_Handle *stats, uint16_t mtu, unsigned int num_msgs, void *cls, GNUNET_FRAGMENT_MessageProcessor proc, GNUNET_DEFRAGMENT_AckProcessor ackp)
	Create a defragmentation context. More...
void	GNUNET_DEFRAGMENT_context_destroy (struct GNUNET_DEFRAGMENT_Context *dc)
	Destroy the given defragmentation context. More...
static void	send_ack (void *cls)
	Send acknowledgement to the other peer now. More...
static void	gsl_fit_mul (const double *x, const size_t xstride, const double *y, const size_t ystride, const size_t n, double *c1, double *cov_11, double *sumsq)
	This function is from the GNU Scientific Library, linear/fit.c, Copyright (C) 2000 Brian Gough. More...
static struct GNUNET_TIME_Relative	estimate_latency (struct MessageContext *mc)
	Estimate the latency between messages based on the most recent message time stamps. More...
static void	discard_oldest_mc (struct GNUNET_DEFRAGMENT_Context *dc)
	Discard the message context that was inactive for the longest time. More...
int	GNUNET_DEFRAGMENT_process_fragment (struct GNUNET_DEFRAGMENT_Context *dc, const struct GNUNET_MessageHeader *msg)
	We have received a fragment. More...

Detailed Description

library to help defragment messages

Author

Christian Grothoff

Definition in file defragmentation.c.

Function Documentation

send_ack()

static void send_ack ( void *  cls )

static

Send acknowledgement to the other peer now.

Parameters

cls	the message context

Definition at line 260 of file defragmentation.c.

References _, MessageContext::ack_task, GNUNET_DEFRAGMENT_Context::ackp, FragmentAcknowledgement::bits, MessageContext::bits, GNUNET_DEFRAGMENT_Context::cls, dc, MessageContext::dc, FragmentAcknowledgement::fragment_id, MessageContext::fragment_id, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_FRAGMENT_ACK, GNUNET_NO, GNUNET_STATISTICS_update(), FragmentAcknowledgement::header, MessageContext::last_duplicate, mc, GNUNET_MessageHeader::size, GNUNET_DEFRAGMENT_Context::stats, and GNUNET_MessageHeader::type.

Referenced by GNUNET_DEFRAGMENT_process_fragment().

{
  struct MessageContext *mc = cls;
  struct GNUNET_DEFRAGMENT_Context *dc = mc->dc;
  struct FragmentAcknowledgement fa;

  mc->ack_task = NULL;
  fa.header.size = htons (sizeof(struct FragmentAcknowledgement));
  fa.header.type = htons (GNUNET_MESSAGE_TYPE_FRAGMENT_ACK);
  fa.fragment_id = htonl (mc->fragment_id);
  fa.bits = GNUNET_htonll (mc->bits);
  GNUNET_STATISTICS_update (mc->dc->stats,
                            _ ("# acknowledgements sent for fragment"),
                            1,
                            GNUNET_NO);
  mc->last_duplicate = GNUNET_NO; /* clear flag */
  dc->ackp (dc->cls,
            mc->fragment_id,
            &fa.header);
}

Here is the call graph for this function:

Here is the caller graph for this function:

gsl_fit_mul()

static void gsl_fit_mul ( const double *  x, const size_t  xstride, const double *  y, const size_t  ystride, const size_t  n, double *  c1, double *  cov_11, double *  sumsq  )

static

This function is from the GNU Scientific Library, linear/fit.c, Copyright (C) 2000 Brian Gough.

Definition at line 287 of file defragmentation.c.

Referenced by estimate_latency().

{
  double m_x = 0, m_y = 0, m_dx2 = 0, m_dxdy = 0;

  size_t i;

  for (i = 0; i < n; i++)
  {
    m_x += (x[i * xstride] - m_x) / (i + 1.0);
    m_y += (y[i * ystride] - m_y) / (i + 1.0);
  }

  for (i = 0; i < n; i++)
  {
    const double dx = x[i * xstride] - m_x;
    const double dy = y[i * ystride] - m_y;

    m_dx2 += (dx * dx - m_dx2) / (i + 1.0);
    m_dxdy += (dx * dy - m_dxdy) / (i + 1.0);
  }

  /* In terms of y =  b x */

  {
    double s2 = 0, d2 = 0;
    double b = (m_x * m_y + m_dxdy) / (m_x * m_x + m_dx2);

    *c1 = b;

    /* Compute chi^2 = \sum (y_i -  b * x_i)^2 */

    for (i = 0; i < n; i++)
    {
      const double dx = x[i * xstride] - m_x;
      const double dy = y[i * ystride] - m_y;
      const double d = (m_y - b * m_x) + dy - b * dx;

      d2 += d * d;
    }

    s2 = d2 / (n - 1.0);        /* chisq per degree of freedom */

    *cov_11 = s2 * 1.0 / (n * (m_x * m_x + m_dx2));

    *sumsq = d2;
  }
}

Here is the caller graph for this function:

estimate_latency()

static struct GNUNET_TIME_Relative estimate_latency ( struct MessageContext *  mc )

static

Estimate the latency between messages based on the most recent message time stamps.

Parameters

mc	context with time stamps

Returns

average delay between time stamps (based on least-squares fit)

Definition at line 346 of file defragmentation.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_assert, GNUNET_TIME_UNIT_MICROSECONDS, gsl_fit_mul(), mc, GNUNET_TIME_Relative::rel_value_us, ret, and FragTimes::time.

Referenced by GNUNET_DEFRAGMENT_process_fragment().

{
  struct FragTimes *first;
  size_t total = mc->frag_times_write_offset - mc->frag_times_start_offset;
  double x[total];
  double y[total];
  size_t i;
  double c1;
  double cov11;
  double sumsq;
  struct GNUNET_TIME_Relative ret;

  first = &mc->frag_times[mc->frag_times_start_offset];
  GNUNET_assert (total > 1);
  for (i = 0; i < total; i++)
  {
    x[i] = (double) i;
    y[i] = (double) (first[i].time.abs_value_us - first[0].time.abs_value_us);
  }
  gsl_fit_mul (x, 1, y, 1, total, &c1, &cov11, &sumsq);
  c1 += sqrt (sumsq);            /* add 1 std dev */
  ret.rel_value_us = (uint64_t) c1;
  if (0 == ret.rel_value_us)
    ret = GNUNET_TIME_UNIT_MICROSECONDS;        /* always at least 1 */
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

discard_oldest_mc()

static void discard_oldest_mc ( struct GNUNET_DEFRAGMENT_Context *  dc )

static

Discard the message context that was inactive for the longest time.

Parameters

dc	defragmentation context

Definition at line 380 of file defragmentation.c.

References GNUNET_TIME_Absolute::abs_value_us, MessageContext::ack_task, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_DEFRAGMENT_Context::head, MessageContext::last_update, GNUNET_DEFRAGMENT_Context::list_size, MessageContext::next, and GNUNET_DEFRAGMENT_Context::tail.

Referenced by GNUNET_DEFRAGMENT_process_fragment().

{
  struct MessageContext *old;
  struct MessageContext *pos;

  old = NULL;
  pos = dc->head;
  while (NULL != pos)
  {
    if ((old == NULL) ||
        (old->last_update.abs_value_us > pos->last_update.abs_value_us))
      old = pos;
    pos = pos->next;
  }
  GNUNET_assert (NULL != old);
  GNUNET_CONTAINER_DLL_remove (dc->head, dc->tail, old);
  dc->list_size--;
  if (NULL != old->ack_task)
  {
    GNUNET_SCHEDULER_cancel (old->ack_task);
    old->ack_task = NULL;
  }
  GNUNET_free (old);
}

Here is the call graph for this function:

Here is the caller graph for this function: