1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.hadoop.hbase.regionserver;
20
21 import static org.junit.Assert.assertEquals;
22 import static org.junit.Assert.assertFalse;
23 import static org.junit.Assert.assertTrue;
24 import static org.junit.Assert.fail;
25
26 import java.lang.management.ManagementFactory;
27 import java.util.Iterator;
28
29 import org.apache.hadoop.conf.Configuration;
30 import org.apache.hadoop.hbase.ChoreService;
31 import org.apache.hadoop.hbase.CoordinatedStateManager;
32 import org.apache.hadoop.hbase.HBaseConfiguration;
33 import org.apache.hadoop.hbase.HConstants;
34 import org.apache.hadoop.hbase.Server;
35 import org.apache.hadoop.hbase.ServerName;
36 import org.apache.hadoop.hbase.testclassification.SmallTests;
37 import org.apache.hadoop.hbase.client.ClusterConnection;
38 import org.apache.hadoop.hbase.io.hfile.BlockCache;
39 import org.apache.hadoop.hbase.io.hfile.BlockCacheKey;
40 import org.apache.hadoop.hbase.io.hfile.CacheStats;
41 import org.apache.hadoop.hbase.io.hfile.Cacheable;
42 import org.apache.hadoop.hbase.io.hfile.CachedBlock;
43 import org.apache.hadoop.hbase.io.hfile.ResizableBlockCache;
44 import org.apache.hadoop.hbase.io.util.HeapMemorySizeUtil;
45 import org.apache.hadoop.hbase.regionserver.HeapMemoryManager.TunerContext;
46 import org.apache.hadoop.hbase.regionserver.HeapMemoryManager.TunerResult;
47 import org.apache.hadoop.hbase.zookeeper.MetaTableLocator;
48 import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher;
49 import org.junit.Test;
50 import org.junit.experimental.categories.Category;
51
52 @Category(SmallTests.class)
53 public class TestHeapMemoryManager {
54
55 private long maxHeapSize = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getMax();
56
57 @Test
58 public void testAutoTunerShouldBeOffWhenMaxMinRangesForMemstoreIsNotGiven() throws Exception {
59 Configuration conf = HBaseConfiguration.create();
60 conf.setFloat(HeapMemorySizeUtil.MEMSTORE_SIZE_KEY, 0.02f);
61 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.75f);
62 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.03f);
63 HeapMemoryManager manager = new HeapMemoryManager(new BlockCacheStub(0),
64 new MemstoreFlusherStub(0), new RegionServerStub(conf));
65 assertFalse(manager.isTunerOn());
66 }
67
68 @Test
69 public void testAutoTunerShouldBeOffWhenMaxMinRangesForBlockCacheIsNotGiven() throws Exception {
70 Configuration conf = HBaseConfiguration.create();
71 conf.setFloat(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY, 0.02f);
72 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.75f);
73 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.03f);
74 HeapMemoryManager manager = new HeapMemoryManager(new BlockCacheStub(0),
75 new MemstoreFlusherStub(0), new RegionServerStub(conf));
76 assertFalse(manager.isTunerOn());
77 }
78
79 @Test
80 public void testWhenMemstoreAndBlockCacheMaxMinChecksFails() throws Exception {
81 BlockCacheStub blockCache = new BlockCacheStub(0);
82 MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub(0);
83 Configuration conf = HBaseConfiguration.create();
84 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.75f);
85 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.06f);
86 try {
87 new HeapMemoryManager(blockCache, memStoreFlusher, new RegionServerStub(conf));
88 fail();
89 } catch (RuntimeException e) {
90 }
91 conf = HBaseConfiguration.create();
92 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.2f);
93 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.7f);
94 try {
95 new HeapMemoryManager(blockCache, memStoreFlusher, new RegionServerStub(conf));
96 fail();
97 } catch (RuntimeException e) {
98 }
99 }
100
101 @Test
102 public void testWhenClusterIsWriteHeavy() throws Exception {
103 BlockCacheStub blockCache = new BlockCacheStub((long) (maxHeapSize * 0.4));
104 MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub((long) (maxHeapSize * 0.4));
105 Configuration conf = HBaseConfiguration.create();
106 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.75f);
107 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.10f);
108 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.7f);
109 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.05f);
110 conf.setLong(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_PERIOD, 1000);
111
112 HeapMemoryManager heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher,
113 new RegionServerStub(conf));
114 long oldMemstoreHeapSize = memStoreFlusher.memstoreSize;
115 long oldBlockCacheSize = blockCache.maxSize;
116 final ChoreService choreService = new ChoreService("TEST_SERVER_NAME");
117 heapMemoryManager.start(choreService);
118 memStoreFlusher.flushType = FlushType.ABOVE_HIGHER_MARK;
119 memStoreFlusher.requestFlush(null, false);
120 memStoreFlusher.requestFlush(null, false);
121 memStoreFlusher.requestFlush(null, false);
122 memStoreFlusher.flushType = FlushType.ABOVE_LOWER_MARK;
123 memStoreFlusher.requestFlush(null, false);
124 Thread.sleep(1500);
125 assertHeapSpaceDelta(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE, oldMemstoreHeapSize,
126 memStoreFlusher.memstoreSize);
127 assertHeapSpaceDelta(-(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE), oldBlockCacheSize,
128 blockCache.maxSize);
129 oldMemstoreHeapSize = memStoreFlusher.memstoreSize;
130 oldBlockCacheSize = blockCache.maxSize;
131
132 memStoreFlusher.flushType = FlushType.ABOVE_HIGHER_MARK;
133 memStoreFlusher.requestFlush(null, false);
134 memStoreFlusher.requestFlush(null, false);
135 Thread.sleep(1500);
136 assertHeapSpaceDelta(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE, oldMemstoreHeapSize,
137 memStoreFlusher.memstoreSize);
138 assertHeapSpaceDelta(-(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE), oldBlockCacheSize,
139 blockCache.maxSize);
140 }
141
142 @Test
143 public void testWhenClusterIsReadHeavy() throws Exception {
144 BlockCacheStub blockCache = new BlockCacheStub((long) (maxHeapSize * 0.4));
145 MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub((long) (maxHeapSize * 0.4));
146 Configuration conf = HBaseConfiguration.create();
147 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.75f);
148 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.10f);
149 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.7f);
150 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.05f);
151 conf.setLong(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_PERIOD, 1000);
152
153 HeapMemoryManager heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher,
154 new RegionServerStub(conf));
155 long oldMemstoreHeapSize = memStoreFlusher.memstoreSize;
156 long oldBlockCacheSize = blockCache.maxSize;
157 final ChoreService choreService = new ChoreService("TEST_SERVER_NAME");
158 heapMemoryManager.start(choreService);
159 blockCache.evictBlock(null);
160 blockCache.evictBlock(null);
161 blockCache.evictBlock(null);
162 Thread.sleep(1500);
163 assertHeapSpaceDelta(-(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE), oldMemstoreHeapSize,
164 memStoreFlusher.memstoreSize);
165 assertHeapSpaceDelta(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE, oldBlockCacheSize,
166 blockCache.maxSize);
167 oldMemstoreHeapSize = memStoreFlusher.memstoreSize;
168 oldBlockCacheSize = blockCache.maxSize;
169
170 blockCache.evictBlock(null);
171 Thread.sleep(1500);
172 assertHeapSpaceDelta(-(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE), oldMemstoreHeapSize,
173 memStoreFlusher.memstoreSize);
174 assertHeapSpaceDelta(DefaultHeapMemoryTuner.DEFAULT_STEP_VALUE, oldBlockCacheSize,
175 blockCache.maxSize);
176 }
177
178 @Test
179 public void testPluggingInHeapMemoryTuner() throws Exception {
180 BlockCacheStub blockCache = new BlockCacheStub((long) (maxHeapSize * 0.4));
181 MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub((long) (maxHeapSize * 0.4));
182 Configuration conf = HBaseConfiguration.create();
183 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.78f);
184 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.05f);
185 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.75f);
186 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.02f);
187 conf.setLong(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_PERIOD, 1000);
188 conf.setClass(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_CLASS, CustomHeapMemoryTuner.class,
189 HeapMemoryTuner.class);
190
191 HeapMemoryManager heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher,
192 new RegionServerStub(conf));
193 final ChoreService choreService = new ChoreService("TEST_SERVER_NAME");
194 heapMemoryManager.start(choreService);
195
196 CustomHeapMemoryTuner.memstoreSize = 0.78f;
197 CustomHeapMemoryTuner.blockCacheSize = 0.02f;
198 Thread.sleep(1500);
199 assertHeapSpace(0.78f, memStoreFlusher.memstoreSize);
200 assertHeapSpace(0.02f, blockCache.maxSize);
201
202 CustomHeapMemoryTuner.blockCacheSize = 0.75f;
203 CustomHeapMemoryTuner.memstoreSize = 0.05f;
204 Thread.sleep(1500);
205 assertHeapSpace(0.75f, blockCache.maxSize);
206 assertHeapSpace(0.05f, memStoreFlusher.memstoreSize);
207 }
208
209 @Test
210 public void testWhenSizeGivenByHeapTunerGoesOutsideRange() throws Exception {
211 BlockCacheStub blockCache = new BlockCacheStub((long) (maxHeapSize * 0.4));
212 MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub((long) (maxHeapSize * 0.4));
213 Configuration conf = HBaseConfiguration.create();
214 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.7f);
215 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.1f);
216 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.7f);
217 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.1f);
218 conf.setLong(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_PERIOD, 1000);
219 conf.setClass(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_CLASS, CustomHeapMemoryTuner.class,
220 HeapMemoryTuner.class);
221 HeapMemoryManager heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher,
222 new RegionServerStub(conf));
223 final ChoreService choreService = new ChoreService("TEST_SERVER_NAME");
224 heapMemoryManager.start(choreService);
225 CustomHeapMemoryTuner.memstoreSize = 0.78f;
226 CustomHeapMemoryTuner.blockCacheSize = 0.02f;
227 Thread.sleep(1500);
228
229
230 assertHeapSpace(0.7f, memStoreFlusher.memstoreSize);
231 assertHeapSpace(0.1f, blockCache.maxSize);
232 }
233
234 @Test
235 public void testWhenCombinedHeapSizesFromTunerGoesOutSideMaxLimit() throws Exception {
236 BlockCacheStub blockCache = new BlockCacheStub((long) (maxHeapSize * 0.4));
237 MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub((long) (maxHeapSize * 0.4));
238 Configuration conf = HBaseConfiguration.create();
239 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.7f);
240 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.1f);
241 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.7f);
242 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.1f);
243 conf.setLong(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_PERIOD, 1000);
244 conf.setClass(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_CLASS, CustomHeapMemoryTuner.class,
245 HeapMemoryTuner.class);
246 HeapMemoryManager heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher,
247 new RegionServerStub(conf));
248 long oldMemstoreSize = memStoreFlusher.memstoreSize;
249 long oldBlockCacheSize = blockCache.maxSize;
250 final ChoreService choreService = new ChoreService("TEST_SERVER_NAME");
251 heapMemoryManager.start(choreService);
252 CustomHeapMemoryTuner.memstoreSize = 0.7f;
253 CustomHeapMemoryTuner.blockCacheSize = 0.3f;
254 Thread.sleep(1500);
255 assertEquals(oldMemstoreSize, memStoreFlusher.memstoreSize);
256 assertEquals(oldBlockCacheSize, blockCache.maxSize);
257 }
258
259 @Test
260 public void testWhenL2BlockCacheIsOnHeap() throws Exception {
261 HeapMemoryManager heapMemoryManager = null;
262 BlockCacheStub blockCache = new BlockCacheStub((long) (maxHeapSize * 0.4));
263 MemstoreFlusherStub memStoreFlusher = new MemstoreFlusherStub((long) (maxHeapSize * 0.3));
264 Configuration conf = HBaseConfiguration.create();
265 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.7f);
266 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MIN_RANGE_KEY, 0.1f);
267 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.7f);
268 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MIN_RANGE_KEY, 0.1f);
269
270 conf.setFloat(HeapMemorySizeUtil.MEMSTORE_SIZE_KEY, 0.4F);
271 conf.setFloat(HConstants.HFILE_BLOCK_CACHE_SIZE_KEY, 0.3F);
272 conf.setFloat(HConstants.BUCKET_CACHE_SIZE_KEY, 0.1F);
273 conf.set(HConstants.BUCKET_CACHE_IOENGINE_KEY, "heap");
274
275 conf.setLong(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_PERIOD, 1000);
276 conf.setClass(HeapMemoryManager.HBASE_RS_HEAP_MEMORY_TUNER_CLASS, CustomHeapMemoryTuner.class,
277 HeapMemoryTuner.class);
278
279 try {
280 heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher, new RegionServerStub(
281 conf));
282 fail("Should have failed as the collective heap memory need is above 80%");
283 } catch (Exception e) {
284 }
285
286
287 conf.setFloat(HeapMemoryManager.MEMSTORE_SIZE_MAX_RANGE_KEY, 0.6f);
288 conf.setFloat(HeapMemoryManager.BLOCK_CACHE_SIZE_MAX_RANGE_KEY, 0.6f);
289 heapMemoryManager = new HeapMemoryManager(blockCache, memStoreFlusher, new RegionServerStub(
290 conf));
291 long oldMemstoreSize = memStoreFlusher.memstoreSize;
292 long oldBlockCacheSize = blockCache.maxSize;
293 final ChoreService choreService = new ChoreService("TEST_SERVER_NAME");
294 heapMemoryManager.start(choreService);
295 CustomHeapMemoryTuner.memstoreSize = 0.4f;
296 CustomHeapMemoryTuner.blockCacheSize = 0.4f;
297 Thread.sleep(1500);
298
299
300 assertEquals(oldMemstoreSize, memStoreFlusher.memstoreSize);
301 assertEquals(oldBlockCacheSize, blockCache.maxSize);
302 CustomHeapMemoryTuner.memstoreSize = 0.1f;
303 CustomHeapMemoryTuner.blockCacheSize = 0.5f;
304 Thread.sleep(1500);
305 assertHeapSpace(0.1f, memStoreFlusher.memstoreSize);
306 assertHeapSpace(0.5f, blockCache.maxSize);
307 }
308
309 private void assertHeapSpace(float expectedHeapPercentage, long currentHeapSpace) {
310 long expected = (long) (this.maxHeapSize * expectedHeapPercentage);
311 assertEquals(expected, currentHeapSpace);
312 }
313
314 private void assertHeapSpaceDelta(float expectedDeltaPercent, long oldHeapSpace, long newHeapSpace) {
315 long expctedMinDelta = (long) (this.maxHeapSize * expectedDeltaPercent);
316 if (expectedDeltaPercent > 0) {
317 assertTrue(expctedMinDelta <= (newHeapSpace - oldHeapSpace));
318 } else {
319 assertTrue(expctedMinDelta <= (oldHeapSpace - newHeapSpace));
320 }
321 }
322
323 private static class BlockCacheStub implements ResizableBlockCache {
324 CacheStats stats = new CacheStats("test");
325 long maxSize = 0;
326
327 public BlockCacheStub(long size){
328 this.maxSize = size;
329 }
330
331 @Override
332 public void cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory,
333 boolean cacheDataInL1) {
334
335 }
336
337 @Override
338 public void cacheBlock(BlockCacheKey cacheKey, Cacheable buf) {
339
340 }
341
342 @Override
343 public Cacheable getBlock(BlockCacheKey cacheKey, boolean caching, boolean repeat,
344 boolean updateCacheMetrics) {
345 return null;
346 }
347
348 @Override
349 public boolean evictBlock(BlockCacheKey cacheKey) {
350 stats.evicted(0, cacheKey != null ? cacheKey.isPrimary() : true);
351 return false;
352 }
353
354 @Override
355 public int evictBlocksByHfileName(String hfileName) {
356 stats.evicted(0, true);
357 return 0;
358 }
359
360 @Override
361 public CacheStats getStats() {
362 return this.stats;
363 }
364
365 @Override
366 public void shutdown() {
367
368 }
369
370 @Override
371 public long size() {
372 return 0;
373 }
374
375 @Override
376 public long getFreeSize() {
377 return 0;
378 }
379
380 @Override
381 public long getCurrentSize() {
382 return 0;
383 }
384
385 @Override
386 public long getBlockCount() {
387 return 0;
388 }
389
390 @Override
391 public void setMaxSize(long size) {
392 this.maxSize = size;
393 }
394
395 @Override
396 public Iterator<CachedBlock> iterator() {
397 return null;
398 }
399
400 @Override
401 public BlockCache[] getBlockCaches() {
402 return null;
403 }
404 }
405
406 private static class MemstoreFlusherStub implements FlushRequester {
407
408 long memstoreSize;
409
410 FlushRequestListener listener;
411
412 FlushType flushType = FlushType.NORMAL;
413
414 public MemstoreFlusherStub(long memstoreSize) {
415 this.memstoreSize = memstoreSize;
416 }
417
418 @Override
419 public void requestFlush(Region region, boolean forceFlushAllStores) {
420 this.listener.flushRequested(flushType, region);
421 }
422
423 @Override
424 public void requestDelayedFlush(Region region, long delay, boolean forceFlushAllStores) {
425
426 }
427
428 @Override
429 public void registerFlushRequestListener(FlushRequestListener listener) {
430 this.listener = listener;
431 }
432
433 @Override
434 public boolean unregisterFlushRequestListener(FlushRequestListener listener) {
435 return false;
436 }
437
438 @Override
439 public void setGlobalMemstoreLimit(long globalMemStoreSize) {
440 this.memstoreSize = globalMemStoreSize;
441 }
442 }
443
444 private static class RegionServerStub implements Server {
445 private Configuration conf;
446 private boolean stopped = false;
447
448 public RegionServerStub(Configuration conf) {
449 this.conf = conf;
450 }
451
452 @Override
453 public void abort(String why, Throwable e) {
454
455 }
456
457 @Override
458 public boolean isAborted() {
459 return false;
460 }
461
462 @Override
463 public void stop(String why) {
464 this.stopped = true;
465 }
466
467 @Override
468 public boolean isStopped() {
469 return this.stopped;
470 }
471
472 @Override
473 public Configuration getConfiguration() {
474 return this.conf;
475 }
476
477 @Override
478 public ZooKeeperWatcher getZooKeeper() {
479 return null;
480 }
481
482 @Override
483 public CoordinatedStateManager getCoordinatedStateManager() {
484 return null;
485 }
486
487 @Override
488 public ClusterConnection getConnection() {
489 return null;
490 }
491
492 @Override
493 public MetaTableLocator getMetaTableLocator() {
494 return null;
495 }
496
497 @Override
498 public ServerName getServerName() {
499 return ServerName.valueOf("server1",4000,12345);
500 }
501
502 @Override
503 public ChoreService getChoreService() {
504 return null;
505 }
506 }
507
508 static class CustomHeapMemoryTuner implements HeapMemoryTuner {
509 static float blockCacheSize = 0.4f;
510 static float memstoreSize = 0.4f;
511
512 @Override
513 public Configuration getConf() {
514 return null;
515 }
516
517 @Override
518 public void setConf(Configuration arg0) {
519
520 }
521
522 @Override
523 public TunerResult tune(TunerContext context) {
524 TunerResult result = new TunerResult(true);
525 result.setBlockCacheSize(blockCacheSize);
526 result.setMemstoreSize(memstoreSize);
527 return result;
528 }
529 }
530 }