View Javadoc

1   /**
2    * Copyright The Apache Software Foundation
3    *
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *     http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing, software
15   * distributed under the License is distributed on an "AS IS" BASIS,
16   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17   * See the License for the specific language governing permissions and
18   * limitations under the License.
19   */
20  
21  package org.apache.hadoop.hbase.util;
22  
23  import java.lang.reflect.Field;
24  import java.lang.reflect.Modifier;
25  import java.util.concurrent.ConcurrentHashMap;
26  import java.util.concurrent.ConcurrentSkipListMap;
27  
28  import org.apache.commons.logging.Log;
29  import org.apache.commons.logging.LogFactory;
30  import org.apache.hadoop.hbase.classification.InterfaceAudience;
31  
32  /**
33   * Class for determining the "size" of a class, an attempt to calculate the
34   * actual bytes that an object of this class will occupy in memory
35   *
36   * The core of this class is taken from the Derby project
37   */
38  @InterfaceAudience.Private
39  public class ClassSize {
40    private static final Log LOG = LogFactory.getLog(ClassSize.class);
41  
42    private static int nrOfRefsPerObj = 2;
43  
44    /** Array overhead */
45    public static final int ARRAY;
46  
47    /** Overhead for ArrayList(0) */
48    public static final int ARRAYLIST;
49  
50    /** Overhead for ByteBuffer */
51    public static final int BYTE_BUFFER;
52  
53    /** Overhead for an Integer */
54    public static final int INTEGER;
55  
56    /** Overhead for entry in map */
57    public static final int MAP_ENTRY;
58  
59    /** Object overhead is minimum 2 * reference size (8 bytes on 64-bit) */
60    public static final int OBJECT;
61  
62    /** Reference size is 8 bytes on 64-bit, 4 bytes on 32-bit */
63    public static final int REFERENCE;
64  
65    /** String overhead */
66    public static final int STRING;
67  
68    /** Overhead for TreeMap */
69    public static final int TREEMAP;
70  
71    /** Overhead for ConcurrentHashMap */
72    public static final int CONCURRENT_HASHMAP;
73  
74    /** Overhead for ConcurrentHashMap.Entry */
75    public static final int CONCURRENT_HASHMAP_ENTRY;
76  
77    /** Overhead for ConcurrentHashMap.Segment */
78    public static final int CONCURRENT_HASHMAP_SEGMENT;
79  
80    /** Overhead for ConcurrentSkipListMap */
81    public static final int CONCURRENT_SKIPLISTMAP;
82  
83    /** Overhead for ConcurrentSkipListMap Entry */
84    public static final int CONCURRENT_SKIPLISTMAP_ENTRY;
85  
86    /** Overhead for ReentrantReadWriteLock */
87    public static final int REENTRANT_LOCK;
88  
89    /** Overhead for AtomicLong */
90    public static final int ATOMIC_LONG;
91  
92    /** Overhead for AtomicInteger */
93    public static final int ATOMIC_INTEGER;
94  
95    /** Overhead for AtomicBoolean */
96    public static final int ATOMIC_BOOLEAN;
97  
98    /** Overhead for CopyOnWriteArraySet */
99    public static final int COPYONWRITE_ARRAYSET;
100 
101   /** Overhead for CopyOnWriteArrayList */
102   public static final int COPYONWRITE_ARRAYLIST;
103 
104   /** Overhead for timerange */
105   public static final int TIMERANGE;
106 
107   /** Overhead for TimeRangeTracker */
108   public static final int TIMERANGE_TRACKER;
109 
110   /** Overhead for CellSkipListSet */
111   public static final int CELL_SKIPLIST_SET;
112 
113   /**
114    * Method for reading the arc settings and setting overheads according
115    * to 32-bit or 64-bit architecture.
116    */
117   static {
118     //Default value is set to 8, covering the case when arcModel is unknown
119     if (is32BitJVM()) {
120       REFERENCE = 4;
121     } else {
122       REFERENCE = 8;
123     }
124 
125     OBJECT = 2 * REFERENCE;
126 
127     ARRAY = align(3 * REFERENCE);
128 
129     ARRAYLIST = align(OBJECT + align(REFERENCE) + align(ARRAY) +
130         (2 * Bytes.SIZEOF_INT));
131 
132     //noinspection PointlessArithmeticExpression
133     BYTE_BUFFER = align(OBJECT + align(REFERENCE) + align(ARRAY) +
134         (5 * Bytes.SIZEOF_INT) +
135         (3 * Bytes.SIZEOF_BOOLEAN) + Bytes.SIZEOF_LONG);
136 
137     INTEGER = align(OBJECT + Bytes.SIZEOF_INT);
138 
139     MAP_ENTRY = align(OBJECT + 5 * REFERENCE + Bytes.SIZEOF_BOOLEAN);
140 
141     TREEMAP = align(OBJECT + (2 * Bytes.SIZEOF_INT) + align(7 * REFERENCE));
142 
143     // STRING is different size in jdk6 and jdk7. Just use what we estimate as size rather than
144     // have a conditional on whether jdk7.
145     STRING = (int) estimateBase(String.class, false);
146 
147     // CONCURRENT_HASHMAP is different size in jdk6 and jdk7; it looks like its different between
148     // 23.6-b03 and 23.0-b21. Just use what we estimate as size rather than have a conditional on
149     // whether jdk7.
150     CONCURRENT_HASHMAP = (int) estimateBase(ConcurrentHashMap.class, false);
151 
152     CONCURRENT_HASHMAP_ENTRY = align(REFERENCE + OBJECT + (3 * REFERENCE) +
153         (2 * Bytes.SIZEOF_INT));
154 
155     CONCURRENT_HASHMAP_SEGMENT = align(REFERENCE + OBJECT +
156         (3 * Bytes.SIZEOF_INT) + Bytes.SIZEOF_FLOAT + ARRAY);
157 
158     // The size changes from jdk7 to jdk8, estimate the size rather than use a conditional
159     CONCURRENT_SKIPLISTMAP = (int) estimateBase(ConcurrentSkipListMap.class, false);
160 
161     CONCURRENT_SKIPLISTMAP_ENTRY = align(
162         align(OBJECT + (3 * REFERENCE)) + /* one node per entry */
163         align((OBJECT + (3 * REFERENCE))/2)); /* one index per two entries */
164 
165     REENTRANT_LOCK = align(OBJECT + (3 * REFERENCE));
166 
167     ATOMIC_LONG = align(OBJECT + Bytes.SIZEOF_LONG);
168 
169     ATOMIC_INTEGER = align(OBJECT + Bytes.SIZEOF_INT);
170 
171     ATOMIC_BOOLEAN = align(OBJECT + Bytes.SIZEOF_BOOLEAN);
172 
173     COPYONWRITE_ARRAYSET = align(OBJECT + REFERENCE);
174 
175     COPYONWRITE_ARRAYLIST = align(OBJECT + (2 * REFERENCE) + ARRAY);
176 
177     TIMERANGE = align(ClassSize.OBJECT + Bytes.SIZEOF_LONG * 2 + Bytes.SIZEOF_BOOLEAN);
178 
179     TIMERANGE_TRACKER = align(ClassSize.OBJECT + Bytes.SIZEOF_LONG * 2);
180 
181     CELL_SKIPLIST_SET = align(OBJECT + REFERENCE);
182   }
183 
184   /**
185    * The estimate of the size of a class instance depends on whether the JVM
186    * uses 32 or 64 bit addresses, that is it depends on the size of an object
187    * reference. It is a linear function of the size of a reference, e.g.
188    * 24 + 5*r where r is the size of a reference (usually 4 or 8 bytes).
189    *
190    * This method returns the coefficients of the linear function, e.g. {24, 5}
191    * in the above example.
192    *
193    * @param cl A class whose instance size is to be estimated
194    * @param debug debug flag
195    * @return an array of 3 integers. The first integer is the size of the
196    * primitives, the second the number of arrays and the third the number of
197    * references.
198    */
199   @SuppressWarnings("unchecked")
200   private static int [] getSizeCoefficients(Class cl, boolean debug) {
201     int primitives = 0;
202     int arrays = 0;
203     //The number of references that a new object takes
204     int references = nrOfRefsPerObj;
205     int index = 0;
206 
207     for ( ; null != cl; cl = cl.getSuperclass()) {
208       Field[] field = cl.getDeclaredFields();
209       if (null != field) {
210         for (Field aField : field) {
211           if (Modifier.isStatic(aField.getModifiers())) continue;
212           Class fieldClass = aField.getType();
213           if (fieldClass.isArray()) {
214             arrays++;
215             references++;
216           } else if (!fieldClass.isPrimitive()) {
217             references++;
218           } else {// Is simple primitive
219             String name = fieldClass.getName();
220 
221             if (name.equals("int") || name.equals("I"))
222               primitives += Bytes.SIZEOF_INT;
223             else if (name.equals("long") || name.equals("J"))
224               primitives += Bytes.SIZEOF_LONG;
225             else if (name.equals("boolean") || name.equals("Z"))
226               primitives += Bytes.SIZEOF_BOOLEAN;
227             else if (name.equals("short") || name.equals("S"))
228               primitives += Bytes.SIZEOF_SHORT;
229             else if (name.equals("byte") || name.equals("B"))
230               primitives += Bytes.SIZEOF_BYTE;
231             else if (name.equals("char") || name.equals("C"))
232               primitives += Bytes.SIZEOF_CHAR;
233             else if (name.equals("float") || name.equals("F"))
234               primitives += Bytes.SIZEOF_FLOAT;
235             else if (name.equals("double") || name.equals("D"))
236               primitives += Bytes.SIZEOF_DOUBLE;
237           }
238           if (debug) {
239             if (LOG.isDebugEnabled()) {
240               LOG.debug("" + index + " " + aField.getName() + " " + aField.getType());
241             }
242           }
243           index++;
244         }
245       }
246     }
247     return new int [] {primitives, arrays, references};
248   }
249 
250   /**
251    * Estimate the static space taken up by a class instance given the
252    * coefficients returned by getSizeCoefficients.
253    *
254    * @param coeff the coefficients
255    *
256    * @param debug debug flag
257    * @return the size estimate, in bytes
258    */
259   private static long estimateBaseFromCoefficients(int [] coeff, boolean debug) {
260     long prealign_size = coeff[0] + align(coeff[1] * ARRAY) + coeff[2] * REFERENCE;
261 
262     // Round up to a multiple of 8
263     long size = align(prealign_size);
264     if(debug) {
265       if (LOG.isDebugEnabled()) {
266         LOG.debug("Primitives=" + coeff[0] + ", arrays=" + coeff[1] +
267             ", references(includes " + nrOfRefsPerObj +
268             " for object overhead)=" + coeff[2] + ", refSize " + REFERENCE +
269             ", size=" + size + ", prealign_size=" + prealign_size);
270       }
271     }
272     return size;
273   }
274 
275   /**
276    * Estimate the static space taken up by the fields of a class. This includes
277    * the space taken up by by references (the pointer) but not by the referenced
278    * object. So the estimated size of an array field does not depend on the size
279    * of the array. Similarly the size of an object (reference) field does not
280    * depend on the object.
281    *
282    * @param cl class
283    * @param debug debug flag
284    * @return the size estimate in bytes.
285    */
286   @SuppressWarnings("unchecked")
287   public static long estimateBase(Class cl, boolean debug) {
288     return estimateBaseFromCoefficients( getSizeCoefficients(cl, debug), debug);
289   }
290 
291   /**
292    * Aligns a number to 8.
293    * @param num number to align to 8
294    * @return smallest number >= input that is a multiple of 8
295    */
296   public static int align(int num) {
297     return (int)(align((long)num));
298   }
299 
300   /**
301    * Aligns a number to 8.
302    * @param num number to align to 8
303    * @return smallest number >= input that is a multiple of 8
304    */
305   public static long align(long num) {
306     //The 7 comes from that the alignSize is 8 which is the number of bytes
307     //stored and sent together
308     return  ((num + 7) >> 3) << 3;
309   }
310 
311   /**
312    * Determines if we are running in a 32-bit JVM. Some unit tests need to
313    * know this too.
314    */
315   public static boolean is32BitJVM() {
316     return System.getProperty("sun.arch.data.model").equals("32");
317   }
318 
319 }
320