plugin_datastore_heap.c File Reference

heap-based datastore backend; usually we want the datastore to be persistent, and storing data in the heap is obviously NOT going to be persistent; still, this plugin is useful for testing/benchmarking — but never for production! More...

#include "platform.h"
#include "gnunet_datastore_plugin.h"

Include dependency graph for plugin_datastore_heap.c:

Go to the source code of this file.

Data Structures
struct	Value
	Entry in the hash map. More...
struct	ZeroAnonByType
	We organize 0-anonymity values in arrays "by type". More...
struct	Plugin
	Handle for a plugin. More...
struct	UpdateContext
	Closure for update_rel_sum() and update_abs_sum(). More...
struct	GetContext
	Closure for get_cb(). More...
struct	GetAllContext
	Closure for the 'return_value' function. More...
struct	RemoveContext
	Closure for iterator called during 'remove_key'. More...

Functions
static void	heap_plugin_estimate_size (void *cls, unsigned long long *estimate)
	Get an estimate of how much space the database is currently using. More...
static int	update_iterator (void *cls, const struct GNUNET_HashCode *key, void *val)
	Update the matching value. More...
static void	heap_plugin_put (void *cls, const struct GNUNET_HashCode *key, bool absent, uint32_t size, const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, uint32_t replication, struct GNUNET_TIME_Absolute expiration, PluginPutCont cont, void *cont_cls)
	Store an item in the datastore. More...
static void	delete_value (struct Plugin *plugin, struct Value *value)
	Delete the given value, removing it from the plugin's data structures. More...
static int	get_iterator (void *cls, const struct GNUNET_HashCode *key, void *val)
	Obtain the matching value with the lowest uid >= next_uid. More...
static void	heap_plugin_get_key (void *cls, uint64_t next_uid, bool random, const struct GNUNET_HashCode *key, enum GNUNET_BLOCK_Type type, PluginDatumProcessor proc, void *proc_cls)
	Get one of the results for a particular key in the datastore. More...
static void	heap_plugin_get_replication (void *cls, PluginDatumProcessor proc, void *proc_cls)
	Get a random item for replication. More...
static void	heap_plugin_get_expiration (void *cls, PluginDatumProcessor proc, void *proc_cls)
	Get a random item for expiration. More...
static void	heap_plugin_get_zero_anonymity (void *cls, uint64_t next_uid, enum GNUNET_BLOCK_Type type, PluginDatumProcessor proc, void *proc_cls)
	Call the given processor on an item with zero anonymity. More...
static void	heap_plugin_drop (void *cls)
	Drop database. More...
static int	return_value (void *cls, const struct GNUNET_HashCode *key, void *val)
	Callback invoked to call callback on each value. More...
static void	heap_get_keys (void *cls, PluginKeyProcessor proc, void *proc_cls)
	Get all of the keys in the datastore. More...
static int	remove_iterator (void *cls, const struct GNUNET_HashCode *key, void *val)
	Obtain the matching value with the lowest uid >= next_uid. More...
static void	heap_plugin_remove_key (void *cls, const struct GNUNET_HashCode *key, uint32_t size, const void *data, PluginRemoveCont cont, void *cont_cls)
	Remove a particular key in the datastore. More...
void *	libgnunet_plugin_datastore_heap_init (void *cls)
	Entry point for the plugin. More...
static int	free_value (void *cls, const struct GNUNET_HashCode *key, void *val)
	Callback invoked to free all value. More...
void *	libgnunet_plugin_datastore_heap_done (void *cls)
	Exit point from the plugin. More...

Detailed Description

heap-based datastore backend; usually we want the datastore to be persistent, and storing data in the heap is obviously NOT going to be persistent; still, this plugin is useful for testing/benchmarking — but never for production!

Author

Christian Grothoff

Definition in file plugin_datastore_heap.c.

Function Documentation

heap_plugin_estimate_size()

static void heap_plugin_estimate_size ( void *  cls, unsigned long long *  estimate  )

