nucleus/library/structures/memory_limiter.cpp

   1 /*****************************************************************************\
   2 *                                                                             *
   3 *  Name   : memory_limiter                                                    *
   4 *  Author : Chris Koeritz                                                     *
   5 *                                                                             *
   6 *******************************************************************************
   7 * Copyright (c) 2001-$now By Author.  This program is free software; you can  *
   8 * redistribute it and/or modify it under the terms of the GNU General Public  *
   9 * License as published by the Free Software Foundation; either version 2 of   *
  10 * the License or (at your option) any later version.  This is online at:      *
  11 *     http://www.fsf.org/copyleft/gpl.html                                    *
  12 * Please send any updates to: fred@gruntose.com                               *
  13 \*****************************************************************************/
  14
  15 #include "int_hash.h"
  16 #include "memory_limiter.h"
  17
  18 #include <basis/functions.h>
  19
  20 #include <stdio.h>
  21
  22 using namespace basis;
  23
  24 namespace structures {
  25
  26 #undef LOG
  27 #define LOG(to_print) printf("%s\n", astring(to_print).s())
  28
  29 class ml_memory_record
  30 {
  31 public:
  32   int _usage;
  33
  34   ml_memory_record(int initial) : _usage(initial) {}
  35 };
  36
  37 //////////////
  38
  39 class ml_memory_state_meter : public int_hash<ml_memory_record>
  40 {
  41 public:
  42   ml_memory_state_meter() : int_hash<ml_memory_record>(10) {}
  43 };
  44
  45 //////////////
  46
  47 memory_limiter::memory_limiter(int overall_limit, int individual_limit)
  48 : _overall_limit(overall_limit),
  49   _individual_limit(individual_limit),
  50   _overall_size(0),
  51   _individual_sizes(new ml_memory_state_meter)
  52 {
  53 }
  54
  55 memory_limiter::~memory_limiter()
  56 {
  57   WHACK(_individual_sizes);
  58 }
  59
  60 void memory_limiter::reset()
  61 {
  62   _overall_size = 0;
  63   _individual_sizes->reset();
  64 }
  65
  66 const int_set &memory_limiter::individuals_listed() const
  67 { return _individual_sizes->ids(); }
  68
  69 ml_memory_record *memory_limiter::find_individual(int individual) const
  70 {
  71   ml_memory_record *to_return = NULL_POINTER;
  72   if (!_individual_sizes->find(individual, to_return)) return NULL_POINTER;
  73     // no record for that guy.
  74   return to_return;
  75 }
  76
  77 int memory_limiter::individual_usage(int individual) const
  78 {
  79   ml_memory_record *found = find_individual(individual);
  80   if (!found) return 0;
  81   return found->_usage;
  82 }
  83
  84 int memory_limiter::individual_space_left(int individual) const
  85 {
  86   if (!individual_limit()) return 0;
  87   return individual_limit() - individual_usage(individual);
  88 }
  89
  90 astring memory_limiter::text_form(int indent) const
  91 {
  92   astring to_return;
  93   astring indentat(' ', indent);
  94
  95   astring allowed = overall_limit()?
  96       astring(astring::SPRINTF, "%dK", overall_limit() / KILOBYTE)
  97       : "unlimited";
  98   astring avail = overall_limit()?
  99       astring(astring::SPRINTF, "%dK", overall_space_left() / KILOBYTE)
 100       : "unlimited";
 101
 102   to_return += astring(astring::SPRINTF, "Overall Limit=%s, Allocations=%dK, "
 103       "Free Space=%s", allowed.s(), overall_usage() / KILOBYTE, avail.s());
 104   to_return += "\n";
 105
 106   int_set individuals = _individual_sizes->ids();
 107   for (int i = 0; i < individuals.elements(); i++) {
 108     astring allowed = individual_limit()?
 109         astring(astring::SPRINTF, "%dK", individual_limit() / KILOBYTE)
 110         : "unlimited";
 111     astring avail = individual_limit()?
 112         astring(astring::SPRINTF, "%dK",
 113         individual_space_left(individuals[i]) / KILOBYTE) : "unlimited";
 114
 115     to_return += indentat + astring(astring::SPRINTF, "individual %d: "
 116         "Limit=%s, Used=%dK, Free=%s", individuals[i], allowed.s(),
 117         individual_usage(individuals[i]) / KILOBYTE, avail.s());
 118     to_return += "\n";
 119   }
 120   if (!individuals.elements()) {
 121     to_return += indentat + "No allocations owned currently.";
 122     to_return += "\n";
 123   }
 124   return to_return;
 125 }
 126
 127 bool memory_limiter::okay_allocation(int individual, int memory_desired)
 128 {
 129   FUNCDEF("okay_allocation");
 130   // check the overall allocation limits first.
 131   if (_overall_limit
 132       && (_overall_size + memory_desired > _overall_limit) ) return false;
 133   // now check sanity of this request.
 134   if (_individual_limit && (memory_desired > _individual_limit) ) return false;
 135   // now check the allocations per user.
 136   ml_memory_record *found = find_individual(individual);
 137   if (!found) {
 138     _individual_sizes->add(individual, new ml_memory_record(0));
 139     found = find_individual(individual);
 140     if (!found) {
 141       LOG("ERROR: adding a new record to the memory state!");
 142       return false;
 143     }
 144   }
 145   if (_individual_limit
 146       && (found->_usage + memory_desired > _individual_limit) )
 147     return false;
 148   found->_usage += memory_desired;
 149   _overall_size += memory_desired;
 150   return true;
 151 }
 152
 153 bool memory_limiter::record_deletion(int individual, int memory_deleted)
 154 {
 155   if (memory_deleted < 0) return false;  // bogus.
 156   // make sure the individual exists.
 157   ml_memory_record *found = find_individual(individual);
 158   if (!found) return false;
 159   // the individual must have actually allocated at least that much previously.
 160   if (found->_usage < memory_deleted) return false;
 161   // okay, we think that's reasonable.
 162   found->_usage -= memory_deleted;
 163   _overall_size -= memory_deleted;
 164   // clean out an empty locker.
 165   if (!found->_usage) _individual_sizes->zap(individual);
 166   return true;
 167 }
 168
 169 } //namespace.
 170
 171