| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/disk_cache/blockfile/stats.h" | |
| 6 | |
| 7 #include "base/format_macros.h" | |
| 8 #include "base/logging.h" | |
| 9 #include "base/metrics/bucket_ranges.h" | |
| 10 #include "base/metrics/histogram.h" | |
| 11 #include "base/metrics/histogram_samples.h" | |
| 12 #include "base/metrics/sample_vector.h" | |
| 13 #include "base/metrics/statistics_recorder.h" | |
| 14 #include "base/strings/string_util.h" | |
| 15 #include "base/strings/stringprintf.h" | |
| 16 | |
| 17 namespace { | |
| 18 | |
| 19 const int32 kDiskSignature = 0xF01427E0; | |
| 20 | |
| 21 struct OnDiskStats { | |
| 22 int32 signature; | |
| 23 int size; | |
| 24 int data_sizes[disk_cache::Stats::kDataSizesLength]; | |
| 25 int64 counters[disk_cache::Stats::MAX_COUNTER]; | |
| 26 }; | |
| 27 static_assert(sizeof(OnDiskStats) < 512, "needs more than 2 blocks"); | |
| 28 | |
| 29 // Returns the "floor" (as opposed to "ceiling") of log base 2 of number. | |
| 30 int LogBase2(int32 number) { | |
| 31 unsigned int value = static_cast<unsigned int>(number); | |
| 32 const unsigned int mask[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000}; | |
| 33 const unsigned int s[] = {1, 2, 4, 8, 16}; | |
| 34 | |
| 35 unsigned int result = 0; | |
| 36 for (int i = 4; i >= 0; i--) { | |
| 37 if (value & mask[i]) { | |
| 38 value >>= s[i]; | |
| 39 result |= s[i]; | |
| 40 } | |
| 41 } | |
| 42 return static_cast<int>(result); | |
| 43 } | |
| 44 | |
| 45 // WARNING: Add new stats only at the end, or change LoadStats(). | |
| 46 const char* const kCounterNames[] = { | |
| 47 "Open miss", | |
| 48 "Open hit", | |
| 49 "Create miss", | |
| 50 "Create hit", | |
| 51 "Resurrect hit", | |
| 52 "Create error", | |
| 53 "Trim entry", | |
| 54 "Doom entry", | |
| 55 "Doom cache", | |
| 56 "Invalid entry", | |
| 57 "Open entries", | |
| 58 "Max entries", | |
| 59 "Timer", | |
| 60 "Read data", | |
| 61 "Write data", | |
| 62 "Open rankings", | |
| 63 "Get rankings", | |
| 64 "Fatal error", | |
| 65 "Last report", | |
| 66 "Last report timer", | |
| 67 "Doom recent entries", | |
| 68 "unused" | |
| 69 }; | |
| 70 static_assert(arraysize(kCounterNames) == disk_cache::Stats::MAX_COUNTER, | |
| 71 "update the names"); | |
| 72 | |
| 73 } // namespace | |
| 74 | |
| 75 namespace disk_cache { | |
| 76 | |
| 77 bool VerifyStats(OnDiskStats* stats) { | |
| 78 if (stats->signature != kDiskSignature) | |
| 79 return false; | |
| 80 | |
| 81 // We don't want to discard the whole cache every time we have one extra | |
| 82 // counter; we keep old data if we can. | |
| 83 if (static_cast<unsigned int>(stats->size) > sizeof(*stats)) { | |
| 84 memset(stats, 0, sizeof(*stats)); | |
| 85 stats->signature = kDiskSignature; | |
| 86 } else if (static_cast<unsigned int>(stats->size) != sizeof(*stats)) { | |
| 87 size_t delta = sizeof(*stats) - static_cast<unsigned int>(stats->size); | |
| 88 memset(reinterpret_cast<char*>(stats) + stats->size, 0, delta); | |
| 89 stats->size = sizeof(*stats); | |
| 90 } | |
| 91 | |
| 92 return true; | |
| 93 } | |
| 94 | |
| 95 Stats::Stats() { | |
| 96 } | |
| 97 | |
| 98 Stats::~Stats() { | |
| 99 } | |
| 100 | |
| 101 bool Stats::Init(void* data, int num_bytes, Addr address) { | |
| 102 OnDiskStats local_stats; | |
| 103 OnDiskStats* stats = &local_stats; | |
| 104 if (!num_bytes) { | |
| 105 memset(stats, 0, sizeof(local_stats)); | |
| 106 local_stats.signature = kDiskSignature; | |
| 107 local_stats.size = sizeof(local_stats); | |
| 108 } else if (num_bytes >= static_cast<int>(sizeof(*stats))) { | |
| 109 stats = reinterpret_cast<OnDiskStats*>(data); | |
| 110 if (!VerifyStats(stats)) | |
| 111 return false; | |
| 112 } else { | |
| 113 return false; | |
| 114 } | |
| 115 | |
| 116 storage_addr_ = address; | |
| 117 | |
| 118 memcpy(data_sizes_, stats->data_sizes, sizeof(data_sizes_)); | |
| 119 memcpy(counters_, stats->counters, sizeof(counters_)); | |
| 120 | |
| 121 // Clean up old value. | |
| 122 SetCounter(UNUSED, 0); | |
| 123 return true; | |
| 124 } | |
| 125 | |
| 126 void Stats::InitSizeHistogram() { | |
| 127 // Only generate this histogram for the main cache. | |
| 128 static bool first_time = true; | |
| 129 if (!first_time) | |
| 130 return; | |
| 131 | |
| 132 first_time = false; | |
| 133 int min = 1; | |
| 134 int max = 64 * 1024; | |
| 135 int num_buckets = 75; | |
| 136 base::BucketRanges ranges(num_buckets + 1); | |
| 137 base::Histogram::InitializeBucketRanges(min, max, &ranges); | |
| 138 | |
| 139 base::HistogramBase* stats_histogram = base::Histogram::FactoryGet( | |
| 140 "DiskCache.SizeStats2", min, max, num_buckets, | |
| 141 base::HistogramBase::kUmaTargetedHistogramFlag); | |
| 142 | |
| 143 base::SampleVector samples(&ranges); | |
| 144 for (int i = 0; i < kDataSizesLength; i++) { | |
| 145 // This is a good time to fix any inconsistent data. The count should be | |
| 146 // always positive, but if it's not, reset the value now. | |
| 147 if (data_sizes_[i] < 0) | |
| 148 data_sizes_[i] = 0; | |
| 149 | |
| 150 samples.Accumulate(GetBucketRange(i) / 1024, data_sizes_[i]); | |
| 151 } | |
| 152 stats_histogram->AddSamples(samples); | |
| 153 } | |
| 154 | |
| 155 int Stats::StorageSize() { | |
| 156 // If we have more than 512 bytes of counters, change kDiskSignature so we | |
| 157 // don't overwrite something else (LoadStats must fail). | |
| 158 static_assert(sizeof(OnDiskStats) <= 256 * 2, "use more blocks"); | |
| 159 return 256 * 2; | |
| 160 } | |
| 161 | |
| 162 void Stats::ModifyStorageStats(int32 old_size, int32 new_size) { | |
| 163 // We keep a counter of the data block size on an array where each entry is | |
| 164 // the adjusted log base 2 of the size. The first entry counts blocks of 256 | |
| 165 // bytes, the second blocks up to 512 bytes, etc. With 20 entries, the last | |
| 166 // one stores entries of more than 64 MB | |
| 167 int new_index = GetStatsBucket(new_size); | |
| 168 int old_index = GetStatsBucket(old_size); | |
| 169 | |
| 170 if (new_size) | |
| 171 data_sizes_[new_index]++; | |
| 172 | |
| 173 if (old_size) | |
| 174 data_sizes_[old_index]--; | |
| 175 } | |
| 176 | |
| 177 void Stats::OnEvent(Counters an_event) { | |
| 178 DCHECK(an_event >= MIN_COUNTER && an_event < MAX_COUNTER); | |
| 179 counters_[an_event]++; | |
| 180 } | |
| 181 | |
| 182 void Stats::SetCounter(Counters counter, int64 value) { | |
| 183 DCHECK(counter >= MIN_COUNTER && counter < MAX_COUNTER); | |
| 184 counters_[counter] = value; | |
| 185 } | |
| 186 | |
| 187 int64 Stats::GetCounter(Counters counter) const { | |
| 188 DCHECK(counter >= MIN_COUNTER && counter < MAX_COUNTER); | |
| 189 return counters_[counter]; | |
| 190 } | |
| 191 | |
| 192 void Stats::GetItems(StatsItems* items) { | |
| 193 std::pair<std::string, std::string> item; | |
| 194 for (int i = 0; i < kDataSizesLength; i++) { | |
| 195 item.first = base::StringPrintf("Size%02d", i); | |
| 196 item.second = base::StringPrintf("0x%08x", data_sizes_[i]); | |
| 197 items->push_back(item); | |
| 198 } | |
| 199 | |
| 200 for (int i = MIN_COUNTER; i < MAX_COUNTER; i++) { | |
| 201 item.first = kCounterNames[i]; | |
| 202 item.second = base::StringPrintf("0x%" PRIx64, counters_[i]); | |
| 203 items->push_back(item); | |
| 204 } | |
| 205 } | |
| 206 | |
| 207 int Stats::GetHitRatio() const { | |
| 208 return GetRatio(OPEN_HIT, OPEN_MISS); | |
| 209 } | |
| 210 | |
| 211 int Stats::GetResurrectRatio() const { | |
| 212 return GetRatio(RESURRECT_HIT, CREATE_HIT); | |
| 213 } | |
| 214 | |
| 215 void Stats::ResetRatios() { | |
| 216 SetCounter(OPEN_HIT, 0); | |
| 217 SetCounter(OPEN_MISS, 0); | |
| 218 SetCounter(RESURRECT_HIT, 0); | |
| 219 SetCounter(CREATE_HIT, 0); | |
| 220 } | |
| 221 | |
| 222 int Stats::GetLargeEntriesSize() { | |
| 223 int total = 0; | |
| 224 // data_sizes_[20] stores values between 512 KB and 1 MB (see comment before | |
| 225 // GetStatsBucket()). | |
| 226 for (int bucket = 20; bucket < kDataSizesLength; bucket++) | |
| 227 total += data_sizes_[bucket] * GetBucketRange(bucket); | |
| 228 | |
| 229 return total; | |
| 230 } | |
| 231 | |
| 232 int Stats::SerializeStats(void* data, int num_bytes, Addr* address) { | |
| 233 OnDiskStats* stats = reinterpret_cast<OnDiskStats*>(data); | |
| 234 if (num_bytes < static_cast<int>(sizeof(*stats))) | |
| 235 return 0; | |
| 236 | |
| 237 stats->signature = kDiskSignature; | |
| 238 stats->size = sizeof(*stats); | |
| 239 memcpy(stats->data_sizes, data_sizes_, sizeof(data_sizes_)); | |
| 240 memcpy(stats->counters, counters_, sizeof(counters_)); | |
| 241 | |
| 242 *address = storage_addr_; | |
| 243 return sizeof(*stats); | |
| 244 } | |
| 245 | |
| 246 int Stats::GetBucketRange(size_t i) const { | |
| 247 if (i < 2) | |
| 248 return static_cast<int>(1024 * i); | |
| 249 | |
| 250 if (i < 12) | |
| 251 return static_cast<int>(2048 * (i - 1)); | |
| 252 | |
| 253 if (i < 17) | |
| 254 return static_cast<int>(4096 * (i - 11)) + 20 * 1024; | |
| 255 | |
| 256 int n = 64 * 1024; | |
| 257 if (i > static_cast<size_t>(kDataSizesLength)) { | |
| 258 NOTREACHED(); | |
| 259 i = kDataSizesLength; | |
| 260 } | |
| 261 | |
| 262 i -= 17; | |
| 263 n <<= i; | |
| 264 return n; | |
| 265 } | |
| 266 | |
| 267 // The array will be filled this way: | |
| 268 // index size | |
| 269 // 0 [0, 1024) | |
| 270 // 1 [1024, 2048) | |
| 271 // 2 [2048, 4096) | |
| 272 // 3 [4K, 6K) | |
| 273 // ... | |
| 274 // 10 [18K, 20K) | |
| 275 // 11 [20K, 24K) | |
| 276 // 12 [24k, 28K) | |
| 277 // ... | |
| 278 // 15 [36k, 40K) | |
| 279 // 16 [40k, 64K) | |
| 280 // 17 [64K, 128K) | |
| 281 // 18 [128K, 256K) | |
| 282 // ... | |
| 283 // 23 [4M, 8M) | |
| 284 // 24 [8M, 16M) | |
| 285 // 25 [16M, 32M) | |
| 286 // 26 [32M, 64M) | |
| 287 // 27 [64M, ...) | |
| 288 int Stats::GetStatsBucket(int32 size) { | |
| 289 if (size < 1024) | |
| 290 return 0; | |
| 291 | |
| 292 // 10 slots more, until 20K. | |
| 293 if (size < 20 * 1024) | |
| 294 return size / 2048 + 1; | |
| 295 | |
| 296 // 5 slots more, from 20K to 40K. | |
| 297 if (size < 40 * 1024) | |
| 298 return (size - 20 * 1024) / 4096 + 11; | |
| 299 | |
| 300 // From this point on, use a logarithmic scale. | |
| 301 int result = LogBase2(size) + 1; | |
| 302 | |
| 303 static_assert(kDataSizesLength > 16, "update the scale"); | |
| 304 if (result >= kDataSizesLength) | |
| 305 result = kDataSizesLength - 1; | |
| 306 | |
| 307 return result; | |
| 308 } | |
| 309 | |
| 310 int Stats::GetRatio(Counters hit, Counters miss) const { | |
| 311 int64 ratio = GetCounter(hit) * 100; | |
| 312 if (!ratio) | |
| 313 return 0; | |
| 314 | |
| 315 ratio /= (GetCounter(hit) + GetCounter(miss)); | |
| 316 return static_cast<int>(ratio); | |
| 317 } | |
| 318 | |
| 319 } // namespace disk_cache | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master