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