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.client.Put;
42 import org.apache.hadoop.hbase.io.hfile.CachedBlock;
43 import org.apache.hadoop.hbase.io.hfile.LruBlockCache;
44 import org.apache.hadoop.hbase.regionserver.HRegion;
45 import org.apache.hadoop.hbase.regionserver.MemStore;
46 import org.apache.hadoop.hbase.regionserver.Store;
47 import org.apache.hadoop.hbase.util.Bytes;
48 import org.apache.hadoop.hbase.util.ClassSize;
49
50
51
52
53
54 public class TestHeapSize extends TestCase {
55 static final Log LOG = LogFactory.getLog(TestHeapSize.class);
56
57
58
59
60
61
62
63 public void testNativeSizes() throws IOException {
64 @SuppressWarnings("rawtypes")
65 Class cl = null;
66 long expected = 0L;
67 long actual = 0L;
68
69
70 cl = ArrayList.class;
71 expected = ClassSize.estimateBase(cl, false);
72 actual = ClassSize.ARRAYLIST;
73 if(expected != actual) {
74 ClassSize.estimateBase(cl, true);
75 assertEquals(expected, actual);
76 }
77
78
79 cl = ByteBuffer.class;
80 expected = ClassSize.estimateBase(cl, false);
81 actual = ClassSize.BYTE_BUFFER;
82 if(expected != actual) {
83 ClassSize.estimateBase(cl, true);
84 assertEquals(expected, actual);
85 }
86
87
88 cl = Integer.class;
89 expected = ClassSize.estimateBase(cl, false);
90 actual = ClassSize.INTEGER;
91 if(expected != actual) {
92 ClassSize.estimateBase(cl, true);
93 assertEquals(expected, actual);
94 }
95
96
97
98
99
100
101
102
103
104
105
106
107 cl = Object.class;
108 expected = ClassSize.estimateBase(cl, false);
109 actual = ClassSize.OBJECT;
110 if(expected != actual) {
111 ClassSize.estimateBase(cl, true);
112 assertEquals(expected, actual);
113 }
114
115
116 cl = TreeMap.class;
117 expected = ClassSize.estimateBase(cl, false);
118 actual = ClassSize.TREEMAP;
119 if(expected != actual) {
120 ClassSize.estimateBase(cl, true);
121 assertEquals(expected, actual);
122 }
123
124
125 cl = String.class;
126 expected = ClassSize.estimateBase(cl, false);
127 actual = ClassSize.STRING;
128 if(expected != actual) {
129 ClassSize.estimateBase(cl, true);
130 assertEquals(expected, actual);
131 }
132
133
134 cl = ConcurrentHashMap.class;
135 expected = ClassSize.estimateBase(cl, false);
136 actual = ClassSize.CONCURRENT_HASHMAP;
137 if(expected != actual) {
138 ClassSize.estimateBase(cl, true);
139 assertEquals(expected, actual);
140 }
141
142
143 cl = ConcurrentSkipListMap.class;
144 expected = ClassSize.estimateBase(cl, false);
145 actual = ClassSize.CONCURRENT_SKIPLISTMAP;
146 if(expected != actual) {
147 ClassSize.estimateBase(cl, true);
148 assertEquals(expected, actual);
149 }
150
151
152 cl = ReentrantReadWriteLock.class;
153 expected = ClassSize.estimateBase(cl, false);
154 actual = ClassSize.REENTRANT_LOCK;
155 if(expected != actual) {
156 ClassSize.estimateBase(cl, true);
157 assertEquals(expected, actual);
158 }
159
160
161 cl = AtomicLong.class;
162 expected = ClassSize.estimateBase(cl, false);
163 actual = ClassSize.ATOMIC_LONG;
164 if(expected != actual) {
165 ClassSize.estimateBase(cl, true);
166 assertEquals(expected, actual);
167 }
168
169
170 cl = AtomicInteger.class;
171 expected = ClassSize.estimateBase(cl, false);
172 actual = ClassSize.ATOMIC_INTEGER;
173 if(expected != actual) {
174 ClassSize.estimateBase(cl, true);
175 assertEquals(expected, actual);
176 }
177
178
179 cl = AtomicBoolean.class;
180 expected = ClassSize.estimateBase(cl, false);
181 actual = ClassSize.ATOMIC_BOOLEAN;
182 if(expected != actual) {
183 ClassSize.estimateBase(cl, true);
184 assertEquals(expected, actual);
185 }
186
187
188 cl = CopyOnWriteArraySet.class;
189 expected = ClassSize.estimateBase(cl, false);
190 actual = ClassSize.COPYONWRITE_ARRAYSET;
191 if(expected != actual) {
192 ClassSize.estimateBase(cl, true);
193 assertEquals(expected, actual);
194 }
195
196
197 cl = CopyOnWriteArrayList.class;
198 expected = ClassSize.estimateBase(cl, false);
199 actual = ClassSize.COPYONWRITE_ARRAYLIST;
200 if(expected != actual) {
201 ClassSize.estimateBase(cl, true);
202 assertEquals(expected, actual);
203 }
204
205
206 }
207
208
209
210
211
212
213
214 public void testSizes() throws IOException {
215 @SuppressWarnings("rawtypes")
216 Class cl = null;
217 long expected = 0L;
218 long actual = 0L;
219
220
221 cl = KeyValue.class;
222 expected = ClassSize.estimateBase(cl, false);
223 KeyValue kv = new KeyValue();
224 actual = kv.heapSize();
225 if(expected != actual) {
226 ClassSize.estimateBase(cl, true);
227 assertEquals(expected, actual);
228 }
229
230
231 cl = Put.class;
232 expected = ClassSize.estimateBase(cl, false);
233
234 expected += ClassSize.TREEMAP;
235 Put put = new Put(Bytes.toBytes(""));
236 actual = put.heapSize();
237 if(expected != actual) {
238 ClassSize.estimateBase(cl, true);
239 assertEquals(expected, actual);
240 }
241
242
243 cl = LruBlockCache.class;
244 actual = LruBlockCache.CACHE_FIXED_OVERHEAD;
245 expected = ClassSize.estimateBase(cl, false);
246 if(expected != actual) {
247 ClassSize.estimateBase(cl, true);
248 assertEquals(expected, actual);
249 }
250
251
252
253
254 cl = CachedBlock.class;
255 actual = CachedBlock.PER_BLOCK_OVERHEAD;
256 expected = ClassSize.estimateBase(cl, false);
257 expected += ClassSize.estimateBase(String.class, false);
258 expected += ClassSize.estimateBase(ByteBuffer.class, false);
259 if(expected != actual) {
260 ClassSize.estimateBase(cl, true);
261 ClassSize.estimateBase(String.class, true);
262 ClassSize.estimateBase(ByteBuffer.class, true);
263 assertEquals(expected, actual);
264 }
265
266
267 cl = MemStore.class;
268 actual = MemStore.FIXED_OVERHEAD;
269 expected = ClassSize.estimateBase(cl, false);
270 if(expected != actual) {
271 ClassSize.estimateBase(cl, true);
272 assertEquals(expected, actual);
273 }
274
275
276 actual = MemStore.DEEP_OVERHEAD;
277 expected = ClassSize.estimateBase(cl, false);
278 expected += ClassSize.estimateBase(ReentrantReadWriteLock.class, false);
279 expected += ClassSize.estimateBase(AtomicLong.class, false);
280 expected += ClassSize.estimateBase(ConcurrentSkipListMap.class, false);
281 expected += ClassSize.estimateBase(ConcurrentSkipListMap.class, false);
282 expected += ClassSize.estimateBase(CopyOnWriteArraySet.class, false);
283 expected += ClassSize.estimateBase(CopyOnWriteArrayList.class, false);
284 if(expected != actual) {
285 ClassSize.estimateBase(cl, true);
286 ClassSize.estimateBase(ReentrantReadWriteLock.class, true);
287 ClassSize.estimateBase(AtomicLong.class, true);
288 ClassSize.estimateBase(ConcurrentSkipListMap.class, true);
289 ClassSize.estimateBase(CopyOnWriteArraySet.class, true);
290 ClassSize.estimateBase(CopyOnWriteArrayList.class, true);
291 assertEquals(expected, actual);
292 }
293
294
295 cl = Store.class;
296 actual = Store.FIXED_OVERHEAD;
297 expected = ClassSize.estimateBase(cl, false);
298 if(expected != actual) {
299 ClassSize.estimateBase(cl, true);
300 assertEquals(expected, actual);
301 }
302
303
304 cl = HRegion.class;
305 actual = HRegion.FIXED_OVERHEAD;
306 expected = ClassSize.estimateBase(cl, false);
307 if(expected != actual) {
308 ClassSize.estimateBase(cl, true);
309 assertEquals(expected, actual);
310 }
311
312
313
314
315
316
317
318
319 }
320
321 }