src/DelayVector.cc

   1
   2 /*
   3  * DEBUG: section 77    Delay Pools
   4  * AUTHOR: Robert Collins <robertc@squid-cache.org>
   5  * Based upon original delay pools code by
   6  *   David Luyer <david@luyer.net>
   7  *
   8  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   9  * ----------------------------------------------------------
  10  *
  11  *  Squid is the result of efforts by numerous individuals from
  12  *  the Internet community; see the CONTRIBUTORS file for full
  13  *  details.   Many organizations have provided support for Squid's
  14  *  development; see the SPONSORS file for full details.  Squid is
  15  *  Copyrighted (C) 2001 by the Regents of the University of
  16  *  California; see the COPYRIGHT file for full details.  Squid
  17  *  incorporates software developed and/or copyrighted by other
  18  *  sources; see the CREDITS file for full details.
  19  *
  20  *  This program is free software; you can redistribute it and/or modify
  21  *  it under the terms of the GNU General Public License as published by
  22  *  the Free Software Foundation; either version 2 of the License, or
  23  *  (at your option) any later version.
  24  *
  25  *  This program is distributed in the hope that it will be useful,
  26  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28  *  GNU General Public License for more details.
  29  *
  30  *  You should have received a copy of the GNU General Public License
  31  *  along with this program; if not, write to the Free Software
  32  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33  *
  34  *
  35  * Copyright (c) 2003, Robert Collins <robertc@squid-cache.org>
  36  */
  37
  38 #include "squid.h"
  39
  40 #if USE_DELAY_POOLS
  41 #include "comm/Connection.h"
  42 #include "CommRead.h"
  43 #include "DelayVector.h"
  44
  45 void *
  46 DelayVector::operator new(size_t size)
  47 {
  48     DelayPools::MemoryUsed += sizeof (DelayVector);
  49     return ::operator new (size);
  50 }
  51
  52 void
  53 DelayVector::operator delete (void *address)
  54 {
  55     DelayPools::MemoryUsed -= sizeof (DelayVector);
  56     ::operator delete (address);
  57 }
  58
  59 DelayVector::DelayVector()
  60 {
  61     DelayPools::registerForUpdates (this);
  62 }
  63
  64 DelayVector::~DelayVector()
  65 {
  66     DelayPools::deregisterForUpdates (this);
  67 }
  68
  69 void
  70 DelayVector::stats(StoreEntry * sentry)
  71 {
  72     iterator pos = pools.begin();
  73
  74     while (pos != pools.end()) {
  75         (*pos)->stats(sentry);
  76         ++pos;
  77     }
  78 }
  79
  80 void
  81 DelayVector::dump(StoreEntry *entry) const
  82 {
  83     const_iterator pos = pools.begin();
  84
  85     while (pos != pools.end()) {
  86         (*pos)->dump(entry);
  87         ++pos;
  88     }
  89 }
  90
  91 void
  92 DelayVector::update(int incr)
  93 {
  94     /*
  95      * Each pool updates itself,
  96      * but we may have deferred reads waiting on the pool as a whole.
  97      */
  98
  99     kickReads();
 100 }
 101
 102 void
 103 DelayVector::parse()
 104 {
 105     iterator pos = pools.begin();
 106
 107     while (pos != pools.end()) {
 108         (*pos)->parse();
 109         ++pos;
 110     }
 111 }
 112
 113 DelayIdComposite::Pointer
 114 DelayVector::id(CompositeSelectionDetails &details)
 115 {
 116     return new Id(this, details);
 117 }
 118
 119 void
 120 DelayVector::push_back(CompositePoolNode::Pointer aNode)
 121 {
 122     pools.push_back(aNode);
 123 }
 124
 125 void *
 126 DelayVector::Id::operator new(size_t size)
 127 {
 128     DelayPools::MemoryUsed += sizeof (Id);
 129     return ::operator new (size);
 130 }
 131
 132 void
 133 DelayVector::Id::operator delete (void *address)
 134 {
 135     DelayPools::MemoryUsed -= sizeof (Id);
 136     ::operator delete (address);
 137 }
 138
 139 DelayVector::Id::Id(DelayVector::Pointer aDelayVector, CompositeSelectionDetails &details) : theVector(aDelayVector)
 140 {
 141     debugs(77, 3, "DelayVector::Id::Id");
 142     DelayVector::iterator pos = theVector->pools.begin();
 143
 144     while (pos != theVector->pools.end()) {
 145         ids.push_back ((*pos)->id (details));
 146         ++pos;
 147     }
 148 }
 149
 150 DelayVector::Id::~Id()
 151 {
 152     debugs(77, 3, "DelayVector::Id::~Id");
 153 }
 154
 155 int
 156 DelayVector::Id::bytesWanted (int minimum, int maximum) const
 157 {
 158     int nbytes = maximum;
 159     const_iterator pos = ids.begin();
 160
 161     while (pos != ids.end()) {
 162         nbytes = min (nbytes, (*pos)->bytesWanted(minimum, nbytes));
 163         ++pos;
 164     }
 165
 166     nbytes = max(minimum, nbytes);
 167     return nbytes;
 168 }
 169
 170 void
 171 DelayVector::Id::bytesIn(int qty)
 172 {
 173     iterator pos = ids.begin();
 174
 175     while (pos != ids.end()) {
 176         (*pos)->bytesIn(qty);
 177         ++pos;
 178     }
 179
 180     theVector->kickReads();
 181 }
 182
 183 void
 184 DelayVector::Id::delayRead(DeferredRead const &aRead)
 185 {
 186     theVector->delayRead(aRead);
 187 }
 188
 189 #endif