testbed_api_operations.c File Reference

functions to manage operation queues More...

#include "platform.h"
#include "testbed_api_operations.h"
#include "testbed_api_sd.h"

Include dependency graph for testbed_api_operations.c:

Go to the source code of this file.

Data Structures
struct	QueueEntry
	An entry in the operation queue. More...
struct	TimeSlot
	A slot to record time taken by an operation. More...
struct	FeedbackCtx
	Context for operation queues of type OPERATION_QUEUE_TYPE_ADAPTIVE. More...
struct	OperationQueue
	Queue of operations where we can only support a certain number of concurrent operations of a particular type. More...
struct	ReadyQueueEntry
	An entry in the ready queue (implemented as DLL) More...
struct	GNUNET_TESTBED_Operation
	Opaque handle to an abstract operation to be executed by the testing framework. More...

Macros
#define	ADAPTIVE_QUEUE_DEFAULT_HISTORY   40
	The number of readings containing past operation's timing information that we keep track of for adaptive queues. More...
#define	ADAPTIVE_QUEUE_DEFAULT_MAX_ACTIVE   4
	The number of parallel operations we start with by default for adaptive queues. More...

Enumerations
enum	OperationState {   OP_STATE_INIT , OP_STATE_WAITING , OP_STATE_READY , OP_STATE_ACTIVE ,   OP_STATE_INACTIVE }
	Operation state. More...

Functions
static void	assign_timeslot (struct GNUNET_TESTBED_Operation *op, struct OperationQueue *queue)
	Assigns the given operation a time slot from the given operation queue. More...
static void	remove_queue_entry (struct GNUNET_TESTBED_Operation *op, unsigned int index)
	Removes a queue entry of an operation from one of the operation queues' lists depending on the state of the operation. More...
static void	change_state (struct GNUNET_TESTBED_Operation *op, enum OperationState state)
	Changes the state of the operation while moving its associated queue entries in the operation's operation queues. More...
static void	rq_remove (struct GNUNET_TESTBED_Operation *op)
	Removes an operation from the ready queue. More...
static void	process_rq_task (void *cls)
	Processes the ready queue by calling the operation start callback of the operation at the head. More...
static void	rq_add (struct GNUNET_TESTBED_Operation *op)
	Adds the operation to the ready queue and starts the 'process_rq_task'. More...
static int	is_queue_empty (struct OperationQueue *opq)
	Checks if the given operation queue is empty or not. More...
static int	decide_capacity (struct OperationQueue *opq, struct QueueEntry *entry, struct GNUNET_TESTBED_Operation ***ops_, unsigned int *n_ops_)
	Checks if the given operation queue has enough resources to provide for the operation of the given queue entry. More...
static void	merge_ops (struct GNUNET_TESTBED_Operation ***old, unsigned int *n_old, struct GNUNET_TESTBED_Operation **new, unsigned int n_new)
	Merges an array of operations into another, eliminating duplicates. More...
static int	check_readiness (struct GNUNET_TESTBED_Operation *op)
	Checks for the readiness of an operation and schedules a operation start task. More...
static void	defer (struct GNUNET_TESTBED_Operation *op)
	Defers a ready to be executed operation back to waiting. More...
static void	cleanup_tslots (struct OperationQueue *queue)
	Cleanups the array of timeslots of an operation queue. More...
static void	adaptive_queue_set_max_active (struct OperationQueue *queue, unsigned int n)
	Cleansup the existing timing slots and sets new timing slots in the given queue to accommodate given number of max active operations. More...
static void	adapt_parallelism (struct OperationQueue *queue)
	Adapts parallelism in an adaptive queue by using the statistical data from the feedback context. More...
static void	update_tslots (struct GNUNET_TESTBED_Operation *op)
	update tslots with the operation's completion time. More...
struct GNUNET_TESTBED_Operation *	GNUNET_TESTBED_operation_create_ (void *cls, OperationStart start, OperationRelease release)
	Create an 'operation' to be performed. More...
struct OperationQueue *	GNUNET_TESTBED_operation_queue_create_ (enum OperationQueueType type, unsigned int max_active)
	Create an operation queue. More...
static void	queue_destroy (struct OperationQueue *queue)
	Cleanup the given operation queue. More...
void	GNUNET_TESTBED_operation_queue_destroy_ (struct OperationQueue *queue)
	Destroys an operation queue. More...
int	GNUNET_TESTBED_operation_queue_destroy_empty_ (struct OperationQueue *queue)
	Destroys the operation queue if it is empty. More...
static void	recheck_waiting (struct OperationQueue *opq)
	Rechecks if any of the operations in the given operation queue's waiting list can be made active. More...
void	GNUNET_TESTBED_operation_queue_reset_max_active_ (struct OperationQueue *queue, unsigned int max_active)
	Function to reset the maximum number of operations in the given queue. More...
void	GNUNET_TESTBED_operation_queue_insert2_ (struct OperationQueue *queue, struct GNUNET_TESTBED_Operation *op, unsigned int nres)
	Add an operation to a queue. More...
void	GNUNET_TESTBED_operation_queue_insert_ (struct OperationQueue *queue, struct GNUNET_TESTBED_Operation *op)
	Add an operation to a queue. More...
void	GNUNET_TESTBED_operation_begin_wait_ (struct GNUNET_TESTBED_Operation *op)
	Marks the given operation as waiting on the queues. More...
void	GNUNET_TESTBED_operation_inactivate_ (struct GNUNET_TESTBED_Operation *op)
	Marks an active operation as inactive - the operation will be kept in a ready-to-be-released state and continues to hold resources until another operation contents for them. More...
void	GNUNET_TESTBED_operation_activate_ (struct GNUNET_TESTBED_Operation *op)
	Marks and inactive operation as active. More...
void	GNUNET_TESTBED_operation_release_ (struct GNUNET_TESTBED_Operation *op)
	An operation is 'done' (was cancelled or finished); remove it from the queues and release associated resources. More...
void	GNUNET_TESTBED_operation_mark_failed (struct GNUNET_TESTBED_Operation *op)
	Marks an operation as failed. More...
void	__attribute__ ((destructor))
	Cleanup expired operation queues. More...

Variables
static struct ReadyQueueEntry *	rq_head
	DLL head for the ready queue. More...
static struct ReadyQueueEntry *	rq_tail
	DLL tail for the ready queue. More...
static struct OperationQueue **	expired_opqs
	Array of operation queues which are to be destroyed. More...
static unsigned int	n_expired_opqs
	Number of expired operation queues in the above array. More...
struct GNUNET_SCHEDULER_Task *	process_rq_task_id
	The id of the task to process the ready queue. More...

Detailed Description

functions to manage operation queues

Author

