1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 package org.apache.hadoop.hbase.io;
22
23 import java.io.IOException;
24 import java.nio.ByteBuffer;
25 import java.util.ArrayList;
26 import java.util.TreeMap;
27 import java.util.concurrent.ConcurrentHashMap;
28 import java.util.concurrent.ConcurrentSkipListMap;
29 import java.util.concurrent.CopyOnWriteArrayList;
30 import java.util.concurrent.CopyOnWriteArraySet;
31 import java.util.concurrent.atomic.AtomicBoolean;
32 import java.util.concurrent.atomic.AtomicInteger;
33 import java.util.concurrent.atomic.AtomicLong;
34 import java.util.concurrent.locks.ReentrantReadWriteLock;
35
36 import junit.framework.TestCase;
37
38 import org.apache.commons.logging.Log;
39 import org.apache.commons.logging.LogFactory;
40 import org.apache.hadoop.hbase.KeyValue;
41 import org.apache.hadoop.hbase.SmallTests;
42 import org.apache.hadoop.hbase.client.Put;
43 import org.apache.hadoop.hbase.io.hfile.BlockCacheKey;
44 import org.apache.hadoop.hbase.io.hfile.CachedBlock;
45 import org.apache.hadoop.hbase.io.hfile.LruBlockCache;
46 import org.apache.hadoop.hbase.regionserver.HRegion;
47 import org.apache.hadoop.hbase.regionserver.KeyValueSkipListSet;
48 import org.apache.hadoop.hbase.regionserver.MemStore;
49 import org.apache.hadoop.hbase.regionserver.Store;
50 import org.apache.hadoop.hbase.regionserver.TimeRangeTracker;
51 import org.apache.hadoop.hbase.regionserver.metrics.SchemaConfigured;
52 import org.apache.hadoop.hbase.util.Bytes;
53 import org.apache.hadoop.hbase.util.ClassSize;
54 import org.junit.experimental.categories.Category;
55
56
57
58
59
60 @Category(SmallTests.class)
61 public class TestHeapSize extends TestCase {
62 static final Log LOG = LogFactory.getLog(TestHeapSize.class);
63
64
65
66
67
68
69
70 public void testNativeSizes() throws IOException {
71 @SuppressWarnings("rawtypes")
72 Class cl = null;
73 long expected = 0L;
74 long actual = 0L;
75
76
77 cl = ArrayList.class;
78 expected = ClassSize.estimateBase(cl, false);
79 actual = ClassSize.ARRAYLIST;
80 if(expected != actual) {
81 ClassSize.estimateBase(cl, true);
82 assertEquals(expected, actual);
83 }
84
85
86 cl = ByteBuffer.class;
87 expected = ClassSize.estimateBase(cl, false);
88 actual = ClassSize.BYTE_BUFFER;
89 if(expected != actual) {
90 ClassSize.estimateBase(cl, true);
91 assertEquals(expected, actual);
92 }
93
94
95 cl = Integer.class;
96 expected = ClassSize.estimateBase(cl, false);
97 actual = ClassSize.INTEGER;
98 if(expected != actual) {
99 ClassSize.estimateBase(cl, true);
100 assertEquals(expected, actual);
101 }
102
103
104
105
106
107
108
109
110
111
112
113
114 cl = Object.class;
115 expected = ClassSize.estimateBase(cl, false);
116 actual = ClassSize.OBJECT;
117 if(expected != actual) {
118 ClassSize.estimateBase(cl, true);
119 assertEquals(expected, actual);
120 }
121
122
123 cl = TreeMap.class;
124 expected = ClassSize.estimateBase(cl, false);
125 actual = ClassSize.TREEMAP;
126 if(expected != actual) {
127 ClassSize.estimateBase(cl, true);
128 assertEquals(expected, actual);
129 }
130
131
132 cl = String.class;
133 expected = ClassSize.estimateBase(cl, false);
134 actual = ClassSize.STRING;
135 if(expected != actual) {
136 ClassSize.estimateBase(cl, true);
137 assertEquals(expected, actual);
138 }
139
140
141 cl = ConcurrentHashMap.class;
142 expected = ClassSize.estimateBase(cl, false);
143 actual = ClassSize.CONCURRENT_HASHMAP;
144 if(expected != actual) {
145 ClassSize.estimateBase(cl, true);
146 assertEquals(expected, actual);
147 }
148
149
150 cl = ConcurrentSkipListMap.class;
151 expected = ClassSize.estimateBase(cl, false);
152 actual = ClassSize.CONCURRENT_SKIPLISTMAP;
153 if(expected != actual) {
154 ClassSize.estimateBase(cl, true);
155 assertEquals(expected, actual);
156 }
157
158
159 cl = ReentrantReadWriteLock.class;
160 expected = ClassSize.estimateBase(cl, false);
161 actual = ClassSize.REENTRANT_LOCK;
162 if(expected != actual) {
163 ClassSize.estimateBase(cl, true);
164 assertEquals(expected, actual);
165 }
166
167
168 cl = AtomicLong.class;
169 expected = ClassSize.estimateBase(cl, false);
170 actual = ClassSize.ATOMIC_LONG;
171 if(expected != actual) {
172 ClassSize.estimateBase(cl, true);
173 assertEquals(expected, actual);
174 }
175
176
177 cl = AtomicInteger.class;
178 expected = ClassSize.estimateBase(cl, false);
179 actual = ClassSize.ATOMIC_INTEGER;
180 if(expected != actual) {
181 ClassSize.estimateBase(cl, true);
182 assertEquals(expected, actual);
183 }
184
185
186 cl = AtomicBoolean.class;
187 expected = ClassSize.estimateBase(cl, false);
188 actual = ClassSize.ATOMIC_BOOLEAN;
189 if(expected != actual) {
190 ClassSize.estimateBase(cl, true);
191 assertEquals(expected, actual);
192 }
193
194
195 cl = CopyOnWriteArraySet.class;
196 expected = ClassSize.estimateBase(cl, false);
197 actual = ClassSize.COPYONWRITE_ARRAYSET;
198 if(expected != actual) {
199 ClassSize.estimateBase(cl, true);
200 assertEquals(expected, actual);
201 }
202
203
204 cl = CopyOnWriteArrayList.class;
205 expected = ClassSize.estimateBase(cl, false);
206 actual = ClassSize.COPYONWRITE_ARRAYLIST;
207 if(expected != actual) {
208 ClassSize.estimateBase(cl, true);
209 assertEquals(expected, actual);
210 }
211
212
213 cl = TimeRangeTracker.class;
214 expected = ClassSize.estimateBase(cl, false);
215 actual = ClassSize.TIMERANGE_TRACKER;
216 if (expected != actual) {
217 ClassSize.estimateBase(cl, true);
218 assertEquals(expected, actual);
219 }
220
221
222 cl = KeyValueSkipListSet.class;
223 expected = ClassSize.estimateBase(cl, false);
224 actual = ClassSize.KEYVALUE_SKIPLIST_SET;
225 if (expected != actual) {
226 ClassSize.estimateBase(cl, true);
227 assertEquals(expected, actual);
228 }
229 }
230
231
232
233
234
235
236
237 public void testSizes() throws IOException {
238 @SuppressWarnings("rawtypes")
239 Class cl = null;
240 long expected = 0L;
241 long actual = 0L;
242
243
244 cl = KeyValue.class;
245 expected = ClassSize.estimateBase(cl, false);
246 KeyValue kv = new KeyValue();
247 actual = kv.heapSize();
248 if(expected != actual) {
249 ClassSize.estimateBase(cl, true);
250 assertEquals(expected, actual);
251 }
252
253
254 cl = Put.class;
255 expected = ClassSize.estimateBase(cl, false);
256
257 expected += ClassSize.TREEMAP;
258 Put put = new Put(Bytes.toBytes(""));
259 actual = put.heapSize();
260 if(expected != actual) {
261 ClassSize.estimateBase(cl, true);
262 assertEquals(expected, actual);
263 }
264
265
266 cl = LruBlockCache.class;
267 actual = LruBlockCache.CACHE_FIXED_OVERHEAD;
268 expected = ClassSize.estimateBase(cl, false);
269 if(expected != actual) {
270 ClassSize.estimateBase(cl, true);
271 assertEquals(expected, actual);
272 }
273
274
275
276
277 cl = CachedBlock.class;
278 actual = CachedBlock.PER_BLOCK_OVERHEAD;
279 expected = ClassSize.estimateBase(cl, false);
280 expected += ClassSize.estimateBase(String.class, false);
281 expected += ClassSize.estimateBase(ByteBuffer.class, false);
282 if(expected != actual) {
283 ClassSize.estimateBase(cl, true);
284 ClassSize.estimateBase(String.class, true);
285 ClassSize.estimateBase(ByteBuffer.class, true);
286 assertEquals(expected, actual);
287 }
288
289
290 cl = MemStore.class;
291 actual = MemStore.FIXED_OVERHEAD;
292 expected = ClassSize.estimateBase(cl, false);
293 if(expected != actual) {
294 ClassSize.estimateBase(cl, true);
295 assertEquals(expected, actual);
296 }
297
298
299 actual = MemStore.DEEP_OVERHEAD;
300 expected = ClassSize.estimateBase(cl, false);
301 expected += ClassSize.estimateBase(ReentrantReadWriteLock.class, false);
302 expected += ClassSize.estimateBase(AtomicLong.class, false);
303 expected += (2 * ClassSize.estimateBase(KeyValueSkipListSet.class, false));
304 expected += (2 * ClassSize.estimateBase(ConcurrentSkipListMap.class, false));
305 expected += (2 * ClassSize.estimateBase(TimeRangeTracker.class, false));
306 if(expected != actual) {
307 ClassSize.estimateBase(cl, true);
308 ClassSize.estimateBase(ReentrantReadWriteLock.class, true);
309 ClassSize.estimateBase(AtomicLong.class, true);
310 ClassSize.estimateBase(KeyValueSkipListSet.class, true);
311 ClassSize.estimateBase(KeyValueSkipListSet.class, true);
312 ClassSize.estimateBase(ConcurrentSkipListMap.class, true);
313 ClassSize.estimateBase(ConcurrentSkipListMap.class, true);
314 ClassSize.estimateBase(TimeRangeTracker.class, true);
315 ClassSize.estimateBase(TimeRangeTracker.class, true);
316 assertEquals(expected, actual);
317 }
318
319
320 LOG.debug("Heap size for: " + SchemaConfigured.class.getName());
321 SchemaConfigured sc = new SchemaConfigured(null, "myTable", "myCF");
322 assertEquals(ClassSize.estimateBase(SchemaConfigured.class, true),
323 sc.heapSize());
324
325
326 cl = Store.class;
327 actual = Store.FIXED_OVERHEAD;
328 expected = ClassSize.estimateBase(cl, false);
329 if(expected != actual) {
330 ClassSize.estimateBase(cl, true);
331 assertEquals(expected, actual);
332 }
333
334
335 cl = HRegion.class;
336 actual = HRegion.FIXED_OVERHEAD;
337 expected = ClassSize.estimateBase(cl, false);
338 if (expected != actual) {
339 ClassSize.estimateBase(cl, true);
340 assertEquals(expected, actual);
341 }
342
343
344 cl = BlockCacheKey.class;
345
346
347 actual = new BlockCacheKey("", 0).heapSize();
348 expected = ClassSize.estimateBase(cl, false);
349 if (expected != actual) {
350 ClassSize.estimateBase(cl, true);
351 assertEquals(expected, actual);
352 }
353
354
355
356
357
358
359
360 }
361
362 @org.junit.Rule
363 public org.apache.hadoop.hbase.ResourceCheckerJUnitRule cu =
364 new org.apache.hadoop.hbase.ResourceCheckerJUnitRule();
365 }
366