static

Get an estimate of how much space the database is currently using.

Parameters

cls	our "struct Plugin*"

Returns

number of bytes used on disk

Definition at line 184 of file plugin_datastore_heap.c.

{
  struct Plugin *plugin = cls;
 
  if (NULL != estimate)
    *estimate = plugin->size;
}

References plugin.

Referenced by libgnunet_plugin_datastore_heap_init().

Here is the caller graph for this function:

update_iterator()

static int update_iterator ( void *  cls, const struct GNUNET_HashCode *  key, void *  val  )

static

Update the matching value.

Parameters

cls	the 'struct UpdateContext'
key	unused
val	the 'struct Value'

Returns

GNUNET_YES (continue iteration), GNUNET_NO if value was found

Definition at line 239 of file plugin_datastore_heap.c.

{
  struct UpdateContext *uc = cls;
  struct Value *value = val;
 
  if (value->size != uc->size)
    return GNUNET_YES;
  if (0 != memcmp (value->data, uc->data, uc->size))
    return GNUNET_YES;
  uc->expiration = GNUNET_TIME_absolute_max (value->expiration,
                                             uc->expiration);
  if (value->expiration.abs_value_us != uc->expiration.abs_value_us)
  {
    value->expiration = uc->expiration;
    GNUNET_CONTAINER_heap_update_cost (value->expire_heap,
                                       value->expiration.abs_value_us);
  }
  /* Saturating adds, don't overflow */
  if (value->priority > UINT32_MAX - uc->priority)
    value->priority = UINT32_MAX;
  else
    value->priority += uc->priority;
  if (value->replication > UINT32_MAX - uc->replication)
    value->replication = UINT32_MAX;
  else
    value->replication += uc->replication;
  uc->updated = true;
  return GNUNET_NO;
}

References GNUNET_CONTAINER_heap_update_cost(), GNUNET_NO, GNUNET_TIME_absolute_max(), GNUNET_YES, uc, and value.

Referenced by heap_plugin_put().

Here is the call graph for this function:

Here is the caller graph for this function:

heap_plugin_put()

static void heap_plugin_put ( void *  cls, const struct GNUNET_HashCode *  key, bool  absent, uint32_t  size, const void *  data, enum GNUNET_BLOCK_Type  type, uint32_t  priority, uint32_t  anonymity, uint32_t  replication, struct GNUNET_TIME_Absolute  expiration, PluginPutCont  cont, void *  cont_cls  )

static

Store an item in the datastore.

Parameters

cls	closure
key	key for the item
absent	true if the key was not found in the bloom filter
size	number of bytes in data
data	content stored
type	type of the content
priority	priority of the content
anonymity	anonymity-level for the content
replication	replication-level for the content
expiration	expiration time for the content
cont	continuation called with success or failure status
cont_cls	continuation closure

Definition at line 289 of file plugin_datastore_heap.c.