Christian Grothoff

Sree Harsha Totakura

Definition in file testbed_api_operations.c.

Macro Definition Documentation

ADAPTIVE_QUEUE_DEFAULT_HISTORY

#define ADAPTIVE_QUEUE_DEFAULT_HISTORY   40

The number of readings containing past operation's timing information that we keep track of for adaptive queues.

Definition at line 36 of file testbed_api_operations.c.

ADAPTIVE_QUEUE_DEFAULT_MAX_ACTIVE

#define ADAPTIVE_QUEUE_DEFAULT_MAX_ACTIVE   4

The number of parallel operations we start with by default for adaptive queues.

Definition at line 42 of file testbed_api_operations.c.

Enumeration Type Documentation

OperationState

enum OperationState

Operation state.

Enumerator
OP_STATE_INIT	The operation is just created and is in initial state.
OP_STATE_WAITING	The operation is currently waiting for resources.
OP_STATE_READY	The operation is ready to be started.
OP_STATE_ACTIVE	The operation has started and is active.
OP_STATE_INACTIVE	The operation is inactive. It still holds resources on the operation queues. However, this operation will be evicted when another operation requires resources from the maxed out queues this operation is holding resources from.

Definition at line 250 of file testbed_api_operations.c.

{
  OP_STATE_INIT,
 
  OP_STATE_WAITING,
 
  OP_STATE_READY,
 
  OP_STATE_ACTIVE,
 
  OP_STATE_INACTIVE
};

Function Documentation

assign_timeslot()

static void assign_timeslot ( struct GNUNET_TESTBED_Operation *  op, struct OperationQueue *  queue  )

static

Assigns the given operation a time slot from the given operation queue.

Parameters

op	the operation
queue	the operation queue

Returns

the timeslot

Definition at line 413 of file testbed_api_operations.c.

{
  struct FeedbackCtx *fctx = queue->fctx;
  struct TimeSlot *tslot;
 
  GNUNET_assert (OPERATION_QUEUE_TYPE_ADAPTIVE == queue->type);
  tslot = fctx->alloc_head;
  GNUNET_assert (NULL != tslot);
  GNUNET_CONTAINER_DLL_remove (fctx->alloc_head, fctx->alloc_tail, tslot);
  GNUNET_CONTAINER_DLL_insert_tail (op->tslots_head, op->tslots_tail, tslot);
  tslot->op = op;
}

References FeedbackCtx::alloc_head, FeedbackCtx::alloc_tail, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, op, TimeSlot::op, OPERATION_QUEUE_TYPE_ADAPTIVE, and queue().

Referenced by process_rq_task().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_queue_entry()

static void remove_queue_entry ( struct GNUNET_TESTBED_Operation *  op, unsigned int  index  )

static

Removes a queue entry of an operation from one of the operation queues' lists depending on the state of the operation.

Parameters

op	the operation whose entry has to be removed
index	the index of the entry in the operation's array of queue entries

Definition at line 436 of file testbed_api_operations.c.

{
  struct OperationQueue *opq;
  struct QueueEntry *entry;
 
  opq = op->queues[index];
  entry = op->qentries[index];
  switch (op->state)
  {
  case OP_STATE_INIT:
    GNUNET_assert (0);
    break;
 
  case OP_STATE_WAITING:
    GNUNET_CONTAINER_DLL_remove (opq->wq_head, opq->wq_tail, entry);
    break;
 
  case OP_STATE_READY:
    GNUNET_CONTAINER_DLL_remove (opq->rq_head, opq->rq_tail, entry);
    break;
 
  case OP_STATE_ACTIVE:
    GNUNET_CONTAINER_DLL_remove (opq->aq_head, opq->aq_tail, entry);
    break;
 
  case OP_STATE_INACTIVE:
    GNUNET_CONTAINER_DLL_remove (opq->nq_head, opq->nq_tail, entry);
    break;
  }
}

References OperationQueue::aq_head, OperationQueue::aq_tail, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, OperationQueue::nq_head, OperationQueue::nq_tail, op, OP_STATE_ACTIVE, OP_STATE_INACTIVE, OP_STATE_INIT, OP_STATE_READY, OP_STATE_WAITING, OperationQueue::rq_head, OperationQueue::rq_tail, OperationQueue::wq_head, and OperationQueue::wq_tail.

Referenced by change_state(), and GNUNET_TESTBED_operation_release_().

Here is the caller graph for this function:

change_state()

static void change_state ( struct GNUNET_TESTBED_Operation *  op, enum OperationState  state  )

static

Changes the state of the operation while moving its associated queue entries in the operation's operation queues.

Parameters

op	the operation whose state has to be changed
state	the state the operation should have. It cannot be OP_STATE_INIT

Definition at line 476 of file testbed_api_operations.c.

{
  struct QueueEntry *entry;
  struct OperationQueue *opq;
  unsigned int cnt;
  unsigned int s;
 
  GNUNET_assert (OP_STATE_INIT != state);
  GNUNET_assert (NULL != op->queues);
  GNUNET_assert (NULL != op->nres);
  GNUNET_assert ((OP_STATE_INIT == op->state) || (NULL != op->qentries));
  GNUNET_assert (op->state != state);
  for (cnt = 0; cnt < op->nqueues; cnt++)
  {
    if (OP_STATE_INIT == op->state)
    {
      entry = GNUNET_new (struct QueueEntry);
      entry->op = op;
      entry->nres = op->nres[cnt];
      s = cnt;
      GNUNET_array_append (op->qentries, s, entry);
    }
    else
    {
      entry = op->qentries[cnt];
      remove_queue_entry (op, cnt);
    }
    opq = op->queues[cnt];
    switch (state)
    {
    case OP_STATE_INIT:
      GNUNET_assert (0);
      break;
 
    case OP_STATE_WAITING:
      GNUNET_CONTAINER_DLL_insert_tail (opq->wq_head, opq->wq_tail, entry);
      break;
 
    case OP_STATE_READY:
      GNUNET_CONTAINER_DLL_insert_tail (opq->rq_head, opq->rq_tail, entry);
      break;
 
    case OP_STATE_ACTIVE:
      GNUNET_CONTAINER_DLL_insert_tail (opq->aq_head, opq->aq_tail, entry);
      break;
 
    case OP_STATE_INACTIVE:
      GNUNET_CONTAINER_DLL_insert_tail (opq->nq_head, opq->nq_tail, entry);
      break;
    }
  }
  op->state = state;
}

