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 COMPILE_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 static const char* 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 COMPILE_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 COMPILE_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 COMPILE_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 320