{
  struct Plugin *plugin = cls;
  struct Value *value;
 
  if (! absent)
  {
    struct UpdateContext uc;
 
    uc.size = size;
    uc.data = data;
    uc.priority = priority;
    uc.replication = replication;
    uc.expiration = expiration;
    uc.updated = false;
    GNUNET_CONTAINER_multihashmap_get_multiple (plugin->keyvalue,
                                                key,
                                                &update_iterator,
                                                &uc);
    if (uc.updated)
    {
      cont (cont_cls, key, size, GNUNET_NO, NULL);
      return;
    }
  }
  value = GNUNET_malloc (sizeof(struct Value) + size);
  value->key = *key;
  value->data = &value[1];
  value->expire_heap = GNUNET_CONTAINER_heap_insert (plugin->by_expiration,
                                                     value,
                                                     expiration.abs_value_us);
  value->replication_heap = GNUNET_CONTAINER_heap_insert (
    plugin->by_replication,
    value,
    replication);
  value->expiration = expiration;
  if (0 == anonymity)
  {
    struct ZeroAnonByType *zabt;
 
    for (zabt = plugin->zero_head; NULL != zabt; zabt = zabt->next)
      if (zabt->type == type)
        break;
    if (NULL == zabt)
    {
      zabt = GNUNET_new (struct ZeroAnonByType);
      zabt->type = type;
      GNUNET_CONTAINER_DLL_insert (plugin->zero_head,
                                   plugin->zero_tail,
                                   zabt);
    }
    if (zabt->array_size == zabt->array_pos)
    {
      GNUNET_array_grow (zabt->array,
                         zabt->array_size,
                         zabt->array_size * 2 + 4);
    }
    value->zero_anon_offset = zabt->array_pos;
    zabt->array[zabt->array_pos++] = value;
  }
  value->size = size;
  value->priority = priority;
  value->anonymity = anonymity;
  value->replication = replication;
  value->type = type;
  GNUNET_memcpy (&value[1], data, size);
  GNUNET_CONTAINER_multihashmap_put (plugin->keyvalue,
                                     &value->key,
                                     value,
                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  plugin->size += size;
  cont (cont_cls, key, size, GNUNET_OK, NULL);
}

References anonymity, ZeroAnonByType::array, ZeroAnonByType::array_pos, ZeroAnonByType::array_size, data, expiration, GNUNET_array_grow, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_OK, key, ZeroAnonByType::next, plugin, UpdateContext::priority, replication, size, ZeroAnonByType::type, type, uc, update_iterator(), and value.

Referenced by libgnunet_plugin_datastore_heap_init().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_value()

static void delete_value ( struct Plugin *  plugin, struct Value *  value  )

static

Delete the given value, removing it from the plugin's data structures.

Parameters

plugin	the plugin
value	value to delete

Definition at line 383 of file plugin_datastore_heap.c.

{
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap_remove (plugin->keyvalue,
                                                       &value->key,
                                                       value));
  GNUNET_assert (value == GNUNET_CONTAINER_heap_remove_node (
                   value->expire_heap));
  GNUNET_assert (value == GNUNET_CONTAINER_heap_remove_node (
                   value->replication_heap));
  if (0 == value->anonymity)
  {
    struct ZeroAnonByType *zabt;
 
    for (zabt = plugin->zero_head; NULL != zabt; zabt = zabt->next)
      if (zabt->type == value->type)
        break;
    GNUNET_assert (NULL != zabt);
    zabt->array[value->zero_anon_offset] = zabt->array[--zabt->array_pos];
    zabt->array[value->zero_anon_offset]->zero_anon_offset =
      value->zero_anon_offset;
    if (0 == zabt->array_pos)
    {
      GNUNET_array_grow (zabt->array,
                         zabt->array_size,
                         0);
      GNUNET_CONTAINER_DLL_remove (plugin->zero_head,
                                   plugin->zero_tail,
                                   zabt);
      GNUNET_free (zabt);
    }
  }
  plugin->size -= value->size;
  GNUNET_free (value);
}

References ZeroAnonByType::array, ZeroAnonByType::array_pos, ZeroAnonByType::array_size, GNUNET_array_grow, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_YES, ZeroAnonByType::next, plugin, ZeroAnonByType::type, value, and Value::zero_anon_offset.

Referenced by free_value(), heap_plugin_get_expiration(), and heap_plugin_remove_key().

Here is the call graph for this function:

Here is the caller graph for this function:

get_iterator()

static int get_iterator ( void *  cls, const struct GNUNET_HashCode *  key, void *  val  )

static

Obtain the matching value with the lowest uid >= next_uid.

Parameters

cls	the 'struct GetContext'
key	unused
val	the 'struct Value'

Returns

GNUNET_YES (continue iteration), GNUNET_NO if result was found

Definition at line 457 of file plugin_datastore_heap.c.

