life_maintainer.cpp

Go to the documentation of this file.

#ifndef LIFE_MAINTAINER_IMPLEMENTATION_FILE
#define LIFE_MAINTAINER_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : life_maintainer                                                   *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1996-$now By Author.  This program 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 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "living_item.h"
#include "life_maintainer.h"

#include <basis/auto_synch.h>
#include <basis/mutex.h>
#include <data_struct/byte_hasher.h>
#include <data_struct/int_hash.cpp>
#include <data_struct/unique_id.h>
#include <mechanisms/heartbeat.h>

using namespace nodes;

const int MAX_LFMT_BITS = 10;
  // the maximum bits used for hash values.

#undef AUTO_LOCK
#define AUTO_LOCK auto_synchronizer l(*_lock)

#undef LOG
#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger(), s)


class living_item_table : public int_hash<living_item>
{
public:
  living_item_table() : int_hash<living_item>(MAX_LFMT_BITS) {}
};


life_maintainer::life_maintainer()
: _items(new living_item_table),
  _lock(new mutex)
{}

life_maintainer::~life_maintainer()
{
  WHACK(_items);
  WHACK(_lock);
}

int_set life_maintainer::valid_ids() const
{
  AUTO_LOCK;
  return _items->ids();
}

bool life_maintainer::add(living_item *to_add)
{
  AUTO_LOCK;
  _items->add(to_add->id().raw_id(), to_add);
  return true;
}

bool life_maintainer::zap(const unique_int &uid)
{
  living_item *item = acquire(uid);
  if (!item) return false;
  item->lock();
    // we want to ensure that we get this node's attention.  since it's not in
    // the list any longer, nobody should be able to touch it except for those
    // who are already waiting on it.  once we've been given the lock, we've
    // ensured no one else is waiting for it anymore.
  item->unlock();
    // release the lock again; nobody else should be able to mess with it
    // any longer.
  item->shut_down_safely();  // this guy is toast; remove its parts.
  WHACK(item);
  return true;
}

heartbeat life_maintainer::get_liveness(const unique_int &uid)
{
  heartbeat to_return;
  living_item *item = locking_find(uid);
  if (!item) return to_return;
  to_return = item->liveness();
  unlock_find(item);
  return to_return;
}

bool life_maintainer::set_liveness(const unique_int &uid,
    const heartbeat &new_beat)
{
  living_item *item = locking_find(uid);
  if (!item) return false;
  item->liveness(new_beat);
  unlock_find(item);
  return true;
}

bool life_maintainer::kabump(const unique_int &id)
{
  living_item *item = locking_find(id);
  if (!item) return false;
  item->liveness().kabump();
  unlock_find(item);
  return true;
}

bool life_maintainer::made_request(const unique_int &id)
{
  living_item *item = locking_find(id);
  if (!item) return false;
  item->liveness().made_request();
  unlock_find(item);
  return true;
}

void life_maintainer::apply(apply_function *to_apply, void *datalink)
{
  FUNCDEF("apply");
  int_set ids;
  {
    AUTO_LOCK;
    _items->ids(ids);
  }
  // this algorithm goes through the list without keeping it locked.
  for (int i = 0; i < ids.length(); i++) {
    living_item *iti = locking_find(ids[i]);
    if (!iti) continue;  // got nothing.
    to_apply(*iti, datalink);
    unlock_find(iti);
  }
}

living_item *life_maintainer::locking_find(const unique_int &uid)
{
  _lock->lock();
  living_item *to_return = _items->find(uid.raw_id());
  if (!to_return) {
    _lock->unlock();
    return NIL;
  }
  // we transition now to downgrading our lock, but we must first acquire the
  // lock on the item.  we will wait until it's released it, which is hopefully
  // not going to take long.
  to_return->lock();
  _lock->unlock();
  return to_return;
}

void life_maintainer::unlock_find(living_item *to_close)
{
  if (!to_close) return;
  to_close->unlock();
}

living_item *life_maintainer::acquire(const unique_int &uid)
{
  AUTO_LOCK;
  return _items->acquire(uid.raw_id());
}


#endif //LIFE_MAINTAINER_IMPLEMENTATION_FILE

---