DataNode引用计数磁盘选择策略

前言

在HDFS中,所有的数据都是存在各个DataNode上的.而这些DataNode上的数据都是存放于节点机器上的各个目录中的,而一般每个目录我们会对应到1个独立的盘,以便我们把机器的存储空间基本用上.这么多的节点,这么多块盘,HDFS在进行写操作时如何进行有效的磁盘选择呢,选择不当必然造成写性能下降,从而影响集群整体的性能.本文来讨论一下目前HDFS中存在的几个磁盘选择策略的特点和不足,然后针对其不足,自定义1个新的磁盘选择策略.

HDFS现有磁盘选择策略

上文前言中提到,随着节点数的扩增,磁盘数也会跟着线性变化,这么的磁盘,会造成1个问题,数据不均衡现象,这个是最容易发生的.原因可能有下面2个:

1.HDFS写操作不当导致.

2.新老机器上线使用时间不同,造成新机器数据少,老机器数据多的问题.

第二点这个通过Balancer操作可以解决.第一个问题才是最根本的,为了解决磁盘数据空间不均衡的现象,HDFS目前的2套磁盘选择策略都是围绕着"数据均衡"的目标设计的.下面介绍这2个磁盘选择策略.

一.RoundRobinVolumeChoosingPolicy

上面这个比较长的类名称可以拆成2个单词,RoundRobin和VolumeChoosingPolicy,VolumeChoosingPolicy理解为磁盘选择策略,RoundRobin这个是一个专业术语,叫做"轮询",类似的还有一些别的类似的术语,Round-Robin Scheduling(轮询调度),Round-Robin 算法等.RoundRobin轮询的意思用最简单的方式翻译就是一个一个的去遍历,到尾巴了,再从头开始.下面是一张解释图:

下面给出在HDFS中他的核心代码如下,我加了注释上去,帮助大家理解:

[java] view plain copy

 print?

1. /** 
2.  * Choose volumes in round-robin order. 
3.  */  
4. public class RoundRobinVolumeChoosingPolicy<V extends FsVolumeSpi>  
5.     implements VolumeChoosingPolicy<V> {  
6.   public static final Log LOG = LogFactory.getLog(RoundRobinVolumeChoosingPolicy.class);  
7.   
8.   private int curVolume = 0;  
9.   
10.   @Override  
11.   public synchronized V chooseVolume(final List<V> volumes, long blockSize)  
12.       throws IOException {  
13.   
14.     //如果磁盘数目小于1个,则抛异常  
15.     if(volumes.size() < 1) {  
16.       throw new DiskOutOfSpaceException("No more available volumes");  
17.     }  
18.       
19.     //如果由于失败磁盘导致当前磁盘下标越界了,则将下标置为0  
20.     // since volumes could've been removed because of the failure  
21.     // make sure we are not out of bounds  
22.     if(curVolume >= volumes.size()) {  
23.       curVolume = 0;  
24.     }  
25.       
26.     //赋值开始下标  
27.     int startVolume = curVolume;  
28.     long maxAvailable = 0;  
29.       
30.     while (true) {  
31.       //获取当前所下标所代表的磁盘  
32.       final V volume = volumes.get(curVolume);  
33.       //下标递增  
34.       curVolume = (curVolume + 1) % volumes.size();  
35.       //获取当前选中磁盘的可用剩余空间  
36.       long availableVolumeSize = volume.getAvailable();  
37.       //如果可用空间满足所需要的副本块大小,则直接返回这块盘  
38.       if (availableVolumeSize > blockSize) {  
39.         return volume;  
40.       }  
41.         
42.       //更新最大可用空间值  
43.       if (availableVolumeSize > maxAvailable) {  
44.         maxAvailable = availableVolumeSize;  
45.       }  
46.         
47.       //如果当前指标又回到了起始下标位置,说明已经遍历完整个磁盘列  
48.       //没有找到符合可用空间要求的磁盘  
49.       if (curVolume == startVolume) {  
50.         throw new DiskOutOfSpaceException("Out of space: "  
51.             + "The volume with the most available space (=" + maxAvailable  
52.             + " B) is less than the block size (=" + blockSize + " B).");  
53.       }  
54.     }  
55.   }  
56. }  

