buffer_manager.cpp

Go to the documentation of this file.

#ifndef BUFFER_MANAGER_IMPLEMENTATION_FILE
#define BUFFER_MANAGER_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : buffer_manager                                                    *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1992-$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 "buffer_key.h"
#include "buffer_manager.h"
#include "implem_only.h"

#include <basis/log_base.h>
#include <basis/mutex.h>
#include <data_struct/amorph.cpp>
#include <data_struct/memory_limiter.h>
#include <mechanisms/time_stamp.h>
#include <textual/string_manipulation.h>

#define LOCKIT auto_synchronizer l(*_buffer_lock);
  // used to synchronize access to the buffer manager's lists.

#define LOG(to_print) CLASS_EMERGENCY_LOG(program_wide_logger(), to_print);


class internal_buffer_list : public amorph<buffer_base> {};


buffer_manager::buffer_manager(int total_memory, int connection_memory)
: _buffer_lock(new mutex),
  _buffer_list(new internal_buffer_list()),
  _space_minder(new memory_limiter(total_memory, connection_memory))
{}

buffer_manager::~buffer_manager()
{
  WHACK(_buffer_list);
  WHACK(_buffer_lock);
  WHACK(_space_minder);
}

int buffer_manager::buffers() const
{
  LOCKIT;
  return _buffer_list->elements();
}

int buffer_manager::total_memory_allowed() const
{
  LOCKIT;
  return _space_minder->overall_limit();
}

int buffer_manager::total_allocated() const
{
  LOCKIT;
  return _space_minder->overall_usage();
}

bool buffer_manager::okay_addition(buffer_base &to_check)
{
  FUNCDEF("okay_addition");
  LOCKIT;
  int new_size = 0;
  if (to_check.whole() && !to_check.did_estimate())
    new_size = to_check.full_length();
  else new_size = to_check.guess_size();
  if (negative(new_size)) return false;

  if (!_space_minder->okay_allocation(to_check.key().connection, new_size)) {
    // this was too big to be allowed currently.

    find_space();
      // try to clean up some estimates that we now know real sizes for.
    if (!_space_minder->okay_allocation(to_check.key().connection, new_size)) {
      // even after cleaning, there just wasn't any space available.
      return false;
    }
  }
  return true;
}

void buffer_manager::find_space()
{
  FUNCDEF("find_space");
  LOCKIT;
  // we scoot through the buffer list looking for buffers that were only
  // estimated originally; if it's whole now, we can recalculate the space
  // that's actually in use.
  for (int i = 0; i < _buffer_list->elements(); i++) {
    buffer_base *to_check = _buffer_list->borrow(i);
    if (to_check->did_estimate() && to_check->whole()) {
      // the buffer is whole now, but we did an estimate before.  make sure
      // we patch the totals to reflect what we know now.
      int space_to_remove = to_check->guess_size() - to_check->full_length();
      if (space_to_remove < 0) {
        // that's a bad fup; they guessed less than they needed.
        LOG(istring(istring::SPRINTF, "estimated size was less than "
            "required amount!  for conn id %d, buff id %d, estimate=%d, "
            "real_size=%d.", to_check->key().connection,
            to_check->key().buff_id.raw_id(),
            to_check->guess_size(), to_check->full_length()));
        continue;  // we can't patch the estimate righteously, so skip it.
      }
      to_check->reset_estimate();
      if (!_space_minder->record_deletion(to_check->key().connection,
          space_to_remove)) {
        LOG(istring(istring::SPRINTF, "failed to properly update "
            "buffer record for conn id %d, buff id %d.",
            to_check->key().connection, to_check->key().buff_id.raw_id()));
      }
    }
  }
}

void buffer_manager::record_subtraction(buffer_base &to_check)
{
  FUNCDEF("record_subtraction");
  LOCKIT;
  int old_size = 0;
  if (to_check.did_estimate() || !to_check.whole())
    old_size = to_check.guess_size();
  else old_size = to_check.full_length();
  if (negative(old_size)) return;
  if (!_space_minder->record_deletion(to_check.key().connection, old_size)) {
    LOG(istring(istring::SPRINTF, "failed to properly update "
        "buffer record for conn id %d, buff id %d.",
        to_check.key().connection, to_check.key().buff_id.raw_id()));
  }
}

