HBase-cache相关

一些配置参数

hbase.lru.blockcache.min.factor

hbase.lru.blockcache.acceptable.factor

hbase.regionserver.global.memstore.upperLimit  默认为0.4

hbase.regionserver.global.memstore.lowerLimit   默认为0.35

 

 

 

 

 

cacheFlusher线程

主要用于定期清理 memstore中的数据，具体逻辑如下:

1. //在单独线程中运行，定期检查是否有  
2. //超过阈值的region，有则执行flush操作  
3. MemStoreFlusher#run() {  
4.     fqe = flushQueue.poll(threadWakeFrequency, TimeUnit.MILLISECONDS);  
5.     if (fqe == null || fqe instanceof WakeupFlushThread) {  
6.         if (isAboveLowWaterMark()) {  
7.             flushOneForGlobalPressure();      
8.         }  
9.         continue;     
10.     }     
11.     FlushRegionEntry fre = (FlushRegionEntry)fqe;  
12.     flushRegion(fre);  
13. }  
14.   
15. //只有高于lowLmit阈值才进行后续操作  
16. MemStoreFlusher#isAboveLowWaterMark() {  
17.     return server.getRegionServerAccounting().  
18.      getGlobalMemstoreSize() >= globalMemStoreLimitLowMark;    
19. }  
20.   
21. MemStoreFlusher#flushOneForGlobalPressure() {  
22.     HRegion bestFlushableRegion = getBiggestMemstoreRegion(  
23.           regionsBySize, excludedRegions, true);  
24.     HRegion bestAnyRegion = getBiggestMemstoreRegion(  
25.           regionsBySize, excludedRegions, false);  
26.     if (bestFlushableRegion == null) {  
27.         regionToFlush = bestAnyRegion;  
28.     } else {  
29.         regionToFlush = bestFlushableRegion;  
30.     }  
31.     flushRegion(regionToFlush, true);                         
32. }  
33.   
34. //刷新region，再根据需要执行compact或者split  
35. MemStoreFlusher#flushRegion() {  
36.     FlushRegionEntry fqe = this.regionsInQueue.remove(region);  
37.     flushQueue.remove(fqe);  
38.     boolean shouldCompact = HRegion.flushcache();  
39.     // We just want to check the size  
40.     boolean shouldSplit = HRegion.checkSplit() != null;  
41.     if (shouldSplit) {  
42.         HRegionServer.compactSplitThread.requestSplit(region);  
43.     } else if (shouldCompact) {  
44.         HRegionServer.compactSplitThread.requestCompaction(region, getName());  
45.     }         
46. }  

 

 

 

 

 

LruBlockCache

HBase上Regionserver的内存分为两个部分，一部分作为Memstore，主要用来写；另外一部分作为BlockCache，主要用于读。

写请求会先写入Memstore，Regionserver会给每个region提供一个Memstore，当Memstore满64MB以后，会启动 flush刷新到磁盘。当Memstore的总大小超过限制时（heapsize * hbase.regionserver.global.memstore.upperLimit * 0.9），会强行启动flush进程，从最大的Memstore开始flush直到低于限制。

读请求先到Memstore中查数据，查不到就到BlockCache中查，再查不到就会到磁盘上读，并把读的结果放入BlockCache。由于BlockCache采用的是LRU策略，因此BlockCache达到上限(heapsize * hfile.block.cache.size * 0.85)后，会启动淘汰机制，淘汰掉最老的一批数据。

一个Regionserver上有一个BlockCache和N个Memstore，它们的大小之和不能大于等于heapsize * 0.8，否则HBase不能正常启动。

默认配置下，BlockCache为0.2，而Memstore为0.4。在注重读响应时间的应用场景下，可以将 BlockCache设置大些，Memstore设置小些，以加大缓存的命中率。

 

HBase RegionServer包含三个级别的Block优先级队列：

Single：如果一个Block第一次被访问，则放在这一优先级队列中；

Multi：如果一个Block被多次访问，则从Single队列移到Multi队列中；

InMemory：如果一个Block是inMemory的，则放到这个队列中。

以上将Cache分级思想的好处在于：