{
  struct GetContext *gc = cls;
  struct Value *value = val;
 
  if ((gc->type != GNUNET_BLOCK_TYPE_ANY) &&
      (gc->type != value->type))
    return GNUNET_OK;
  if (gc->random)
  {
    gc->value = value;
    return GNUNET_NO;
  }
  if ((uint64_t) (intptr_t) value < gc->next_uid)
    return GNUNET_OK;
  if ((NULL != gc->value) &&
      (value > gc->value))
    return GNUNET_OK;
  gc->value = value;
  return GNUNET_OK;
}

References GNUNET_BLOCK_TYPE_ANY, GNUNET_NO, GNUNET_OK, GetContext::random, GetContext::type, GetContext::value, and value.

Referenced by heap_plugin_get_key().

Here is the caller graph for this function:

heap_plugin_get_key()

static void heap_plugin_get_key ( void *  cls, uint64_t  next_uid, bool  random, const struct GNUNET_HashCode *  key, enum GNUNET_BLOCK_Type  type, PluginDatumProcessor  proc, void *  proc_cls  )

static

Get one of the results for a particular key in the datastore.

Parameters

cls	closure
next_uid	return the result with lowest uid >= next_uid
random	if true, return a random result instead of using next_uid
key	maybe NULL (to match all entries)
type	entries of which type are relevant? Use 0 for any type.
proc	function to call on the matching value; will be called with NULL if nothing matches
proc_cls	closure for proc

Definition at line 496 of file plugin_datastore_heap.c.

{
  struct Plugin *plugin = cls;
  struct GetContext gc;
 
  gc.value = NULL;
  gc.next_uid = next_uid;
  gc.random = random;
  gc.type = type;
  if (NULL == key)
  {
    GNUNET_CONTAINER_multihashmap_iterate (plugin->keyvalue,
                                           &get_iterator,
                                           &gc);
  }
  else
  {
    GNUNET_CONTAINER_multihashmap_get_multiple (plugin->keyvalue,
                                                key,
                                                &get_iterator,
                                                &gc);
  }
  if (NULL == gc.value)
  {
    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
    return;
  }
  GNUNET_assert (GNUNET_OK ==
                 proc (proc_cls,
                       &gc.value->key,
                       gc.value->size,
                       &gc.value[1],
                       gc.value->type,
                       gc.value->priority,
                       gc.value->anonymity,
                       gc.value->replication,
                       gc.value->expiration,
                       (uint64_t) (intptr_t) gc.value));
}

