001/* 002 * Copyright (C) 2011 The Guava Authors 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except 005 * in compliance with the License. You may obtain a copy of the License at 006 * 007 * http://www.apache.org/licenses/LICENSE-2.0 008 * 009 * Unless required by applicable law or agreed to in writing, software distributed under the License 010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 011 * or implied. See the License for the specific language governing permissions and limitations under 012 * the License. 013 */ 014 015package com.google.common.cache; 016 017import static com.google.common.base.Preconditions.checkArgument; 018import static com.google.common.math.LongMath.saturatedAdd; 019import static com.google.common.math.LongMath.saturatedSubtract; 020 021import com.google.common.annotations.GwtCompatible; 022import com.google.common.base.MoreObjects; 023import com.google.common.base.Objects; 024import java.util.concurrent.Callable; 025import javax.annotation.CheckForNull; 026 027/** 028 * Statistics about the performance of a {@link Cache}. Instances of this class are immutable. 029 * 030 * <p>Cache statistics are incremented according to the following rules: 031 * 032 * <ul> 033 * <li>When a cache lookup encounters an existing cache entry {@code hitCount} is incremented. 034 * <li>When a cache lookup first encounters a missing cache entry, a new entry is loaded. 035 * <ul> 036 * <li>After successfully loading an entry {@code missCount} and {@code loadSuccessCount} 037 * are incremented, and the total loading time, in nanoseconds, is added to {@code 038 * totalLoadTime}. 039 * <li>When an exception is thrown while loading an entry, {@code missCount} and {@code 040 * loadExceptionCount} are incremented, and the total loading time, in nanoseconds, is 041 * added to {@code totalLoadTime}. 042 * <li>Cache lookups that encounter a missing cache entry that is still loading will wait 043 * for loading to complete (whether successful or not) and then increment {@code 044 * missCount}. 045 * </ul> 046 * <li>When an entry is evicted from the cache, {@code evictionCount} is incremented. 047 * <li>No stats are modified when a cache entry is invalidated or manually removed. 048 * <li>No stats are modified by operations invoked on the {@linkplain Cache#asMap asMap} view of 049 * the cache. 050 * </ul> 051 * 052 * <p>A lookup is specifically defined as an invocation of one of the methods {@link 053 * LoadingCache#get(Object)}, {@link LoadingCache#getUnchecked(Object)}, {@link Cache#get(Object, 054 * Callable)}, or {@link LoadingCache#getAll(Iterable)}. 055 * 056 * @author Charles Fry 057 * @since 10.0 058 */ 059@GwtCompatible 060@ElementTypesAreNonnullByDefault 061public final class CacheStats { 062 private final long hitCount; 063 private final long missCount; 064 private final long loadSuccessCount; 065 private final long loadExceptionCount; 066 067 @SuppressWarnings("GoodTime") // should be a java.time.Duration 068 private final long totalLoadTime; 069 070 private final long evictionCount; 071 072 /** 073 * Constructs a new {@code CacheStats} instance. 074 * 075 * <p>Five parameters of the same type in a row is a bad thing, but this class is not constructed 076 * by end users and is too fine-grained for a builder. 077 */ 078 @SuppressWarnings("GoodTime") // should accept a java.time.Duration 079 public CacheStats( 080 long hitCount, 081 long missCount, 082 long loadSuccessCount, 083 long loadExceptionCount, 084 long totalLoadTime, 085 long evictionCount) { 086 checkArgument(hitCount >= 0); 087 checkArgument(missCount >= 0); 088 checkArgument(loadSuccessCount >= 0); 089 checkArgument(loadExceptionCount >= 0); 090 checkArgument(totalLoadTime >= 0); 091 checkArgument(evictionCount >= 0); 092 093 this.hitCount = hitCount; 094 this.missCount = missCount; 095 this.loadSuccessCount = loadSuccessCount; 096 this.loadExceptionCount = loadExceptionCount; 097 this.totalLoadTime = totalLoadTime; 098 this.evictionCount = evictionCount; 099 } 100 101 /** 102 * Returns the number of times {@link Cache} lookup methods have returned either a cached or 103 * uncached value. This is defined as {@code hitCount + missCount}. 104 * 105 * <p><b>Note:</b> the values of the metrics are undefined in case of overflow (though it is 106 * guaranteed not to throw an exception). If you require specific handling, we recommend 107 * implementing your own stats collector. 108 */ 109 public long requestCount() { 110 return saturatedAdd(hitCount, missCount); 111 } 112 113 /** Returns the number of times {@link Cache} lookup methods have returned a cached value. */ 114 public long hitCount() { 115 return hitCount; 116 } 117 118 /** 119 * Returns the ratio of cache requests which were hits. This is defined as {@code hitCount / 120 * requestCount}, or {@code 1.0} when {@code requestCount == 0}. Note that {@code hitRate + 121 * missRate =~ 1.0}. 122 */ 123 public double hitRate() { 124 long requestCount = requestCount(); 125 return (requestCount == 0) ? 1.0 : (double) hitCount / requestCount; 126 } 127 128 /** 129 * Returns the number of times {@link Cache} lookup methods have returned an uncached (newly 130 * loaded) value, or null. Multiple concurrent calls to {@link Cache} lookup methods on an absent 131 * value can result in multiple misses, all returning the results of a single cache load 132 * operation. 133 */ 134 public long missCount() { 135 return missCount; 136 } 137 138 /** 139 * Returns the ratio of cache requests which were misses. This is defined as {@code missCount / 140 * requestCount}, or {@code 0.0} when {@code requestCount == 0}. Note that {@code hitRate + 141 * missRate =~ 1.0}. Cache misses include all requests which weren't cache hits, including 142 * requests which resulted in either successful or failed loading attempts, and requests which 143 * waited for other threads to finish loading. It is thus the case that {@code missCount >= 144 * loadSuccessCount + loadExceptionCount}. Multiple concurrent misses for the same key will result 145 * in a single load operation. 146 */ 147 public double missRate() { 148 long requestCount = requestCount(); 149 return (requestCount == 0) ? 0.0 : (double) missCount / requestCount; 150 } 151 152 /** 153 * Returns the total number of times that {@link Cache} lookup methods attempted to load new 154 * values. This includes both successful load operations and those that threw exceptions. This is 155 * defined as {@code loadSuccessCount + loadExceptionCount}. 156 * 157 * <p><b>Note:</b> the values of the metrics are undefined in case of overflow (though it is 158 * guaranteed not to throw an exception). If you require specific handling, we recommend 159 * implementing your own stats collector. 160 */ 161 public long loadCount() { 162 return saturatedAdd(loadSuccessCount, loadExceptionCount); 163 } 164 165 /** 166 * Returns the number of times {@link Cache} lookup methods have successfully loaded a new value. 167 * This is usually incremented in conjunction with {@link #missCount}, though {@code missCount} is 168 * also incremented when an exception is encountered during cache loading (see {@link 169 * #loadExceptionCount}). Multiple concurrent misses for the same key will result in a single load 170 * operation. This may be incremented not in conjunction with {@code missCount} if the load occurs 171 * as a result of a refresh or if the cache loader returned more items than was requested. {@code 172 * missCount} may also be incremented not in conjunction with this (nor {@link 173 * #loadExceptionCount}) on calls to {@code getIfPresent}. 174 */ 175 public long loadSuccessCount() { 176 return loadSuccessCount; 177 } 178 179 /** 180 * Returns the number of times {@link Cache} lookup methods threw an exception while loading a new 181 * value. This is usually incremented in conjunction with {@code missCount}, though {@code 182 * missCount} is also incremented when cache loading completes successfully (see {@link 183 * #loadSuccessCount}). Multiple concurrent misses for the same key will result in a single load 184 * operation. This may be incremented not in conjunction with {@code missCount} if the load occurs 185 * as a result of a refresh or if the cache loader returned more items than was requested. {@code 186 * missCount} may also be incremented not in conjunction with this (nor {@link #loadSuccessCount}) 187 * on calls to {@code getIfPresent}. 188 */ 189 public long loadExceptionCount() { 190 return loadExceptionCount; 191 } 192 193 /** 194 * Returns the ratio of cache loading attempts which threw exceptions. This is defined as {@code 195 * loadExceptionCount / (loadSuccessCount + loadExceptionCount)}, or {@code 0.0} when {@code 196 * loadSuccessCount + loadExceptionCount == 0}. 197 * 198 * <p><b>Note:</b> the values of the metrics are undefined in case of overflow (though it is 199 * guaranteed not to throw an exception). If you require specific handling, we recommend 200 * implementing your own stats collector. 201 */ 202 public double loadExceptionRate() { 203 long totalLoadCount = saturatedAdd(loadSuccessCount, loadExceptionCount); 204 return (totalLoadCount == 0) ? 0.0 : (double) loadExceptionCount / totalLoadCount; 205 } 206 207 /** 208 * Returns the total number of nanoseconds the cache has spent loading new values. This can be 209 * used to calculate the miss penalty. This value is increased every time {@code loadSuccessCount} 210 * or {@code loadExceptionCount} is incremented. 211 */ 212 @SuppressWarnings("GoodTime") // should return a java.time.Duration 213 public long totalLoadTime() { 214 return totalLoadTime; 215 } 216 217 /** 218 * Returns the average time spent loading new values. This is defined as {@code totalLoadTime / 219 * (loadSuccessCount + loadExceptionCount)}. 220 * 221 * <p><b>Note:</b> the values of the metrics are undefined in case of overflow (though it is 222 * guaranteed not to throw an exception). If you require specific handling, we recommend 223 * implementing your own stats collector. 224 */ 225 public double averageLoadPenalty() { 226 long totalLoadCount = saturatedAdd(loadSuccessCount, loadExceptionCount); 227 return (totalLoadCount == 0) ? 0.0 : (double) totalLoadTime / totalLoadCount; 228 } 229 230 /** 231 * Returns the number of times an entry has been evicted. This count does not include manual 232 * {@linkplain Cache#invalidate invalidations}. 233 */ 234 public long evictionCount() { 235 return evictionCount; 236 } 237 238 /** 239 * Returns a new {@code CacheStats} representing the difference between this {@code CacheStats} 240 * and {@code other}. Negative values, which aren't supported by {@code CacheStats} will be 241 * rounded up to zero. 242 */ 243 public CacheStats minus(CacheStats other) { 244 return new CacheStats( 245 Math.max(0, saturatedSubtract(hitCount, other.hitCount)), 246 Math.max(0, saturatedSubtract(missCount, other.missCount)), 247 Math.max(0, saturatedSubtract(loadSuccessCount, other.loadSuccessCount)), 248 Math.max(0, saturatedSubtract(loadExceptionCount, other.loadExceptionCount)), 249 Math.max(0, saturatedSubtract(totalLoadTime, other.totalLoadTime)), 250 Math.max(0, saturatedSubtract(evictionCount, other.evictionCount))); 251 } 252 253 /** 254 * Returns a new {@code CacheStats} representing the sum of this {@code CacheStats} and {@code 255 * other}. 256 * 257 * <p><b>Note:</b> the values of the metrics are undefined in case of overflow (though it is 258 * guaranteed not to throw an exception). If you require specific handling, we recommend 259 * implementing your own stats collector. 260 * 261 * @since 11.0 262 */ 263 public CacheStats plus(CacheStats other) { 264 return new CacheStats( 265 saturatedAdd(hitCount, other.hitCount), 266 saturatedAdd(missCount, other.missCount), 267 saturatedAdd(loadSuccessCount, other.loadSuccessCount), 268 saturatedAdd(loadExceptionCount, other.loadExceptionCount), 269 saturatedAdd(totalLoadTime, other.totalLoadTime), 270 saturatedAdd(evictionCount, other.evictionCount)); 271 } 272 273 @Override 274 public int hashCode() { 275 return Objects.hashCode( 276 hitCount, missCount, loadSuccessCount, loadExceptionCount, totalLoadTime, evictionCount); 277 } 278 279 @Override 280 public boolean equals(@CheckForNull Object object) { 281 if (object instanceof CacheStats) { 282 CacheStats other = (CacheStats) object; 283 return hitCount == other.hitCount 284 && missCount == other.missCount 285 && loadSuccessCount == other.loadSuccessCount 286 && loadExceptionCount == other.loadExceptionCount 287 && totalLoadTime == other.totalLoadTime 288 && evictionCount == other.evictionCount; 289 } 290 return false; 291 } 292 293 @Override 294 public String toString() { 295 return MoreObjects.toStringHelper(this) 296 .add("hitCount", hitCount) 297 .add("missCount", missCount) 298 .add("loadSuccessCount", loadSuccessCount) 299 .add("loadExceptionCount", loadExceptionCount) 300 .add("totalLoadTime", totalLoadTime) 301 .add("evictionCount", evictionCount) 302 .toString(); 303 } 304}