首先，通过inMemory类型Cache，可以有选择地将in-memory的column families放到RegionServer内存中，例如Meta元数据信息；

通过区分Single和Multi类型Cache，可以防止由于Scan操作带来的Cache频繁颠簸，将最少使用的Block加入到淘汰算法中。

默认配置下，对于整个BlockCache的内存，又按照以下百分比分配给Single、Multi、InMemory使用：0.25、0.50和0.25。

注意，其中InMemory队列用于保存HBase Meta表元数据信息，因此如果将数据量很大的用户表设置为InMemory的话，可能会导致Meta表缓存失效，进而对整个集群的性能产生影响。

 

主要逻辑如下:

1. //用于cache block的类  
2. LruBlockCache#构造函数() {  
3.     map = new ConcurrentHashMap<BlockCacheKey,CachedBlock>(mapInitialSize,  
4.         mapLoadFactor, mapConcurrencyLevel);  
5.     this.minFactor = minFactor;  
6.     this.acceptableFactor = acceptableFactor;  
7.     this.singleFactor = singleFactor;  
8.     this.multiFactor = multiFactor;  
9.     this.memoryFactor = memoryFactor;  
10.     this.stats = new CacheStats();  
11.     this.count = new AtomicLong(0);  
12.     this.elements = new AtomicLong(0);  
13.     this.overhead = calculateOverhead(maxSize, blockSize, mapConcurrencyLevel);  
14.     this.size = new AtomicLong(this.overhead);  
15.     if(evictionThread) {  
16.         this.evictionThread = new EvictionThread(this);  
17.         this.evictionThread.start(); // FindBugs SC_START_IN_CTOR  
18.     } else {  
19.         this.evictionThread = null;  
20.     }  
21.     this.scheduleThreadPool.scheduleAtFixedRate(new StatisticsThread(this),  
22.         statThreadPeriod, statThreadPeriod, TimeUnit.SECONDS);    
23. }  
24.   
25. //这里假设不会对同一个已经被缓存的BlockCacheKey重复放入cache操作  
26. //根据inMemory标志创建不同类别的CachedBlock对象：若inMemory为true则创建BlockPriority.MEMORY类型，  
27. //否则创建BlockPriority.SINGLE；注意，这里只有这两种类型的Cache，因为BlockPriority.MULTI  
28. //在Cache Block被重复访问时才进行创建  
29. LruBlockCache#cacheBlock() {  
30.     CachedBlock cb = map.get(cacheKey);  
31.     if(cb != null) {  
32.         throw new RuntimeException("Cached an already cached block");  
33.     }  
34.     cb = new CachedBlock(cacheKey, buf, count.incrementAndGet(), inMemory);  
35.     long newSize = updateSizeMetrics(cb, false);  
36.     map.put(cacheKey, cb);  
37.     elements.incrementAndGet();  
38.     if(newSize > acceptableSize() && !evictionInProgress) {  
39.         runEviction();  
40.     }  
41. }  
42.   
43. class CachedBlock() {  
44.     static enum BlockPriority {  
45.         //如果一个Block第一次被访问，则放在这一优先级队列中  
46.         SINGLE,  
47.         //如果一个Block被多次访问，则从Single队列移到Multi队列中  
48.         MULTI,  
49.         //如果一个Block是inMemory的，则放到这个队列中  
50.         MEMORY  
51.     };    
52.       
53.     //多次访问后才设置MULTI类型  
54.     public void access(long accessTime) {  
55.         this.accessTime = accessTime;  
56.         if(this.priority == BlockPriority.SINGLE) {  
57.             this.priority = BlockPriority.MULTI;  
58.         }  
59.     }     
60. }  
61.   
62.   
63. //在单独的线程中运行  
64. LruBlockCache#run() {  
65.     this.wait();  
66.     LruBlockCache cache = this.cache.get();  
67.     if(cache == null) {  
68.         break;  
69.     }  
70.     cache.evict();  
71. }  
72.   
73. //最核心的驱逐函数  
74. LruBlockCache#evict() {  
75.     //计算得到当前Block Cache总大小currentSize及需要被淘汰释放掉的  
76.     //大小bytesToFree，如果bytesToFree小于等于0则不进行后续操作  
77.     long currentSize = this.size.get();  
78.     long bytesToFree = currentSize - minSize();  
79.     if(bytesToFree <= 0) {  
80.         return;  
81.     }  
82.       
83.     //初始化创建三个BlockBucket队列，分别用于存放Single、Multi和InMemory类Block Cache  
84.     //其中每个BlockBucket维护了一个CachedBlockQueue，按  
85.     //LRU淘汰算法维护该BlockBucket中的所有CachedBlock对象  
86.     BlockBucket bucketSingle = new BlockBucket(bytesToFree, blockSize,  
87.           singleSize());  
88.     BlockBucket bucketMulti = new BlockBucket(bytesToFree, blockSize,  
89.           multiSize());  
90.     BlockBucket bucketMemory = new BlockBucket(bytesToFree, blockSize,  
91.           memorySize());  
92.   
93.     //遍历记录所有Block Cache的全局ConcurrentHashMap，加入到相应的BlockBucket队列中  
94.     for(CachedBlock cachedBlock : map.values()) {  
95.         switch(cachedBlock.getPriority()) {  
96.           case SINGLE: {  
97.             bucketSingle.add(cachedBlock);  
98.             break;  
99.           }  
100.           case MULTI: {  
101.             bucketMulti.add(cachedBlock);  
102.             break;  
103.           }  
104.           case MEMORY: {  
105.             bucketMemory.add(cachedBlock);  
106.             break;  
107.           }  
108.         }  
109.     }//end for  
110.       
111.     //将以上三个BlockBucket队列加入到一个优先级队列中，按照各个BlockBucket  
112.     //超出bucketSize的大小顺序排序(BlockBucket的compareTo函数)  
113.     PriorityQueue<BlockBucket> bucketQueue =  
114.         new PriorityQueue<BlockBucket>(3);  
115.     bucketQueue.add(bucketSingle);  
116.     bucketQueue.add(bucketMulti);  
117.     bucketQueue.add(bucketMemory);  
118.     int remainingBuckets = 3;  
119.     long bytesFreed = 0;  
120.     BlockBucket bucket;  
121.       
122.     //遍历优先级队列，对于每个BlockBucket，通过Math.min(overflow, (bytesToFree - bytesFreed) / remainingBuckets)  
123.     //计算出需要释放的空间大小这样做可以保证尽可能平均地从三个BlockBucket中释放指定的空间  
124.     while((bucket = bucketQueue.poll()) != null) {  
125.         long overflow = bucket.overflow();  
126.         if(overflow > 0) {  
127.             long bucketBytesToFree = Math.min(overflow,  
128.             (bytesToFree - bytesFreed) / remainingBuckets);  
129.             //释放空间  
130.             bytesFreed += bucket.free(bucketBytesToFree);  
131.         }  
132.         remainingBuckets--;  
133.     }     
134. }  
135.   
136. //从其CachedBlockQueue中取出即将被淘汰掉的CachedBlock对象  
137. LruBlockCache#free() {  
138.     CachedBlock cb;  
139.     long freedBytes = 0;  
140.     while ((cb = queue.pollLast()) != null) {  
141.         freedBytes += evictBlock(cb);  
142.         if (freedBytes >= toFree) {  
143.             return freedBytes;  
144.         }  
145.     }     
146. }  
147.   
148. //从map中移除数据并更新metrics信息  
149. LruBlockCache#evictBlock() {  
150.     map.remove(block.getCacheKey());  
151.     updateSizeMetrics(block, true);  
152.     elements.decrementAndGet();  
153.     stats.evicted();  
154.     return block.heapSize();      
155. }  

 

 

 

 

 

类图

block cache相关类图如下

 

 

 

 

 

参考

HBase上关于CMS、GC碎片、大缓存的一种解决方案：Bucket Cache 

HBase的Block Cache实现机制分析

memstore的flush流程分析

hbase定时memflush PeriodicMemstoreFlusher

MemStoreChunkPool&MSLAB提升HBASE GC性能