int buffer_manager::locked_find(int &start, const buffer_key &key)
{
  FUNCDEF("locked_find");
  bounds_return(start, 0, _buffer_list->elements() - 1, buffer_base::BAD_INPUT);
  // scan through from the "start" onwards, looking for the buffer.
  for (int i = start; i < _buffer_list->elements(); i++) {
    // if the buffer ids match, then the buffers are the same.  for a wildcard
    // buffer id, the connection is still checked and must match and the
    // message id must be the same or a wildcard.
    if ( (key.buff_id == _buffer_list->get(i)->key().buff_id)
        || (!key.buff_id  // must be zero for other compares.
          && (_buffer_list->get(i)->key().connection == key.connection)
          && (!key.msg_id
             || (_buffer_list->get(i)->key().msg_id == key.msg_id)))) {
      start = i + 1;
      return i;
    }
  }
  return common::NOT_FOUND;
}

outcome buffer_manager::add_buffer(buffer_base *to_add)
{
  FUNCDEF("add_buffer");
  if (!to_add) return buffer_base::BAD_INPUT;
  LOCKIT;
  buffer_key key = to_add->key();
  if (!key.connection) {
    // one cannot use a connection id of zero.
    LOG("buffer was passed in with a connection identifier of zero!");
    WHACK(to_add);
    return buffer_base::BAD_INPUT;
  }
  if (!key.buff_id) {
    LOG("buffer was passed in with a buffer identifier of zero!");
    WHACK(to_add);
    return buffer_base::BAD_INPUT;
  }

  // make sure we're not having deja vu.
  int start = 0;
  if (locked_locate(start, key)) {
    LOG(istring(istring::SPRINTF, "the buffer %d already exists!!!",
        key.buff_id.raw_id()));
    WHACK(to_add);
    return buffer_base::IN_USE;
  }

  // now ensure that the buffer is allowed into our storage, given the current
  // usage of memory.
  if (!okay_addition(*to_add)) {
    // this one was wafer thin, but still too much to store.
    WHACK(to_add);
    return buffer_base::NO_SPACE;
  }

  // actually add the buffer to our list now.
  _buffer_list->append(to_add);
  return buffer_base::OKAY;
}

buffer_base *buffer_manager::lock_buffer(int &start, const buffer_key &key)
{
  _buffer_lock->lock();
  buffer_base *to_return = locked_locate(start, key);
  if (!to_return) {
    _buffer_lock->unlock();
    return NIL;
  }
  // note that we're hanging onto the lock.
  return to_return;
}

void buffer_manager::unlock_buffer(buffer_base *to_unlock)
{
  if (!to_unlock) return;
  // we ignore the parameter and hope they're doing this properly.
  to_unlock = NIL;
  _buffer_lock->unlock();
}

buffer_base *buffer_manager::locked_locate(int &start, const buffer_key &key)
{
  FUNCDEF("locked_locate");
  int index = locked_find(start, key);
  if (negative(index)) return NIL;
  return _buffer_list->borrow(index);
}

bool buffer_manager::zap(buffer_id to_whack)
{
  FUNCDEF("zap");
  LOCKIT;
  int start = 0;
  buffer_key key(to_whack, 0, 0);
  int index = locked_find(start, key);
  if (negative(index)) return false;
  // update our faked key with the real one.
  key = _buffer_list->get(index)->key();
  // now grab out the buffer that's leaving us.
  buffer_base *found = _buffer_list->acquire(index);
  // zap the space it used to occupy.
  _buffer_list->zap(index, index);
  // remove the listing of allocation.
  record_subtraction(*found);
  WHACK(found);
  return true;
}

bool buffer_manager::zap_match(int &start, const buffer_key &key)
{
  FUNCDEF("zap_match");
  LOCKIT;
  int index = locked_find(start, key);
  if (negative(index)) return false;
  // now grab out the buffer that's leaving us.
  buffer_base *found = _buffer_list->acquire(index);
  // zap the space it used to occupy.
  _buffer_list->zap(index, index);
  // remove the listing of allocation.
  record_subtraction(*found);
  WHACK(found);
  return true;
}