References OperationQueue::aq_head, OperationQueue::aq_tail, GNUNET_array_append, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_new, OperationQueue::nq_head, OperationQueue::nq_tail, QueueEntry::nres, op, QueueEntry::op, OP_STATE_ACTIVE, OP_STATE_INACTIVE, OP_STATE_INIT, OP_STATE_READY, OP_STATE_WAITING, remove_queue_entry(), OperationQueue::rq_head, OperationQueue::rq_tail, state, OperationQueue::wq_head, and OperationQueue::wq_tail.

Referenced by check_readiness(), defer(), GNUNET_TESTBED_operation_activate_(), GNUNET_TESTBED_operation_begin_wait_(), GNUNET_TESTBED_operation_inactivate_(), and process_rq_task().

Here is the call graph for this function:

Here is the caller graph for this function:

rq_remove()

static void rq_remove ( struct GNUNET_TESTBED_Operation *  op )

static

Removes an operation from the ready queue.

Also stops the 'process_rq_task' if the given operation is the last one in the queue.

Parameters

op	the operation to be removed

Definition at line 538 of file testbed_api_operations.c.

{
  GNUNET_assert (NULL != op->rq_entry);
  GNUNET_CONTAINER_DLL_remove (rq_head, rq_tail, op->rq_entry);
  GNUNET_free (op->rq_entry);
  op->rq_entry = NULL;
  if ((NULL == rq_head) && (NULL != process_rq_task_id))
  {
    GNUNET_SCHEDULER_cancel (process_rq_task_id);
    process_rq_task_id = NULL;
  }
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), op, process_rq_task_id, rq_head, and rq_tail.

Referenced by defer(), GNUNET_TESTBED_operation_release_(), and process_rq_task().

Here is the call graph for this function:

Here is the caller graph for this function:

process_rq_task()

static void process_rq_task ( void *  cls )

static

Processes the ready queue by calling the operation start callback of the operation at the head.

The operation is then removed from the queue. The task is scheduled to run again immediately until no more operations are in the ready queue.

Parameters

cls

NULL

Definition at line 561 of file testbed_api_operations.c.

{
  struct GNUNET_TESTBED_Operation *op;
  struct OperationQueue *queue;
  unsigned int cnt;
 
  process_rq_task_id = NULL;
  GNUNET_assert (NULL != rq_head);
  GNUNET_assert (NULL != (op = rq_head->op));
  rq_remove (op);
  if (NULL != rq_head)
    process_rq_task_id = GNUNET_SCHEDULER_add_now (&process_rq_task, NULL);
  change_state (op, OP_STATE_ACTIVE);
  for (cnt = 0; cnt < op->nqueues; cnt++)
  {
    queue = op->queues[cnt];
    if (OPERATION_QUEUE_TYPE_ADAPTIVE == queue->type)
      assign_timeslot (op, queue);
  }
  op->tstart = GNUNET_TIME_absolute_get ();
  if (NULL != op->start)
    op->start (op->cb_cls);
}

References assign_timeslot(), change_state(), GNUNET_assert, GNUNET_SCHEDULER_add_now(), GNUNET_TIME_absolute_get(), op, ReadyQueueEntry::op, OP_STATE_ACTIVE, OPERATION_QUEUE_TYPE_ADAPTIVE, process_rq_task_id, queue(), rq_head, and rq_remove().

Referenced by rq_add().

Here is the call graph for this function:

Here is the caller graph for this function:

rq_add()

static void rq_add ( struct GNUNET_TESTBED_Operation *  op )

static

Adds the operation to the ready queue and starts the 'process_rq_task'.

Parameters

op	the operation to be queued

Definition at line 592 of file testbed_api_operations.c.