理论上来说这种策略是蛮符合数据均衡的目标的,因为一个个的写吗,每块盘写入的次数都差不多,不存在哪块盘多写少写的现象,但是唯一的不足之处在于每次写入的数据量是无法控制的,可能我某次操作在A盘上写入了512字节的数据,在轮到B盘写的时候我写了128M的数据,数据就不均衡了,所以说轮询策略在某种程度上来说是理论上均衡但还不是最好的.更好的是下面这种.

二.AvailableSpaceVolumeChoosingPolicy

剩余可用空间磁盘选择策略.这个磁盘选择策略比第一种设计的就精妙很多了,首选他根据1个阈值,将所有的磁盘分为了2大类,高可用空间磁盘列表和低可用空间磁盘列表.然后通过1个随机数概率,会比较高概率下选择高剩余磁盘列表中的块,然后对这些磁盘列表进行轮询策略的选择,下面是相关代码:

[java] view plain copy

 print?

1. /** 
2.  * A DN volume choosing policy which takes into account the amount of free 
3.  * space on each of the available volumes when considering where to assign a 
4.  * new replica allocation. By default this policy prefers assigning replicas to 
5.  * those volumes with more available free space, so as to over time balance the 
6.  * available space of all the volumes within a DN. 
7.  */  
8. public class AvailableSpaceVolumeChoosingPolicy<V extends FsVolumeSpi>  
9.     implements VolumeChoosingPolicy<V>, Configurable {  
10.     
11.   ...  
12.   //用于一般的需要平衡磁盘的轮询磁盘选择策略  
13.   private final VolumeChoosingPolicy<V> roundRobinPolicyBalanced =  
14.       new RoundRobinVolumeChoosingPolicy<V>();  
15.   //用于可用空间高的磁盘的轮询磁盘选择策略  
16.   private final VolumeChoosingPolicy<V> roundRobinPolicyHighAvailable =  
17.       new RoundRobinVolumeChoosingPolicy<V>();  
18.   //用于可用空间低的剩余磁盘的轮询磁盘选择策略  
19.   private final VolumeChoosingPolicy<V> roundRobinPolicyLowAvailable =  
20.       new RoundRobinVolumeChoosingPolicy<V>();  
21.   
22.   @Override  
23.   public synchronized V chooseVolume(List<V> volumes,  
24.       long replicaSize) throws IOException {  
25.     if (volumes.size() < 1) {  
26.       throw new DiskOutOfSpaceException("No more available volumes");  
27.     }  
28.       
29.     //获取所有磁盘包装列表对象  
30.     AvailableSpaceVolumeList volumesWithSpaces =  
31.         new AvailableSpaceVolumeList(volumes);  
32.       
33.     //如果所有的磁盘在数据平衡阈值之内,则在所有的磁盘块中直接进行轮询选择  
34.     if (volumesWithSpaces.areAllVolumesWithinFreeSpaceThreshold()) {  
35.       // If they're actually not too far out of whack, fall back on pure round  
36.       // robin.  
37.       V volume = roundRobinPolicyBalanced.chooseVolume(volumes, replicaSize);  
38.       if (LOG.isDebugEnabled()) {  
39.         LOG.debug("All volumes are within the configured free space balance " +  
40.             "threshold. Selecting " + volume + " for write of block size " +  
41.             replicaSize);  
42.       }  
43.       return volume;  
44.     } else {  
45.       V volume = null;  
46.       // If none of the volumes with low free space have enough space for the  
47.       // replica, always try to choose a volume with a lot of free space.  
48.       //如果存在数据不均衡的现象,则从低剩余空间磁盘块中选出可用空间最大值  
49.       long mostAvailableAmongLowVolumes = volumesWithSpaces  
50.           .getMostAvailableSpaceAmongVolumesWithLowAvailableSpace();  
51.         
52.       //得到高可用空间磁盘列表  
53.       List<V> highAvailableVolumes = extractVolumesFromPairs(  
54.           volumesWithSpaces.getVolumesWithHighAvailableSpace());  
55.       //得到低可用空间磁盘列表  
56.       List<V> lowAvailableVolumes = extractVolumesFromPairs(  
57.           volumesWithSpaces.getVolumesWithLowAvailableSpace());  
58.         
59.       float preferencePercentScaler =  
60.           (highAvailableVolumes.size() * balancedPreferencePercent) +  
61.           (lowAvailableVolumes.size() * (1 - balancedPreferencePercent));  
62.       //计算平衡比值,balancedPreferencePercent越大,highAvailableVolumes.size()所占的值会变大  
63.       //整个比例值也会变大,就会有更高的随机概率在这个值下  
64.       float scaledPreferencePercent =  
65.           (highAvailableVolumes.size() * balancedPreferencePercent) /  
66.           preferencePercentScaler;  
67.       //如果低可用空间磁盘列表中最大的可用空间无法满足副本大小  
68.       //或随机概率小于比例值,就在高可用空间磁盘中进行轮询调度选择  
69.       if (mostAvailableAmongLowVolumes < replicaSize ||  
70.           random.nextFloat() < scaledPreferencePercent) {  
71.         volume = roundRobinPolicyHighAvailable.chooseVolume(  
72.             highAvailableVolumes, replicaSize);  
73.         if (LOG.isDebugEnabled()) {  
74.           LOG.debug("Volumes are imbalanced. Selecting " + volume +  
75.               " from high available space volumes for write of block size "  
76.               + replicaSize);  
77.         }  
78.       } else {  
79.         //否则在低磁盘空间列表中选择磁盘  
80.         volume = roundRobinPolicyLowAvailable.chooseVolume(  
81.             lowAvailableVolumes, replicaSize);  
82.         if (LOG.isDebugEnabled()) {  
83.           LOG.debug("Volumes are imbalanced. Selecting " + volume +  
84.               " from low available space volumes for write of block size "  
85.               + replicaSize);  
86.         }  
87.       }  
88.       return volume;  
89.     }  
90.   }  

低剩余空间磁盘和高剩余空间磁盘的标准是这样定义的:

[java] view plain copy

 print?

1. /** 
2.      * @return the list of volumes with relatively low available space. 
3.      */  
4.     public List<AvailableSpaceVolumePair> getVolumesWithLowAvailableSpace() {  
5.       long leastAvailable = getLeastAvailableSpace();  
6.       List<AvailableSpaceVolumePair> ret = new ArrayList<AvailableSpaceVolumePair>();  
7.       for (AvailableSpaceVolumePair volume : volumes) {  
8.         //可用空间小于最小空间与平衡空间阈值的和的磁盘加入低磁盘空间列表  
9.         if (volume.getAvailable() <= leastAvailable + balancedSpaceThreshold) {  
10.           ret.add(volume);  
11.         }  
12.       }  
13.       return ret;  
14.     }  
15.       
16.     /** 
17.      * @return the list of volumes with a lot of available space. 
18.      */  
19.     public List<AvailableSpaceVolumePair> getVolumesWithHighAvailableSpace() {  
20.       long leastAvailable = getLeastAvailableSpace();  
21.       List<AvailableSpaceVolumePair> ret = new ArrayList<AvailableSpaceVolumePair>();  
22.       for (AvailableSpaceVolumePair volume : volumes) {  
23.         //高剩余空间磁盘选择条件与上面相反  
24.         if (volume.getAvailable() > leastAvailable + balancedSpaceThreshold) {  
25.           ret.add(volume);  
26.         }  
27.       }  
28.       return ret;  
29.     }  

现有HDFS磁盘选择策略的不足

OK,我们已经了解了HDFS目前存在的2种磁盘选择策略,我们看看HDFS在使用这些策略的是不是就是完美的呢,答案显然不是,下面是我总结出的2点不足之处.

1.HDFS的默认磁盘选择策略是RoundRobinVolumeChoosingPolicy,而不是更优的AvailableSpaceVolumeChoosingPolicy,我猜测的原因估计是AvailableSpaceVolumeChoosingPolicy是后来才有的,但是默认值的选择没有改,依然是老的策略.

2.磁盘选择策略考虑的因素过于单一,磁盘可用空间只是其中1个因素,其实还有别的指标比如这个块目前的IO情况,如果正在执行许多读写操作的时候,我们当然希望找没有进行任何操作的磁盘进行数据写入,否则只会更加影响当前磁盘的写入速度,这个维度也是下面我自定义的新的磁盘选择策略的1个根本需求点.

自定义磁盘选择策略之ReferenceCountVolumeChoosingPolicy

新的磁盘选择策略的根本依赖点在于ReferenceCount,引用计数,他能让你了解有多少对象正在操作你,引用计数在很多地方都有用到,比如jvm中通过引用计数,判断是否进行垃圾回收.在磁盘相关类FsVolume中也有类似的1个变量,刚好可以满足我们的需求,如下:

[java] view plain copy

 print?

1. /** 
2.  * The underlying volume used to store replica. 
3.  *  
4.  * It uses the {@link FsDatasetImpl} object for synchronization. 
5.  */  
6. @InterfaceAudience.Private  
7. @VisibleForTesting  
8. public class FsVolumeImpl implements FsVolumeSpi {  
9.   ...  
10.   private CloseableReferenceCount reference = new CloseableReferenceCount();  

然后我们需要将此变量值开放出去,便于我们调用.

[java] view plain copy

 print?

1. @Override  
2. public int getReferenceCount() {  
3.   return this.reference.getReferenceCount();  
4. }  

然后模仿AvailableSpaceVolumeChoosingPolicy策略进行选择,核心代码如下:

[java] view plain copy

 print?

1. @Override  
2.   public synchronized V chooseVolume(final List<V> volumes, long blockSize)  
3.       throws IOException {  
4.   
5.     if (volumes.size() < 1) {  
6.       throw new DiskOutOfSpaceException("No more available volumes");  
7.     }  
8.   
9.     V volume = null;  
10.   
11.     //获取当前磁盘中被引用次数最少的1块盘  
12.     int minReferenceCount = getMinReferenceCountOfVolumes(volumes);  
13.     //根据最少引用次数以及引用计数临界值得到低引用计数磁盘列表  
14.     List<V> lowReferencesVolumes =  
15.         getLowReferencesCountVolume(volumes, minReferenceCount);  
16.     //根据最少引用次数以及引用计数临界值得到高引用计数磁盘列表  
17.     List<V> highReferencesVolumes =  
18.         getHighReferencesCountVolume(volumes, minReferenceCount);  
19.   
20.     //判断低引用磁盘列表中是否存在满足要求块大小的磁盘,如果有优选从低磁盘中进行轮询磁盘的选择  
21.     if (isExistVolumeHasFreeSpaceForBlock(lowReferencesVolumes, blockSize)) {  
22.       volume =  
23.           roundRobinPolicyLowReferences.chooseVolume(lowReferencesVolumes,  
24.               blockSize);  
25.     } else {  
26.       //如果低磁盘块中没有可用空间的块,则再从高引用计数的磁盘列表中进行磁盘的选择  
27.       volume =  
28.           roundRobinPolicyHighReferences.chooseVolume(highReferencesVolumes,  
29.               blockSize);  
30.     }  
31.   
32.     return volume;  
33.   }  

附上相应的单元测试,测试已经通过

[java] view plain copy

 print?

1. @Test  
2.   public void testReferenceCountVolumeChoosingPolicy() throws Exception {  
3.     @SuppressWarnings("unchecked")  
4.     final ReferenceCountVolumeChoosingPolicy<FsVolumeSpi> policy =  
5.         ReflectionUtils.newInstance(ReferenceCountVolumeChoosingPolicy.class,  
6.             null);  
7.   
8.     initPolicy(policy);  
9.     final List<FsVolumeSpi> volumes = new ArrayList<FsVolumeSpi>();  
10.   
11.     // Add two low references count volumes.  
12.     // First volume, with 1 reference.  
13.     volumes.add(Mockito.mock(FsVolumeSpi.class));  
14.     Mockito.when(volumes.get(0).getReferenceCount()).thenReturn(1);  
15.     Mockito.when(volumes.get(0).getAvailable()).thenReturn(100L);  
16.   
17.     // First volume, with 2 references.  
18.     volumes.add(Mockito.mock(FsVolumeSpi.class));  
19.     Mockito.when(volumes.get(1).getReferenceCount()).thenReturn(2);  
20.     Mockito.when(volumes.get(1).getAvailable()).thenReturn(100L);  
21.   
22.     // Add two high references count volumes.  
23.     // First volume, with 4 references.  
24.     volumes.add(Mockito.mock(FsVolumeSpi.class));  
25.     Mockito.when(volumes.get(2).getReferenceCount()).thenReturn(4);  
26.     Mockito.when(volumes.get(2).getAvailable()).thenReturn(100L);  
27.   
28.     // First volume, with 5 references.  
29.     volumes.add(Mockito.mock(FsVolumeSpi.class));  
30.     Mockito.when(volumes.get(3).getReferenceCount()).thenReturn(5);  
31.     Mockito.when(volumes.get(3).getAvailable()).thenReturn(100L);  
32.   
33.     // initPolicy(policy, 1.0f);  
34.     Assert.assertEquals(volumes.get(0), policy.chooseVolume(volumes, 50));  
35.   
36.     volumes.clear();  
37.   
38.     // Test when the low-references volumes has not enough available space for  
39.     // block  
40.     // First volume, with 1 reference.  
41.     volumes.add(Mockito.mock(FsVolumeSpi.class));  
42.     Mockito.when(volumes.get(0).getReferenceCount()).thenReturn(1);  
43.     Mockito.when(volumes.get(0).getAvailable()).thenReturn(50L);  
44.   
45.     // First volume, with 2 references.  
46.     volumes.add(Mockito.mock(FsVolumeSpi.class));  
47.     Mockito.when(volumes.get(1).getReferenceCount()).thenReturn(2);  
48.     Mockito.when(volumes.get(1).getAvailable()).thenReturn(50L);  
49.   
50.     // Add two high references count volumes.  
51.     // First volume, with 4 references.  
52.     volumes.add(Mockito.mock(FsVolumeSpi.class));  
53.     Mockito.when(volumes.get(2).getReferenceCount()).thenReturn(4);  
54.     Mockito.when(volumes.get(2).getAvailable()).thenReturn(200L);  
55.   
56.     // First volume, with 5 references.  
57.     volumes.add(Mockito.mock(FsVolumeSpi.class));  
58.     Mockito.when(volumes.get(3).getReferenceCount()).thenReturn(5);  
59.     Mockito.when(volumes.get(3).getAvailable()).thenReturn(200L);  
60.   
61.     Assert.assertEquals(volumes.get(2), policy.chooseVolume(volumes, 100));  
62.   }  

我在代码注释中已经进行了很详细的分析了,这里就不多说了.

总结

当然根据引用计数的磁盘选择策略也不见得是最好的,因为这里忽略了磁盘间数据不均衡的问题,显然这个弊端会慢慢凸显出来,所以说你很难做到1个策略是绝对完美的,可能最好的办法是根据用户使用场景使用最合适的磁盘选择策略,或者定期更换策略以此达到最佳的效果.引用计数磁盘选择策略的相关代码可以从我的github patch链接中查阅,学习.

原文地址：http://blog.csdn.net/androidlushangderen/article/details/50531760

感谢作者 Android路上的人 分享