bool buffer_manager::zap_all_matches(const buffer_key &key)
{
  FUNCDEF("zap_all_matches");
  LOCKIT;
  int start = 0;
  int index = locked_find(start, key);
  if (negative(index)) return false;
  while (non_negative(index)) {
    // grab the buffer that's getting chucked.
    buffer_base *found = _buffer_list->acquire(index);
    // zap the space it used to occupy.
    _buffer_list->zap(index, index);
    // remove the listing of allocation.
    record_subtraction(*found);
    WHACK(found);
    start = 0;
    index = locked_find(start, key);
  }
  return true;
}

void buffer_manager::zap_all()
{
  FUNCDEF("zap_all");
  LOCKIT;
  _buffer_list->zap(0, _buffer_list->elements() - 1);
  _space_minder->reset();
}

bool buffer_manager::zap_expired(istring &text_form, buffer_key &dead_key,
    int &start, int age, kind_to_find which)
{
  FUNCDEF("zap_expired");
  LOCKIT;
  if (start > _buffer_list->elements() - 1) return false;
  time_stamp comparator(-age);  // time past is a negative offset.
  for (int i = start; i < _buffer_list->elements(); i++) {
    if (!_buffer_list->get(i)->alive()) {
      // this buffer is history already.
      record_subtraction(*_buffer_list->borrow(i));
      _buffer_list->zap(i, i);
      i--;  // skip loop backwards.
    } else if ( (_buffer_list->get(i)->last_add() <= comparator)
          && ( (which == EITHER)
              || (_buffer_list->get(i)->whole() && (which == WHOLE))
              || (!_buffer_list->get(i)->whole() && (which == NON_WHOLE)) ) ) {
      start = i + 1;
      text_form = _buffer_list->get(i)->text_form();
      dead_key = _buffer_list->get(i)->key();
      record_subtraction(*_buffer_list->borrow(i));
      _buffer_list->zap(i, i);
      return true;
    }
  }
  return false;
}

void buffer_manager::show_buffers(istring &dump, int indenting)
{
  istring indent = string_manipulation::indentation(indenting);
  LOCKIT;
  if (!_buffer_list->elements()) {
    dump += indent + "No buffers are presently held."
        + log_base::platform_ending() + log_base::platform_ending();
    return;
  }
  for (int j = 0; j < _buffer_list->elements(); j++) {
    dump += indent + _buffer_list->get(j)->detailed_form();
    dump += log_base::platform_ending();
  }
  dump += log_base::platform_ending();
  dump += istring("Memory Usage: ") + _space_minder->text_form(indenting);
  dump += log_base::platform_ending();
  dump += log_base::platform_ending();
}

buffer_base *buffer_manager::disengage(buffer_key &key)
{
  FUNCDEF("disengage");
  LOCKIT;
  int start = 0;
  int index = locked_find(start, key);
  if (negative(index)) return NIL;
  buffer_base *to_return = _buffer_list->acquire(index);
  _buffer_list->zap(index, index);
  record_subtraction(*to_return);
  return to_return;
}

outcome buffer_manager::extract(buffer_key &key, byte_array &to_fill,
    byte_array &attachment, int offset, bool remove_buffer)
{
  FUNCDEF("extract");
  LOCKIT;
  int check_position = 0;
  while (check_position < buffers()) {
    buffer_base *buff = locked_locate(check_position, key);
    if (!buff) return buffer_base::INCOMPLETE;
    if (buff->whole()) {
      outcome ret = buff->dump(to_fill, offset);
      key = buff->key();
      // store the attachment if we had a success.
      if (ret == buffer_base::OKAY) {
        buff->get_attachment(attachment);
      }
      // zapping the position plus one because the locater automatically
      // increments the position to the next place.
      if ( (ret == buffer_base::OKAY) && remove_buffer) {
        buffer_key key_to_whack = _buffer_list->get(check_position - 1)->key();
        if (!zap(key_to_whack.buff_id)) {
          LOG(istring(istring::SPRINTF, "could not whack buffer %d.",
              key_to_whack.buff_id.raw_id()));
        }
      }
      return ret;
    }
  }
  return buffer_base::INCOMPLETE;
}


#endif //BUFFER_MANAGER_IMPLEMENTATION_FILE

---