{
  struct ReadyQueueEntry *rq_entry;
 
  GNUNET_assert (NULL == op->rq_entry);
  rq_entry = GNUNET_new (struct ReadyQueueEntry);
  rq_entry->op = op;
  GNUNET_CONTAINER_DLL_insert_tail (rq_head, rq_tail, rq_entry);
  op->rq_entry = rq_entry;
  if (NULL == process_rq_task_id)
    process_rq_task_id = GNUNET_SCHEDULER_add_now (&process_rq_task, NULL);
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_new, GNUNET_SCHEDULER_add_now(), op, ReadyQueueEntry::op, process_rq_task(), process_rq_task_id, rq_head, and rq_tail.

Referenced by check_readiness().

Here is the call graph for this function:

Here is the caller graph for this function:

is_queue_empty()

static int is_queue_empty ( struct OperationQueue *  opq )

static

Checks if the given operation queue is empty or not.

Parameters

opq	the operation queue

Returns

GNUNET_YES if the given operation queue has no operations; GNUNET_NO otherwise

Definition at line 614 of file testbed_api_operations.c.

{
  if ((NULL != opq->wq_head)
      || (NULL != opq->rq_head)
      || (NULL != opq->aq_head)
      || (NULL != opq->nq_head))
    return GNUNET_NO;
  return GNUNET_YES;
}

References OperationQueue::aq_head, GNUNET_NO, GNUNET_YES, OperationQueue::nq_head, OperationQueue::rq_head, and OperationQueue::wq_head.

Referenced by __attribute__(), GNUNET_TESTBED_operation_queue_destroy_(), and GNUNET_TESTBED_operation_queue_destroy_empty_().

Here is the caller graph for this function:

decide_capacity()

static int decide_capacity ( struct OperationQueue *  opq, struct QueueEntry *  entry, struct GNUNET_TESTBED_Operation ***  ops_, unsigned int *  n_ops_  )

static

Checks if the given operation queue has enough resources to provide for the operation of the given queue entry.

It also checks if any inactive operations are to be released in order to accommodate the needed resources and returns them as an array.

Parameters

opq	the operation queue to check for resource accommodation
entry	the operation queue entry whose operation's resources are to be accommodated
ops_	pointer to return the array of operations which are to be released in order to accommodate the new operation. Can be NULL
n_ops_	the number of operations in ops_

Returns

GNUNET_YES if the given entry's operation can be accommodated in this queue. GNUNET_NO if it cannot be accommodated; ops_ and n_ops_ will be set to NULL and 0 respectively.

Definition at line 642 of file testbed_api_operations.c.

{
  struct QueueEntry **evict_entries;
  struct GNUNET_TESTBED_Operation **ops;
  struct GNUNET_TESTBED_Operation *op;
  unsigned int n_ops;
  unsigned int n_evict_entries;
  unsigned int need;
  unsigned int max;
  int deficit;
  int rval;
 
  GNUNET_assert (NULL != (op = entry->op));
  GNUNET_assert (0 < (need = entry->nres));
  ops = NULL;
  n_ops = 0;
  evict_entries = NULL;
  n_evict_entries = 0;
  rval = GNUNET_YES;
  if (OPERATION_QUEUE_TYPE_ADAPTIVE == opq->type)
  {
    GNUNET_assert (NULL != opq->fctx);
    GNUNET_assert (opq->max_active >= opq->overload);
    max = opq->max_active - opq->overload;
  }
  else
    max = opq->max_active;
  if (opq->active > max)
  {
    rval = GNUNET_NO;
    goto ret;
  }
  if ((opq->active + need) <= max)
    goto ret;
  deficit = need - (max - opq->active);
  for (entry = opq->nq_head;
       (0 < deficit) && (NULL != entry);
       entry = entry->next)
  {
    GNUNET_array_append (evict_entries, n_evict_entries, entry);
    deficit -= entry->nres;
  }
  if (0 < deficit)
  {
    rval = GNUNET_NO;
    goto ret;
  }
  for (n_ops = 0; n_ops < n_evict_entries;)
  {
    op = evict_entries[n_ops]->op;
    GNUNET_array_append (ops, n_ops, op);  /* increments n-ops */
  }
 
ret:
  GNUNET_free (evict_entries);
  if (NULL != ops_)
    *ops_ = ops;
  else
    GNUNET_free (ops);
  if (NULL != n_ops_)
    *n_ops_ = n_ops;
  return rval;
}

References OperationQueue::active, OperationQueue::fctx, GNUNET_array_append, GNUNET_assert, GNUNET_free, GNUNET_NO, GNUNET_YES, max, OperationQueue::max_active, QueueEntry::next, OperationQueue::nq_head, QueueEntry::nres, op, QueueEntry::op, OPERATION_QUEUE_TYPE_ADAPTIVE, OperationQueue::overload, ret, and OperationQueue::type.

Referenced by check_readiness().

Here is the caller graph for this function:

merge_ops()

static void merge_ops ( struct GNUNET_TESTBED_Operation ***  old, unsigned int *  n_old, struct GNUNET_TESTBED_Operation **  new, unsigned int  n_new  )

static

Merges an array of operations into another, eliminating duplicates.

No ordering is guaranteed.

Parameters

old	the array into which the merging is done.
n_old	the number of operations in old array
new	the array from which operations are to be merged
n_new	the number of operations in new array

Definition at line 720 of file testbed_api_operations.c.

{
  struct GNUNET_TESTBED_Operation **cur;
  unsigned int i;
  unsigned int j;
  unsigned int n_cur;
 
  GNUNET_assert (NULL != old);
  n_cur = *n_old;
  cur = *old;
  for (i = 0; i < n_new; i++)
  {
    for (j = 0; j < *n_old; j++)
    {
      if (new[i] == cur[j])
        break;
    }
    if (j < *n_old)
      continue;
    GNUNET_array_append (cur, n_cur, new[j]);
  }
  *old = cur;
  *n_old = n_cur;
}

References GNUNET_array_append, and GNUNET_assert.

Referenced by check_readiness().

Here is the caller graph for this function:

check_readiness()

static int check_readiness ( struct GNUNET_TESTBED_Operation *  op )

static

Checks for the readiness of an operation and schedules a operation start task.

Parameters

op	the operation

Definition at line 755 of file testbed_api_operations.c.

{
  struct GNUNET_TESTBED_Operation **evict_ops;
  struct GNUNET_TESTBED_Operation **ops;
  unsigned int n_ops;
  unsigned int n_evict_ops;
  unsigned int i;
 
  GNUNET_assert (NULL == op->rq_entry);
  GNUNET_assert (OP_STATE_WAITING == op->state);
  evict_ops = NULL;
  n_evict_ops = 0;
  for (i = 0; i < op->nqueues; i++)
  {
    ops = NULL;
    n_ops = 0;
    if (GNUNET_NO == decide_capacity (op->queues[i], op->qentries[i],
                                      &ops, &n_ops))
    {
      GNUNET_free (evict_ops);
      return GNUNET_NO;
    }
    if (NULL == ops)
      continue;
    merge_ops (&evict_ops, &n_evict_ops, ops, n_ops);
    GNUNET_free (ops);
  }
  if (NULL != evict_ops)
  {
    for (i = 0; i < n_evict_ops; i++)
      GNUNET_TESTBED_operation_release_ (evict_ops[i]);
    GNUNET_free (evict_ops);
    evict_ops = NULL;
    /* Evicting the operations should schedule this operation */
    GNUNET_assert (OP_STATE_READY == op->state);
    return GNUNET_YES;
  }
  for (i = 0; i < op->nqueues; i++)
    op->queues[i]->active += op->nres[i];
  change_state (op, OP_STATE_READY);
  rq_add (op);
  return GNUNET_YES;
}

References change_state(), decide_capacity(), GNUNET_assert, GNUNET_free, GNUNET_NO, GNUNET_TESTBED_operation_release_(), GNUNET_YES, merge_ops(), op, OP_STATE_READY, OP_STATE_WAITING, and rq_add().

Referenced by GNUNET_TESTBED_operation_begin_wait_(), and recheck_waiting().

Here is the call graph for this function:

Here is the caller graph for this function:

defer()

static void defer ( struct GNUNET_TESTBED_Operation *  op )

static

Defers a ready to be executed operation back to waiting.

Parameters

op	the operation to defer

Definition at line 806 of file testbed_api_operations.c.

{
  unsigned int i;
 
  GNUNET_assert (OP_STATE_READY == op->state);
  rq_remove (op);
  for (i = 0; i < op->nqueues; i++)
  {
    GNUNET_assert (op->queues[i]->active >= op->nres[i]);
    op->queues[i]->active -= op->nres[i];
  }
  change_state (op, OP_STATE_WAITING);
}

References change_state(), GNUNET_assert, op, OP_STATE_READY, OP_STATE_WAITING, and rq_remove().

Referenced by GNUNET_TESTBED_operation_queue_reset_max_active_().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_tslots()

static void cleanup_tslots ( struct OperationQueue *  queue )

static

Cleanups the array of timeslots of an operation queue.

For each time slot in the array, if it is allocated to an operation, it will be deallocated from the operation

Parameters

queue

the operation queue

Definition at line 829 of file testbed_api_operations.c.

{
  struct FeedbackCtx *fctx = queue->fctx;
  struct TimeSlot *tslot;
  struct GNUNET_TESTBED_Operation *op;
  unsigned int cnt;
 
  GNUNET_assert (NULL != fctx);
  for (cnt = 0; cnt < queue->max_active; cnt++)
  {
    tslot = &fctx->tslots_freeptr[cnt];
    op = tslot->op;
    if (NULL == op)
      continue;
    GNUNET_CONTAINER_DLL_remove (op->tslots_head, op->tslots_tail, tslot);
  }
  GNUNET_free (fctx->tslots_freeptr);
  fctx->tslots_freeptr = NULL;
  fctx->alloc_head = NULL;
  fctx->alloc_tail = NULL;
  fctx->tslots_filled = 0;
}

References FeedbackCtx::alloc_head, FeedbackCtx::alloc_tail, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, op, TimeSlot::op, queue(), FeedbackCtx::tslots_filled, and FeedbackCtx::tslots_freeptr.

Referenced by adaptive_queue_set_max_active(), and queue_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

adaptive_queue_set_max_active()

static void adaptive_queue_set_max_active ( struct OperationQueue *  queue, unsigned int  n  )

static

Cleansup the existing timing slots and sets new timing slots in the given queue to accommodate given number of max active operations.

Parameters

queue	the queue
n	the number of maximum active operations. If n is greater than the maximum limit set while creating the queue, then the minimum of these two will be selected as n

Definition at line 863 of file testbed_api_operations.c.

{
  struct FeedbackCtx *fctx = queue->fctx;
  struct TimeSlot *tslot;
  unsigned int cnt;
 
  cleanup_tslots (queue);
  n = GNUNET_MIN (n, fctx->max_active_bound);
  fctx->tslots_freeptr = GNUNET_malloc (n * sizeof(struct TimeSlot));
  fctx->nfailed = 0;
  for (cnt = 0; cnt < n; cnt++)
  {
    tslot = &fctx->tslots_freeptr[cnt];
    tslot->queue = queue;
    GNUNET_CONTAINER_DLL_insert_tail (fctx->alloc_head, fctx->alloc_tail,
                                      tslot);
  }
  GNUNET_TESTBED_operation_queue_reset_max_active_ (queue, n);
}

References FeedbackCtx::alloc_head, FeedbackCtx::alloc_tail, cleanup_tslots(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_malloc, GNUNET_MIN, GNUNET_TESTBED_operation_queue_reset_max_active_(), FeedbackCtx::max_active_bound, FeedbackCtx::nfailed, queue(), TimeSlot::queue, and FeedbackCtx::tslots_freeptr.

Referenced by adapt_parallelism(), and GNUNET_TESTBED_operation_queue_create_().

Here is the call graph for this function:

Here is the caller graph for this function:

adapt_parallelism()

static void adapt_parallelism ( struct OperationQueue *  queue )

static

Adapts parallelism in an adaptive queue by using the statistical data from the feedback context.

Parameters

queue

the queue

Definition at line 891 of file testbed_api_operations.c.

{
  struct GNUNET_TIME_Relative avg;
  struct FeedbackCtx *fctx;
  struct TimeSlot *tslot;
  int sd;
  unsigned int nvals;
  unsigned int cnt;
  unsigned int parallelism;
 
  avg = GNUNET_TIME_UNIT_ZERO;
  nvals = 0;
  fctx = queue->fctx;
  for (cnt = 0; cnt < queue->max_active; cnt++)
  {
    tslot = &fctx->tslots_freeptr[cnt];
    avg = GNUNET_TIME_relative_add (avg, tslot->tsum);
    nvals += tslot->nvals;
  }
  GNUNET_assert (nvals >= queue->max_active);
  GNUNET_assert (fctx->nfailed <= nvals);
  nvals -= fctx->nfailed;
  if (0 == nvals)
  {
    if (1 == queue->max_active)
      adaptive_queue_set_max_active (queue, 1);
    else
      adaptive_queue_set_max_active (queue, queue->max_active / 2);
    return;
  }
  avg = GNUNET_TIME_relative_divide (avg, nvals);
  GNUNET_TESTBED_SD_add_data_ (fctx->sd, (unsigned int) avg.rel_value_us);
  if (GNUNET_SYSERR ==
      GNUNET_TESTBED_SD_deviation_factor_ (fctx->sd,
                                           (unsigned int) avg.rel_value_us,
                                           &sd))
  {
    adaptive_queue_set_max_active (queue, queue->max_active);  /* no change */
    return;
  }
 
  parallelism = 0;
  if (-1 == sd)
    parallelism = queue->max_active + 1;
  if (sd <= -2)
    parallelism = queue->max_active * 2;
  if (1 == sd)
    parallelism = queue->max_active - 1;
  if (2 <= sd)
    parallelism = queue->max_active / 2;
  parallelism = GNUNET_MAX (parallelism, ADAPTIVE_QUEUE_DEFAULT_MAX_ACTIVE);
  adaptive_queue_set_max_active (queue, parallelism);
 
#if 0
  /* old algorithm */
  if (sd < 0)
    sd = 0;
  GNUNET_assert (0 <= sd);
  // GNUNET_TESTBED_SD_add_data_ (fctx->sd, (unsigned int) avg.rel_value_us);
  if (0 == sd)
  {
    adaptive_queue_set_max_active (queue, queue->max_active * 2);
    return;
  }
  if (1 == sd)
  {
    adaptive_queue_set_max_active (queue, queue->max_active + 1);
    return;
  }
  if (1 == queue->max_active)
  {
    adaptive_queue_set_max_active (queue, 1);
    return;
  }
  if (2 == sd)
  {
    adaptive_queue_set_max_active (queue, queue->max_active - 1);
    return;
  }
  adaptive_queue_set_max_active (queue, queue->max_active / 2);
#endif
}

References ADAPTIVE_QUEUE_DEFAULT_MAX_ACTIVE, adaptive_queue_set_max_active(), GNUNET_assert, GNUNET_MAX, GNUNET_SYSERR, GNUNET_TESTBED_SD_add_data_(), GNUNET_TESTBED_SD_deviation_factor_(), GNUNET_TIME_relative_add(), GNUNET_TIME_relative_divide(), GNUNET_TIME_UNIT_ZERO, FeedbackCtx::nfailed, TimeSlot::nvals, parallelism, queue(), GNUNET_TIME_Relative::rel_value_us, FeedbackCtx::sd, FeedbackCtx::tslots_freeptr, and TimeSlot::tsum.

Referenced by update_tslots().

Here is the call graph for this function:

Here is the caller graph for this function:

update_tslots()

static void update_tslots ( struct GNUNET_TESTBED_Operation *  op )

static

update tslots with the operation's completion time.

Additionally, if updating a timeslot makes all timeslots filled in an adaptive operation queue, call adapt_parallelism() for that queue.

Parameters

op	the operation

Definition at line 983 of file testbed_api_operations.c.

{
  struct OperationQueue *queue;
  struct GNUNET_TIME_Relative t;
  struct TimeSlot *tslot;
  struct FeedbackCtx *fctx;
  unsigned int i;
 
  t = GNUNET_TIME_absolute_get_duration (op->tstart);
  while (NULL != (tslot = op->tslots_head)) /* update time slots */
  {
    queue = tslot->queue;
    fctx = queue->fctx;
    GNUNET_CONTAINER_DLL_remove (op->tslots_head, op->tslots_tail, tslot);
    tslot->op = NULL;
    GNUNET_CONTAINER_DLL_insert_tail (fctx->alloc_head, fctx->alloc_tail,
                                      tslot);
    if (op->failed)
    {
      fctx->nfailed++;
      for (i = 0; i < op->nqueues; i++)
        if (queue == op->queues[i])
          break;
      GNUNET_assert (i != op->nqueues);
      op->queues[i]->overload += op->nres[i];
    }
    tslot->tsum = GNUNET_TIME_relative_add (tslot->tsum, t);
    if (0 != tslot->nvals++)
      continue;
    fctx->tslots_filled++;
    if (queue->max_active == fctx->tslots_filled)
      adapt_parallelism (queue);
  }
}

References adapt_parallelism(), FeedbackCtx::alloc_head, FeedbackCtx::alloc_tail, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_add(), FeedbackCtx::nfailed, TimeSlot::nvals, op, TimeSlot::op, queue(), TimeSlot::queue, t, FeedbackCtx::tslots_filled, and TimeSlot::tsum.

Referenced by GNUNET_TESTBED_operation_release_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_operation_create_()

struct GNUNET_TESTBED_Operation* GNUNET_TESTBED_operation_create_	(	void *	cls,
		OperationStart	start,
		OperationRelease	release
	)

Create an 'operation' to be performed.

Parameters

cls	closure for the callbacks
start	function to call to start the operation
release	function to call to close down the operation

Returns

handle to the operation

Definition at line 1028 of file testbed_api_operations.c.

{
  struct GNUNET_TESTBED_Operation *op;
 
  op = GNUNET_new (struct GNUNET_TESTBED_Operation);
  op->start = start;
  op->state = OP_STATE_INIT;
  op->release = release;
  op->cb_cls = cls;
  return op;
}

References GNUNET_new, op, OP_STATE_INIT, GNUNET_TESTBED_Operation::release, and start.

Referenced by GNUNET_TESTBED_controller_link(), GNUNET_TESTBED_get_slave_config_(), GNUNET_TESTBED_get_statistics(), GNUNET_TESTBED_overlay_configure_topology_va(), GNUNET_TESTBED_overlay_connect(), GNUNET_TESTBED_peer_create(), GNUNET_TESTBED_peer_destroy(), GNUNET_TESTBED_peer_get_information(), GNUNET_TESTBED_peer_manage_service(), GNUNET_TESTBED_peer_start(), GNUNET_TESTBED_peer_stop(), GNUNET_TESTBED_peer_update_configuration(), GNUNET_TESTBED_service_connect(), GNUNET_TESTBED_shutdown_peers(), GST_connection_pool_get_handle(), and GST_neighbour_get_connection().

Here is the caller graph for this function:

GNUNET_TESTBED_operation_queue_create_()

struct OperationQueue* GNUNET_TESTBED_operation_queue_create_	(	enum OperationQueueType	type,
		unsigned int	max_active
	)

Create an operation queue.

Parameters

type	the type of operation queue
max_active	maximum number of operations in this queue that can be active in parallel at the same time.

Returns

handle to the queue

Definition at line 1043 of file testbed_api_operations.c.

{
  struct OperationQueue *queue;
  struct FeedbackCtx *fctx;
 
  queue = GNUNET_new (struct OperationQueue);
  queue->type = type;
  if (OPERATION_QUEUE_TYPE_FIXED == type)
  {
    queue->max_active = max_active;
  }
  else
  {
    fctx = GNUNET_new (struct FeedbackCtx);
    fctx->max_active_bound = max_active;
    fctx->sd = GNUNET_TESTBED_SD_init_ (ADAPTIVE_QUEUE_DEFAULT_HISTORY);
    queue->fctx = fctx;
    adaptive_queue_set_max_active (queue, ADAPTIVE_QUEUE_DEFAULT_MAX_ACTIVE);
  }
  return queue;
}

References ADAPTIVE_QUEUE_DEFAULT_HISTORY, ADAPTIVE_QUEUE_DEFAULT_MAX_ACTIVE, adaptive_queue_set_max_active(), GNUNET_new, GNUNET_TESTBED_SD_init_(), FeedbackCtx::max_active_bound, OPERATION_QUEUE_TYPE_FIXED, queue(), FeedbackCtx::sd, and type.

Referenced by GNUNET_TESTBED_controller_connect(), GNUNET_TESTBED_get_statistics(), GNUNET_TESTBED_host_create_with_id(), and testbed_run().

Here is the call graph for this function:

Here is the caller graph for this function:

queue_destroy()

static void queue_destroy ( struct OperationQueue *  queue )

static

Cleanup the given operation queue.

Parameters

queue

the operation queue to destroy

Definition at line 1073 of file testbed_api_operations.c.

{
  struct FeedbackCtx *fctx;
 
  if (OPERATION_QUEUE_TYPE_ADAPTIVE == queue->type)
  {
    cleanup_tslots (queue);
    fctx = queue->fctx;
    GNUNET_TESTBED_SD_destroy_ (fctx->sd);
    GNUNET_free (fctx);
  }
  GNUNET_free (queue);
}

References cleanup_tslots(), GNUNET_free, GNUNET_TESTBED_SD_destroy_(), OPERATION_QUEUE_TYPE_ADAPTIVE, queue(), and FeedbackCtx::sd.

Referenced by __attribute__(), and GNUNET_TESTBED_operation_queue_destroy_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_operation_queue_destroy_()

void GNUNET_TESTBED_operation_queue_destroy_

(

struct OperationQueue *

queue

)

Destroys an operation queue.

Destroy an operation queue.

If the queue is still in use by operations it is marked as expired and its resources are released in the destructor GNUNET_TESTBED_operations_fini().

Parameters

queue

queue to destroy

Definition at line 1096 of file testbed_api_operations.c.

{
  if (GNUNET_YES != is_queue_empty (queue))
  {
    GNUNET_assert (0 == queue->expired);  /* Are you calling twice on same queue? */
    queue->expired = 1;
    GNUNET_array_append (expired_opqs, n_expired_opqs, queue);
    return;
  }
  queue_destroy (queue);
}

References expired_opqs, GNUNET_array_append, GNUNET_assert, GNUNET_YES, is_queue_empty(), n_expired_opqs, queue(), and queue_destroy().

Referenced by GNUNET_TESTBED_controller_disconnect(), GNUNET_TESTBED_host_destroy(), GNUNET_TESTBED_operation_queue_destroy_empty_(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_operation_queue_destroy_empty_()

int GNUNET_TESTBED_operation_queue_destroy_empty_

(

struct OperationQueue *

queue

)

Destroys the operation queue if it is empty.

If not empty return GNUNET_NO.

Parameters

queue

the queue to destroy if empty

Returns

GNUNET_YES if the queue is destroyed. GNUNET_NO if not (because it is not empty)

Definition at line 1117 of file testbed_api_operations.c.

{
  if (GNUNET_NO == is_queue_empty (queue))
    return GNUNET_NO;
  GNUNET_TESTBED_operation_queue_destroy_ (queue);
  return GNUNET_YES;
}

References GNUNET_NO, GNUNET_TESTBED_operation_queue_destroy_(), GNUNET_YES, is_queue_empty(), and queue().

Referenced by oprelease_get_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

recheck_waiting()

static void recheck_waiting ( struct OperationQueue *  opq )

static

Rechecks if any of the operations in the given operation queue's waiting list can be made active.

Parameters

opq	the operation queue

Definition at line 1133 of file testbed_api_operations.c.

{
  struct QueueEntry *entry;
  struct QueueEntry *entry2;
 
  entry = opq->wq_head;
  while (NULL != entry)
  {
    entry2 = entry->next;
    if (GNUNET_NO == check_readiness (entry->op))
      break;
    entry = entry2;
  }
}

References check_readiness(), GNUNET_NO, QueueEntry::next, QueueEntry::op, and OperationQueue::wq_head.

Referenced by GNUNET_TESTBED_operation_inactivate_(), GNUNET_TESTBED_operation_queue_reset_max_active_(), and GNUNET_TESTBED_operation_release_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_operation_queue_reset_max_active_()

void GNUNET_TESTBED_operation_queue_reset_max_active_	(	struct OperationQueue *	queue,
		unsigned int	max_active
	)

Function to reset the maximum number of operations in the given queue.

If max_active is lesser than the number of currently active operations, the active operations are not stopped immediately.

Parameters

queue	the operation queue which has to be modified
max_active	the new maximum number of active operations

Definition at line 1158 of file testbed_api_operations.c.

{
  struct QueueEntry *entry;
 
  queue->max_active = max_active;
  queue->overload = 0;
  while ((queue->active > queue->max_active)
         && (NULL != (entry = queue->rq_head)))
    defer (entry->op);
  recheck_waiting (queue);
}

References defer(), QueueEntry::op, queue(), and recheck_waiting().

Referenced by adaptive_queue_set_max_active().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_operation_queue_insert2_()

void GNUNET_TESTBED_operation_queue_insert2_	(	struct OperationQueue *	queue,
		struct GNUNET_TESTBED_Operation *	op,
		unsigned int	nres
	)

Add an operation to a queue.

An operation can be in multiple queues at once. Once the operation is inserted into all the queues GNUNET_TESTBED_operation_begin_wait_() has to be called to actually start waiting for the operation to become active.

Parameters

queue	queue to add the operation to
op	operation to add to the queue
nres	the number of units of the resources of queue needed by the operation. Should be greater than 0.

Definition at line 1184 of file testbed_api_operations.c.

{
  unsigned int qsize;
 
  GNUNET_assert (0 < nres);
  qsize = op->nqueues;
  GNUNET_array_append (op->queues, op->nqueues, queue);
  GNUNET_array_append (op->nres, qsize, nres);
  GNUNET_assert (qsize == op->nqueues);
}

References GNUNET_array_append, GNUNET_assert, QueueEntry::nres, op, and queue().

Referenced by GNUNET_TESTBED_operation_queue_insert_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_operation_queue_insert_()

void GNUNET_TESTBED_operation_queue_insert_	(	struct OperationQueue *	queue,
		struct GNUNET_TESTBED_Operation *	op
	)

Add an operation to a queue.

An operation can be in multiple queues at once. Once the operation is inserted into all the queues GNUNET_TESTBED_operation_begin_wait_() has to be called to actually start waiting for the operation to become active. The operation is assumed to take 1 queue resource. Use GNUNET_TESTBED_operation_queue_insert2_() if it requires more than 1

Parameters

queue	queue to add the operation to
op	operation to add to the queue

Definition at line 1210 of file testbed_api_operations.c.

{
  return GNUNET_TESTBED_operation_queue_insert2_ (queue, op, 1);
}

References GNUNET_TESTBED_operation_queue_insert2_(), op, and queue().

Referenced by GNUNET_TESTBED_controller_link(), GNUNET_TESTBED_get_slave_config_(), GNUNET_TESTBED_get_statistics(), GNUNET_TESTBED_host_queue_oc_(), GNUNET_TESTBED_overlay_configure_topology_va(), GNUNET_TESTBED_peer_create(), GNUNET_TESTBED_peer_destroy(), GNUNET_TESTBED_peer_get_information(), GNUNET_TESTBED_peer_manage_service(), GNUNET_TESTBED_peer_start(), GNUNET_TESTBED_peer_stop(), GNUNET_TESTBED_peer_update_configuration(), GNUNET_TESTBED_service_connect(), GNUNET_TESTBED_shutdown_peers(), GST_connection_pool_get_handle(), and GST_neighbour_get_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_operation_begin_wait_()

void GNUNET_TESTBED_operation_begin_wait_

(

struct GNUNET_TESTBED_Operation *

op

)

Marks the given operation as waiting on the queues.

Once all queues permit the operation to become active, the operation will be activated. The actual activation will occur in a separate task (thus allowing multiple queue insertions to be made without having the first one instantly trigger the operation if the first queue has sufficient resources).

Parameters

op	the operation to marks as waiting

Definition at line 1227 of file testbed_api_operations.c.

{
  GNUNET_assert (NULL == op->rq_entry);
  change_state (op, OP_STATE_WAITING);
  (void) check_readiness (op);
}

References change_state(), check_readiness(), GNUNET_assert, op, and OP_STATE_WAITING.

Referenced by GNUNET_TESTBED_controller_link(), GNUNET_TESTBED_get_slave_config_(), GNUNET_TESTBED_get_statistics(), GNUNET_TESTBED_overlay_configure_topology_va(), GNUNET_TESTBED_overlay_connect(), GNUNET_TESTBED_peer_create(), GNUNET_TESTBED_peer_destroy(), GNUNET_TESTBED_peer_get_information(), GNUNET_TESTBED_peer_manage_service(), GNUNET_TESTBED_peer_start(), GNUNET_TESTBED_peer_stop(), GNUNET_TESTBED_peer_update_configuration(), GNUNET_TESTBED_service_connect(), GNUNET_TESTBED_shutdown_peers(), GST_connection_pool_get_handle(), and GST_neighbour_get_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_operation_inactivate_()

void GNUNET_TESTBED_operation_inactivate_

(

struct GNUNET_TESTBED_Operation *

op

)

Marks an active operation as inactive - the operation will be kept in a ready-to-be-released state and continues to hold resources until another operation contents for them.

Parameters

op	the operation to be marked as inactive. The operation start callback should have been called before for this operation to mark it as inactive.

Definition at line 1245 of file testbed_api_operations.c.

{
  struct OperationQueue **queues;
  size_t ms;
  unsigned int nqueues;
  unsigned int i;
 
  GNUNET_assert (OP_STATE_ACTIVE == op->state);
  change_state (op, OP_STATE_INACTIVE);
  nqueues = op->nqueues;
  ms = sizeof(struct OperationQueue *) * nqueues;
  queues = GNUNET_malloc (ms);
  /* Cloning is needed as the operation be released by waiting operations and
     hence its nqueues memory ptr will be freed */
  GNUNET_memcpy (queues, op->queues, ms);
  for (i = 0; i < nqueues; i++)
    recheck_waiting (queues[i]);
  GNUNET_free (queues);
}

References change_state(), GNUNET_assert, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, op, OP_STATE_ACTIVE, OP_STATE_INACTIVE, and recheck_waiting().

Referenced by GST_neighbour_get_connection_cancel(), and GST_neighbour_release_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_operation_activate_()

void GNUNET_TESTBED_operation_activate_

(

struct GNUNET_TESTBED_Operation *

op

)

Marks and inactive operation as active.

This function should be called to ensure that the oprelease callback will not be called until it is either marked as inactive or released.

Parameters

op	the operation to be marked as active

Definition at line 1274 of file testbed_api_operations.c.

{
  GNUNET_assert (OP_STATE_INACTIVE == op->state);
  change_state (op, OP_STATE_ACTIVE);
}

References change_state(), GNUNET_assert, op, OP_STATE_ACTIVE, and OP_STATE_INACTIVE.

Referenced by GNUNET_TESTBED_operation_release_(), and trigger_notifications().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_operation_release_()

void GNUNET_TESTBED_operation_release_

(

struct GNUNET_TESTBED_Operation *

op

)

An operation is 'done' (was cancelled or finished); remove it from the queues and release associated resources.

Parameters

op	operation that finished

Definition at line 1288 of file testbed_api_operations.c.

{
  struct QueueEntry *entry;
  struct OperationQueue *opq;
  unsigned int i;
 
  if (OP_STATE_INIT == op->state)
  {
    GNUNET_free (op);
    return;
  }
  if (OP_STATE_READY == op->state)
    rq_remove (op);
  if (OP_STATE_INACTIVE == op->state) /* Activate the operation if inactive */
    GNUNET_TESTBED_operation_activate_ (op);
  if (OP_STATE_ACTIVE == op->state)
    update_tslots (op);
  GNUNET_assert (NULL != op->queues);
  GNUNET_assert (NULL != op->qentries);
  for (i = 0; i < op->nqueues; i++)
  {
    entry = op->qentries[i];
    remove_queue_entry (op, i);
    opq = op->queues[i];
    switch (op->state)
    {
    case OP_STATE_INIT:
    case OP_STATE_INACTIVE:
      GNUNET_assert (0);
      break;
 
    case OP_STATE_WAITING:
      break;
 
    case OP_STATE_ACTIVE:
    case OP_STATE_READY:
      GNUNET_assert (0 != opq->active);
      GNUNET_assert (opq->active >= entry->nres);
      opq->active -= entry->nres;
      recheck_waiting (opq);
      break;
    }
    GNUNET_free (entry);
  }
  GNUNET_free (op->qentries);
  GNUNET_free (op->queues);
  GNUNET_free (op->nres);
  if (NULL != op->release)
    op->release (op->cb_cls);
  GNUNET_free (op);
}

References OperationQueue::active, GNUNET_assert, GNUNET_free, GNUNET_TESTBED_operation_activate_(), QueueEntry::nres, op, OP_STATE_ACTIVE, OP_STATE_INACTIVE, OP_STATE_INIT, OP_STATE_READY, OP_STATE_WAITING, recheck_waiting(), remove_queue_entry(), rq_remove(), and update_tslots().

Referenced by check_readiness(), GNUNET_TESTBED_operation_done(), and GST_neighbour_list_clean().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_operation_mark_failed()

void GNUNET_TESTBED_operation_mark_failed

(

struct GNUNET_TESTBED_Operation *

op

)

Marks an operation as failed.

Parameters

op	the operation to be marked as failed

Definition at line 1347 of file testbed_api_operations.c.

{
  op->failed = GNUNET_YES;
}

References GNUNET_YES, and op.

Referenced by handle_op_fail_event().

Here is the caller graph for this function:

__attribute__()

void __attribute__

(

(destructor)

)

Cleanup expired operation queues.

While doing so, also check for any operations which are not completed and warn about them.

Definition at line 1357 of file testbed_api_operations.c.

{
  struct OperationQueue *queue;
  unsigned int i;
  int warn = 0;
 
  for (i = 0; i < n_expired_opqs; i++)
  {
    queue = expired_opqs[i];
    if (GNUNET_NO == is_queue_empty (queue))
      warn = 1;
    queue_destroy (queue);
  }
  GNUNET_free (expired_opqs);
  n_expired_opqs = 0;
  if (warn)
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Be disciplined.  Some operations were not marked as done.\n");
}

References expired_opqs, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_NO, is_queue_empty(), n_expired_opqs, queue(), and queue_destroy().

Here is the call graph for this function:

Variable Documentation

rq_head

struct ReadyQueueEntry* rq_head

static

DLL head for the ready queue.

Definition at line 382 of file testbed_api_operations.c.

Referenced by process_rq_task(), rq_add(), and rq_remove().

rq_tail

struct ReadyQueueEntry* rq_tail

static

DLL tail for the ready queue.

Definition at line 387 of file testbed_api_operations.c.

Referenced by rq_add(), and rq_remove().

expired_opqs

struct OperationQueue** expired_opqs

static

Array of operation queues which are to be destroyed.

Definition at line 392 of file testbed_api_operations.c.

Referenced by __attribute__(), and GNUNET_TESTBED_operation_queue_destroy_().

n_expired_opqs

unsigned int n_expired_opqs

static

Number of expired operation queues in the above array.

Definition at line 397 of file testbed_api_operations.c.

Referenced by __attribute__(), and GNUNET_TESTBED_operation_queue_destroy_().

process_rq_task_id

struct GNUNET_SCHEDULER_Task* process_rq_task_id

The id of the task to process the ready queue.

Definition at line 402 of file testbed_api_operations.c.

Referenced by process_rq_task(), rq_add(), and rq_remove().