References Value::anonymity, Value::expiration, get_iterator(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_OK, GNUNET_TIME_UNIT_ZERO_ABS, Value::key, key, GetContext::next_uid, plugin, Value::priority, GetContext::random, Value::replication, Value::size, GetContext::type, Value::type, type, and GetContext::value.

Referenced by libgnunet_plugin_datastore_heap_init().

Here is the call graph for this function:

Here is the caller graph for this function:

heap_plugin_get_replication()

static void heap_plugin_get_replication ( void *  cls, PluginDatumProcessor  proc, void *  proc_cls  )

static

Get a random item for replication.

Returns a single, not expired, random item from those with the highest replication counters. The item's replication counter is decremented by one IF it was positive before. Call 'proc' with all values ZERO or NULL if the datastore is empty.

Parameters

cls	closure
proc	function to call the value (once only).
proc_cls	closure for proc

Definition at line 555 of file plugin_datastore_heap.c.

{
  struct Plugin *plugin = cls;
  struct Value *value;
 
  value = GNUNET_CONTAINER_heap_remove_root (plugin->by_replication);
  if (NULL == value)
  {
    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
    return;
  }
  if (value->replication > 0)
  {
    value->replication--;
    value->replication_heap = GNUNET_CONTAINER_heap_insert (
      plugin->by_replication,
      value,
      value->replication);
  }
  else
  {
    /* need a better way to pick a random item, replication level is always 0 */
    value->replication_heap = GNUNET_CONTAINER_heap_insert (
      plugin->by_replication,
      value,
      value->replication);
    value = GNUNET_CONTAINER_heap_walk_get_next (plugin->by_replication);
  }
  GNUNET_assert (GNUNET_OK ==
                 proc (proc_cls,
                       &value->key,
                       value->size,
                       &value[1],
                       value->type,
                       value->priority,
                       value->anonymity,
                       value->replication,
                       value->expiration,
                       (uint64_t) (intptr_t) value));
}

References GNUNET_assert, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_CONTAINER_heap_walk_get_next(), GNUNET_OK, GNUNET_TIME_UNIT_ZERO_ABS, plugin, and value.

Referenced by libgnunet_plugin_datastore_heap_init().

Here is the call graph for this function:

Here is the caller graph for this function:

heap_plugin_get_expiration()

static void heap_plugin_get_expiration ( void *  cls, PluginDatumProcessor  proc, void *  proc_cls  )

static

Get a random item for expiration.

Call 'proc' with all values ZERO or NULL if the datastore is empty.

Parameters

cls	closure
proc	function to call the value (once only).
proc_cls	closure for proc

Definition at line 608 of file plugin_datastore_heap.c.

{
  struct Plugin *plugin = cls;
  struct Value *value;
 
  value = GNUNET_CONTAINER_heap_peek (plugin->by_expiration);
  if (NULL == value)
  {
    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
    return;
  }
  if (GNUNET_NO ==
      proc (proc_cls,
            &value->key,
            value->size,
            &value[1],
            value->type,
            value->priority,
            value->anonymity,
            value->replication,
            value->expiration,
            (uint64_t) (intptr_t) value))
    delete_value (plugin, value);
}

References delete_value(), GNUNET_CONTAINER_heap_peek(), GNUNET_NO, GNUNET_TIME_UNIT_ZERO_ABS, plugin, and value.

Referenced by libgnunet_plugin_datastore_heap_init().

Here is the call graph for this function:

Here is the caller graph for this function:

heap_plugin_get_zero_anonymity()

static void heap_plugin_get_zero_anonymity ( void *  cls, uint64_t  next_uid, enum GNUNET_BLOCK_Type  type, PluginDatumProcessor  proc, void *  proc_cls  )

static

Call the given processor on an item with zero anonymity.

Parameters

cls	our "struct Plugin*"
next_uid	return the result with lowest uid >= next_uid
type	entries of which type should be considered? Must not be zero (ANY).
proc	function to call on each matching value; will be called with NULL if no value matches
proc_cls	closure for proc

Definition at line 647 of file plugin_datastore_heap.c.

{
  struct Plugin *plugin = cls;
  struct ZeroAnonByType *zabt;
  struct Value *value = NULL;
 
  for (zabt = plugin->zero_head; NULL != zabt; zabt = zabt->next)
  {
    if ((type != GNUNET_BLOCK_TYPE_ANY) &&
        (type != zabt->type))
      continue;
    for (int i = 0; i < zabt->array_pos; ++i)
    {
      if ((uint64_t) (intptr_t) zabt->array[i] < next_uid)
        continue;
      if ((NULL != value) &&
          (zabt->array[i] > value))
        continue;
      value = zabt->array[i];
    }
  }
  if (NULL == value)
  {
    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
    return;
  }
  GNUNET_assert (GNUNET_OK ==
                 proc (proc_cls,
                       &value->key,
                       value->size,
                       &value[1],
                       value->type,
                       value->priority,
                       value->anonymity,
                       value->replication,
                       value->expiration,
                       (uint64_t) (intptr_t) value));
}

References ZeroAnonByType::array, ZeroAnonByType::array_pos, GNUNET_assert, GNUNET_BLOCK_TYPE_ANY, GNUNET_OK, GNUNET_TIME_UNIT_ZERO_ABS, ZeroAnonByType::next, plugin, ZeroAnonByType::type, type, and value.

Referenced by libgnunet_plugin_datastore_heap_init().

Here is the caller graph for this function:

heap_plugin_drop()

static void heap_plugin_drop ( void *  cls )

static

Drop database.

Definition at line 693 of file plugin_datastore_heap.c.

{
  /* nothing needs to be done */
}

Referenced by libgnunet_plugin_datastore_heap_init().

Here is the caller graph for this function:

return_value()

static int return_value ( void *  cls, const struct GNUNET_HashCode *  key, void *  val  )

static

Callback invoked to call callback on each value.

Parameters

cls	the plugin
key	unused
val	the value

Returns

GNUNET_OK (continue to iterate)

Definition at line 725 of file plugin_datastore_heap.c.

{
  struct GetAllContext *gac = cls;
 
  gac->proc (gac->proc_cls,
             key,
             1);
  return GNUNET_OK;
}

References GNUNET_OK, key, GetAllContext::proc, and GetAllContext::proc_cls.

Referenced by heap_get_keys().

Here is the caller graph for this function:

heap_get_keys()

static void heap_get_keys ( void *  cls, PluginKeyProcessor  proc, void *  proc_cls  )

static

Get all of the keys in the datastore.

Parameters

cls	closure
proc	function to call on each key
proc_cls	closure for proc

Definition at line 746 of file plugin_datastore_heap.c.

{
  struct Plugin *plugin = cls;
  struct GetAllContext gac;
 
  gac.proc = proc;
  gac.proc_cls = proc_cls;
  GNUNET_CONTAINER_multihashmap_iterate (plugin->keyvalue,
                                         &return_value,
                                         &gac);
  proc (proc_cls, NULL, 0);
}

References GNUNET_CONTAINER_multihashmap_iterate(), plugin, GetAllContext::proc, GetAllContext::proc_cls, and return_value().

Referenced by libgnunet_plugin_datastore_heap_init().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_iterator()

static int remove_iterator ( void *  cls, const struct GNUNET_HashCode *  key, void *  val  )

static

Obtain the matching value with the lowest uid >= next_uid.

Parameters

cls	the 'struct GetContext'
key	unused
val	the 'struct Value'

Returns

GNUNET_YES (continue iteration), GNUNET_NO if result was found

Definition at line 793 of file plugin_datastore_heap.c.

{
  struct RemoveContext *rc = cls;
  struct Value *value = val;
 
  if (value->size != rc->size)
    return GNUNET_YES;
  if (0 != memcmp (value->data, rc->data, rc->size))
    return GNUNET_YES;
  rc->value = value;
  return GNUNET_NO;
}

References RemoveContext::data, GNUNET_NO, GNUNET_YES, RemoveContext::size, RemoveContext::value, and value.

Referenced by heap_plugin_remove_key().

Here is the caller graph for this function:

heap_plugin_remove_key()

static void heap_plugin_remove_key ( void *  cls, const struct GNUNET_HashCode *  key, uint32_t  size, const void *  data, PluginRemoveCont  cont, void *  cont_cls  )

static

Remove a particular key in the datastore.

Parameters

cls	closure
key	key for the content
size	number of bytes in data
data	content stored
cont	continuation called with success or failure status
cont_cls	continuation closure for cont

Definition at line 820 of file plugin_datastore_heap.c.

{
  struct Plugin *plugin = cls;
  struct RemoveContext rc;
 
  rc.value = NULL;
  rc.size = size;
  rc.data = data;
  GNUNET_CONTAINER_multihashmap_get_multiple (plugin->keyvalue,
                                              key,
                                              &remove_iterator,
                                              &rc);
  if (NULL == rc.value)
  {
    cont (cont_cls,
          key,
          size,
          GNUNET_NO,
          NULL);
    return;
  }
  delete_value (plugin,
                rc.value);
  cont (cont_cls,
        key,
        size,
        GNUNET_OK,
        NULL);
}

References RemoveContext::data, data, delete_value(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_NO, GNUNET_OK, key, plugin, remove_iterator(), RemoveContext::size, size, and RemoveContext::value.

Referenced by libgnunet_plugin_datastore_heap_init().

Here is the call graph for this function:

Here is the caller graph for this function:

libgnunet_plugin_datastore_heap_init()

void* libgnunet_plugin_datastore_heap_init

(

void *

cls

)

Entry point for the plugin.

Parameters

cls	the "struct GNUNET_DATASTORE_PluginEnvironment*"

Returns

our "struct Plugin*"

Definition at line 863 of file plugin_datastore_heap.c.

{
  struct GNUNET_DATASTORE_PluginEnvironment *env = cls;
  struct GNUNET_DATASTORE_PluginFunctions *api;
  struct Plugin *plugin;
  unsigned long long esize;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (env->cfg,
                                             "datastore-heap",
                                             "HASHMAPSIZE",
                                             &esize))
    esize = 128 * 1024;
  plugin = GNUNET_new (struct Plugin);
  plugin->env = env;
  plugin->keyvalue = GNUNET_CONTAINER_multihashmap_create (esize, GNUNET_YES);
  plugin->by_expiration = GNUNET_CONTAINER_heap_create (
    GNUNET_CONTAINER_HEAP_ORDER_MIN);
  plugin->by_replication = GNUNET_CONTAINER_heap_create (
    GNUNET_CONTAINER_HEAP_ORDER_MAX);
  api = GNUNET_new (struct GNUNET_DATASTORE_PluginFunctions);
  api->cls = plugin;
  api->estimate_size = &heap_plugin_estimate_size;
  api->put = &heap_plugin_put;
  api->get_key = &heap_plugin_get_key;
  api->get_replication = &heap_plugin_get_replication;
  api->get_expiration = &heap_plugin_get_expiration;
  api->get_zero_anonymity = &heap_plugin_get_zero_anonymity;
  api->drop = &heap_plugin_drop;
  api->get_keys = &heap_get_keys;
  api->remove_key = &heap_plugin_remove_key;
  GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "heap",
                   _ ("Heap database running\n"));
  return api;
}

