src/DelayTagged.cc

   1 /*
   2  * Copyright (C) 1996-2014 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 /* DEBUG: section 77    Delay Pools */
  10
  11 #include "squid.h"
  12
  13 #if USE_DELAY_POOLS
  14 #include "comm/Connection.h"
  15 #include "DelayTagged.h"
  16 #include "NullDelayId.h"
  17 #include "Store.h"
  18
  19 void *
  20 DelayTagged::operator new(size_t size)
  21 {
  22     DelayPools::MemoryUsed += sizeof (DelayTagged);
  23     return ::operator new (size);
  24 }
  25
  26 void
  27 DelayTagged::operator delete (void *address)
  28 {
  29     DelayPools::MemoryUsed -= sizeof (DelayTagged);
  30     ::operator delete (address);
  31 }
  32
  33 DelayTagged::DelayTagged()
  34 {
  35     DelayPools::registerForUpdates (this);
  36 }
  37
  38 static SplayNode<DelayTaggedBucket::Pointer>::SPLAYFREE DelayTaggedFree;
  39
  40 DelayTagged::~DelayTagged()
  41 {
  42     DelayPools::deregisterForUpdates (this);
  43     buckets.head->destroy (DelayTaggedFree);
  44 }
  45
  46 static SplayNode<DelayTaggedBucket::Pointer>::SPLAYCMP DelayTaggedCmp;
  47
  48 int
  49 DelayTaggedCmp(DelayTaggedBucket::Pointer const &left, DelayTaggedBucket::Pointer const &right)
  50 {
  51     /* for rate limiting, case insensitive */
  52     return left->tag.caseCmp(right->tag);
  53 }
  54
  55 void
  56 DelayTaggedFree(DelayTaggedBucket::Pointer &)
  57 {}
  58
  59 void
  60 DelayTaggedStatsWalkee(DelayTaggedBucket::Pointer const &current, void *state)
  61 {
  62     current->stats ((StoreEntry *)state);
  63 }
  64
  65 void
  66 DelayTagged::stats(StoreEntry * sentry)
  67 {
  68     spec.stats (sentry, "Per Tag");
  69
  70     if (spec.restore_bps == -1)
  71         return;
  72
  73     storeAppendPrintf(sentry, "\t\tCurrent: ");
  74
  75     if (!buckets.head) {
  76         storeAppendPrintf (sentry, "Not used yet.\n\n");
  77         return;
  78     }
  79
  80     buckets.head->walk(DelayTaggedStatsWalkee, sentry);
  81     storeAppendPrintf(sentry, "\n\n");
  82 }
  83
  84 void
  85 DelayTagged::dump(StoreEntry *entry) const
  86 {
  87     spec.dump(entry);
  88 }
  89
  90 struct DelayTaggedUpdater {
  91     DelayTaggedUpdater (DelaySpec &_spec, int _incr):spec(_spec),incr(_incr) {};
  92
  93     DelaySpec spec;
  94     int incr;
  95 };
  96
  97 void
  98 DelayTaggedUpdateWalkee(DelayTaggedBucket::Pointer const &current, void *state)
  99 {
 100     DelayTaggedUpdater *t = (DelayTaggedUpdater *)state;
 101     /* This doesn't change the value of the DelayTaggedBucket, so is safe */
 102     const_cast<DelayTaggedBucket *>(current.getRaw())->theBucket.update(t->spec, t->incr);
 103 }
 104
 105 void
 106 DelayTagged::update(int incr)
 107 {
 108     DelayTaggedUpdater updater(spec, incr);
 109     buckets.head->walk (DelayTaggedUpdateWalkee, &updater);
 110     kickReads();
 111 }
 112
 113 void
 114 DelayTagged::parse()
 115 {
 116     spec.parse();
 117 }
 118
 119 DelayIdComposite::Pointer
 120
 121 DelayTagged::id(CompositePoolNode::CompositeSelectionDetails &details)
 122 {
 123     if (!details.tag.size())
 124         return new NullDelayId;
 125
 126     return new Id(this, details.tag);
 127 }
 128
 129 void *
 130 DelayTagged::Id::operator new(size_t size)
 131 {
 132     DelayPools::MemoryUsed += sizeof (Id);
 133     return ::operator new (size);
 134 }
 135
 136 void
 137 DelayTagged::Id::operator delete (void *address)
 138 {
 139     DelayPools::MemoryUsed -= sizeof (Id);
 140     ::operator delete (address);
 141 }
 142
 143 void *
 144 DelayTaggedBucket::operator new(size_t size)
 145 {
 146     DelayPools::MemoryUsed += sizeof (DelayTaggedBucket);
 147     return ::operator new (size);
 148 }
 149
 150 void
 151 DelayTaggedBucket::operator delete (void *address)
 152 {
 153     DelayPools::MemoryUsed -= sizeof (DelayTaggedBucket);
 154     ::operator delete (address);
 155 }
 156
 157 DelayTaggedBucket::DelayTaggedBucket(String &aTag) : tag (aTag)
 158 {
 159     debugs(77, 3, "DelayTaggedBucket::DelayTaggedBucket");
 160 }
 161
 162 DelayTaggedBucket::~DelayTaggedBucket()
 163 {
 164     debugs(77, 3, "DelayTaggedBucket::~DelayTaggedBucket");
 165 }
 166
 167 void
 168 DelayTaggedBucket::stats(StoreEntry *entry) const
 169 {
 170     storeAppendPrintf(entry, " " SQUIDSTRINGPH ":", SQUIDSTRINGPRINT(tag));
 171     theBucket.stats(entry);
 172 }
 173
 174 DelayTagged::Id::Id(DelayTagged::Pointer aDelayTagged, String &aTag) : theTagged(aDelayTagged)
 175 {
 176     theBucket = new DelayTaggedBucket(aTag);
 177     DelayTaggedBucket::Pointer const *existing = theTagged->buckets.find(theBucket, DelayTaggedCmp);
 178
 179     if (existing) {
 180         theBucket = *existing;
 181         return;
 182     }
 183
 184     theBucket->theBucket.init(theTagged->spec);
 185     theTagged->buckets.head = theTagged->buckets.head->insert (theBucket, DelayTaggedCmp);
 186 }
 187
 188 DelayTagged::Id::~Id()
 189 {
 190     debugs(77, 3, "DelayTagged::Id::~Id");
 191 }
 192
 193 int
 194 DelayTagged::Id::bytesWanted (int min, int max) const
 195 {
 196     return theBucket->theBucket.bytesWanted(min,max);
 197 }
 198
 199 void
 200 DelayTagged::Id::bytesIn(int qty)
 201 {
 202     theBucket->theBucket.bytesIn(qty);
 203 }
 204
 205 void
 206 DelayTagged::Id::delayRead(DeferredRead const &aRead)
 207 {
 208     theTagged->delayRead(aRead);
 209 }
 210
 211 #endif
 212