References _, Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_DATASTORE_PluginEnvironment::cls, env, GNUNET_BLOCK_PluginFunctions::get_key, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MAX, GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_INFO, GNUNET_log_from, GNUNET_new, GNUNET_OK, GNUNET_YES, heap_get_keys(), heap_plugin_drop(), heap_plugin_estimate_size(), heap_plugin_get_expiration(), heap_plugin_get_key(), heap_plugin_get_replication(), heap_plugin_get_zero_anonymity(), heap_plugin_put(), heap_plugin_remove_key(), and plugin.

Here is the call graph for this function:

free_value()

static int free_value ( void *  cls, const struct GNUNET_HashCode *  key, void *  val  )

static

Callback invoked to free all value.

Parameters

cls	the plugin
key	unused
val	the value

Returns

GNUNET_OK (continue to iterate)

Definition at line 909 of file plugin_datastore_heap.c.

{
  struct Plugin *plugin = cls;
  struct Value *value = val;
 
  delete_value (plugin, value);
  return GNUNET_OK;
}

References delete_value(), GNUNET_OK, plugin, and value.

Here is the call graph for this function:

libgnunet_plugin_datastore_heap_done()

void* libgnunet_plugin_datastore_heap_done

(

void *

cls

)

Exit point from the plugin.

Parameters

cls	our "struct Plugin*"

Returns

always NULL

Definition at line 927 of file plugin_datastore_heap.c.

{
  struct GNUNET_DATASTORE_PluginFunctions *api = cls;
  struct Plugin *plugin = api->cls;
 
  GNUNET_CONTAINER_multihashmap_iterate (plugin->keyvalue,
                                         &free_value,
                                         plugin);
  GNUNET_CONTAINER_multihashmap_destroy (plugin->keyvalue);
  GNUNET_CONTAINER_heap_destroy (plugin->by_expiration);
  GNUNET_CONTAINER_heap_destroy (plugin->by_replication);
  GNUNET_free (plugin);
  GNUNET_free (api);
  return NULL;
}