精华内容
下载资源
问答
  • Crush算法

    2019-08-14 22:47:09
    Crush算法

    Crush算法

    展开全文
  • CRUSH算法

    2016-11-17 22:48:12
    CRUSH算法

    原链接

    http://blog.csdn.net/litianze99/article/details/50611414


    ceph计算数据分布的过程:

    //要存储的文件对象
    file=data.txt
    //将文件切分成多个除最后一个外的等大的小对象
    objects = splits(file)
    for (i = 0; i < length(objects); i++)
    {
        //获取对象的哈希值
        obj_hash_value = hash(objects[i])
        //用对象的哈希值对pg_num取模,获取对应的pg_id
        pg_id = obj_hash_value % pg_num
        //通过crush算法计算该pg对应的一组osds
        osds = crush(pg_id...)
    }
    注:file-map->objects-map->pg-map->osd,pg是虚拟的概念,不会因为硬件的变化而变化。
    ceph CRUSH中的层级结构:
    http://way4ever.com/?p=122


    展开全文
  • Ceph的CRUSH算法原理

    2014-01-18 12:58:38
    Ceph的CRUSH算法原理
  • crushmap就相当于是ceph集群的一张数据分布地图,crush算法通过该地图可以知道数据应该如何分布;找到数据存放位置从而直接与对应的osd进行数据访问和写入;故障域的设置和数据冗余选择策略等。crushmap的灵活设置...

    1 什么是crushmap

    crushmap就相当于是ceph集群的一张数据分布地图,crush算法通过该地图可以知道数据应该如何分布;找到数据存放位置从而直接与对应的osd进行数据访问和写入;故障域的设置和数据冗余选择策略等。crushmap的灵活设置显示出了ceph的软件定义存储方案。
    这里可以引入raid相关的概念来对比下:
    raid0:又称为Stripe,中文名为条带,它是所有RAID级别中存储性能最高的,它的原理就是把连续的数据分散存储到多个磁盘中,充分利用了每个磁盘的吞吐,突破了单个磁盘的吞吐限制。
    raid1:又称为Mirror,中文名为镜像,它的主要宗旨是保证用户的数据可用性和可修复性,它的原理是把用户写入硬盘的数据百分之百的自动复制到另外一个磁盘上。
    raid10:高可靠性与高效磁盘结构,可以理解为raid0和raid1的互补结合,类似于ceph中的多副本策略。
    raid5:是一种存储性能、存储成本和数据安全都兼顾的一种方案,它的原理是不对存储的数据进行备份,而是把数据和存储校验信息存储到组成raid5的各个磁盘上,当raid5的一个磁盘损坏时,可以根据剩下的数据和奇偶校验信息来恢复损坏的数据,类似于ceph中的纠删码策略。

    对导出的crushmap进行反编译后得到的内容如下:

    # begin crush map 选择存放副本位置时的选择算法策略中的变量配置
    tunable choose_local_tries 0
    tunable choose_local_fallback_tries 0
    tunable choose_total_tries 50
    tunable chooseleaf_descend_once 1
    tunable straw_calc_version 1
    
    # devices    一般指的是叶子节点osd
    device 0 osd.0
    device 1 osd.1
    device 2 osd.2
    
    # types    树形下的多种类型
    type 0 osd    # 一般一个osd对应一个磁盘
    type 1 host    # 一般host表示是一个主机,即某一台服务器 
    type 2 chassis # 系列
    type 3 rack # 机架
    type 4 row # 排
    type 5 pdu # 
    type 6 pod    # 
    type 7 room # 机房
    type 8 datacenter    # 数据中心
    type 9 region    # 区域
    type 10 root    # 根
    
    # buckets    躯干部分 host一般是表示一个物理节点,root是树形的根部
    host thinstack-test0 {
    id -2    # do not change unnecessarily
    # weight 0.031
    alg straw # ceph作者实现的选择item的算法
    hash 0    # rjenkins1 这代表的是使用哪个hash算法,0表示选择rjenkins1这种hash算法
    item osd.0 weight 0.031
    }
    host thinstack-test1 {
    id -3    # do not change unnecessarily
    # weight 0.031
    alg straw
    hash 0    # rjenkins1
    item osd.1 weight 0.031
    }
    host thinstack-test2 {
    id -4    # do not change unnecessarily
    # weight 0.031
    alg straw
    hash 0    # rjenkins1
    item osd.2 weight 0.031
    }
    root default {
    id -1    # do not change unnecessarily
    # weight 0.094
    alg straw
    hash 0    # rjenkins1
    item thinstack-test0 weight 0.031
    item thinstack-test1 weight 0.031
    item thinstack-test2 weight 0.031
    }
    
    # rules    副本选取规则的设定
    rule replicated_ruleset {
    ruleset 0
    type replicated
    min_size 1
    max_size 10
    step take default    # 以default root为入口
    step chooseleaf firstn 0 type host    # 看如下 解释1
    step emit    # 提交
    }
    
    # end crush map
    
    解释1:
    step chooseleaf firstn {num} type {bucket-type}
    chooseleaf表示选择bucket-type的bucket并选择其的叶子节点(osd)
    当num等于0时:表示选择副本数量个bucket
    当num > 0 and num < 副本数量时:表示选择num个bucket
    当num < 0: 表示选择 副本数量 - num 个bucket

     

    2 crush的基本原理

    常用的分布式数据分布算法有一致性Hash算法和Crush算法,Crush也称为可扩展的伪随机数据分布算法
    一致性Hash算法原理:
    对一个圆形(圆形可以是0-2的31次方-1)用n个虚拟节点将其划分成n个区域,每个虚拟节点管控一个范围,如下图所示:

    T0负责[A, B],T1负责[B, C],T2负责[C,D],T3负责[D,A]
    由于分区是固定的,所以我们很容易知道哪些数据要迁移,哪些数据不需要迁移。
    在每个节点的存储容量相等且虚拟节点跟物理节点个数一致时,就会是每个节点对应一段相同大小的区段,从而可以达到最佳的数据分布。

    Crush算法原理:
    Crush算法跟一致性Hash算法原理很类似,其中的pg就是充当上面所说的虚拟节点的作用,用以分割区域,每个pg管理的数据区间相同,因而数据能够均匀的分布到pg上。

    crush分布数据过程:
    数据x经过hash函数得到一个值,将该值与pg数量取模得到数值,该数值即是pg的编号,然后通过crush算法知道pg是对应哪些osd的,最后是将数据存放到pg对应的osd上。其中经过了两次的映射,一次是数据到pg的映射,一次是pg到osd的映射,由于pg是抽象的存储节点,一般情况下,pg的数量是保持的不变的,不随着节点的增加或减少而改变,因此数据到pg的映射是稳定的。

     

    3 利用crushmap可以做哪些事

    (1)故障域的设置
    ceph中已经定义的故障域有:
    # types
    type 0 osd # 一般一个osd对应一个磁盘
    type 1 host # 一般host表示是一个主机,即某一台服务器
    type 2 chassis # 系列
    type 3 rack # 机架
    type 4 row # 排
    type 5 pdu #
    type 6 pod #
    type 7 room # 机房
    type 8 datacenter # 数据中心
    type 9 region # 区域
    type 10 root # 根
    当然也可以自定义类型
    比如有3台服务器,设置的故障域为host,数据冗余策略为多副本的2副本策略,则数据会保存到其中的两台服务器上,这样当其中一台服务器挂掉时,确保还有冗余数据在另外一台服务器上,保证了数据的可靠性。


    (2)指定数据存放到指定位置上
    比如对于一些私有云来说,可以划分ssd的磁盘用以存放镜像等数据,这样虚拟机启动会比较快,对于快照和备份等冷数据则可存放在sata盘中。


    (3)保证数据尽可能的均衡
    可以设定osd的权重,如果只考虑容量,则一般1T容量权重设为1.0


    (4)尽可能保证数据不会大量迁移引起性能问题
    当有节点故障时需要进行数据均衡时,可以设定合理的crushmap让数据的迁移只发生在一个小范围内

    4 crushmap实践

    (1)获取当前crushmap并修改和应用
    获取当前集群中应用的crushmap文件到一个文件中:ceph osd getcrushmap -o crushmap.txt
    上面导出的crushmap.txt是乱码的,需要进行反编译来查看:crushtool -d crushmap.txt -o crushmap-decompile
    此时就是文本形式了,可以在这个文件上修改,修改后进行编译:crushtool -c crushmap-decompile -o crushmap-compiled
    然后应用到集群中:ceph osd setcrushmap -i crushmap-compiled
    注意:这样修改如果想要服务重启后保持原来的,需要在配置文件的[osd]上加上:osd crush update on start = false,否则启动时会校验当前位置是否是正确的位置,如果不是则会自动移动到之前的位置

    如果只是想查看下当前的crush map分布,可以用命令行查看:ceph osd crush tree

    (2)命令行构建crush map
    <1>添加bucket:ceph osd crush add-bucket {bucket-name} {bucket-type}
    比如添加一个root类型的名为default的bucket:ceph osd crush add-bucket default root
    添加一个host类型的名为test1的bucket:ceph osd crush add-bucket test1 host

    <2>移动一个bucket:ceph osd crush move {bucket-name} {bucket-type}={bucket-name}, [...]
    比如我想将bucket1 test1移动到root类型的名为default2下:ceph osd crush move test1 root=default2

    <3>移除一个bucket:ceph osd crush remove {bucket-name}
    比如:ceph osd crush remove test1

    <4>添加或移动osd的crush map位置:ceph osd crush set {name} {weight} root={root} [{bucket-type}={bucket-name} ...]
    比如我将osd.1设置test1下:ceph osd crush set osd.1 1.0 root=default host=test1

    <5>调整osd的权重:ceph osd crush reweight {name} {weight}
    比如:ceph osd crush reweight osd.1 2.0

    <6>移除osd crush map:ceph osd crush remove {name}
    比如:ceph osd crush remove osd.1

    <7>创建一个副本策略:ceph osd crush rule create-replicated {name} {root} {failure-domain-type} [{class}] # 低版本没有这个,比如0.94.10就没有
    比如创建一个故障域级别为host的副本策略:ceph osd crush rule create-replicated rep_test default host
    自己项目中用的创建命令:ceph osd crush rule create-simple rep_test default host firstn # 原型是osd crush rule create-simple <name> <root> <type> {firstn|indep}

    <8>给pool指定副本策略:ceph osd pool set <pool-name> crush_rule <rule-name>
    比如:ceph osd pool set testpool crush_rule test_rule

    (3)创建指定主副本放在host A上,其它副本放在host B上

    # rules
    rule replicated_ruleset {
    ruleset 0
    type replicated
    min_size 1
    max_size 10
    step take A
    step chooseleaf firstn 1 type osd
    step emit
    
    step take B
    step chooseleaf firstn -1 type osd
    step emit
    }

    这时可以用ceph pg dump命令看pg的分布是否是如我们所想的那样分布。
    或者测试数据是否真的落到我们想要的osd上:
    put一个文件命名对象名为uuu到testpool中去:rados put uuu kk.txt -p volumes
    查看该对象是在哪个osd上:ceph osd map testpool uuu

    还有个简单的方法来设置某个osd作为主的,某个为副osd:
    假设只有osd.0和osd.1,要将osd.0作为副本osd,1作为主osd,则可以将osd.0的主亲和力设置为0,这样osd.0就只能做副本osd
    ceph tell mon.\* injectargs '--mon_osd_allow_primary_affinity=true'
    ceph osd primary-affinity osd.0 0

    (4)将ssd磁盘的osd用来放主副本,hdd磁盘的osd用来放副本
    思路:可以创建两个root类型,一个名为ssd,一个名为hdd,然后ssd磁盘的osd移到root=sdd下,hdd磁盘的osd移到root=hdd下,crushmap内容如下:

    # begin crush map
    tunable choose_local_tries 0
    tunable choose_local_fallback_tries 0
    tunable choose_total_tries 50
    tunable chooseleaf_descend_once 1
    tunable straw_calc_version 1
    
    # devices
    device 0 osd.0
    device 1 osd.1
    
    # types
    type 0 osd
    type 1 host
    type 2 chassis
    type 3 rack
    type 4 row
    type 5 pdu
    type 6 pod
    type 7 room
    type 8 datacenter
    type 9 region
    type 10 root
    
    # buckets
    host A {
    id -2    # do not change unnecessarily
    # weight 0.031
    alg straw
    hash 0    # rjenkins1
    item osd.0 weight 0.031
    }
    host B {
    id -3    # do not change unnecessarily
    # weight 0.031
    alg straw
    hash 0    # rjenkins1
    item osd.1 weight 0.031
    }
    root ssd {
    id -5    # do not change unnecessarily
    # weight 0.031
    alg straw
    hash 0    # rjenkins1
    item A weight 0.031
    }
    root hdd {
    id -6    # do not change unnecessarily
    # weight 0.031
    alg straw
    hash 0    # rjenkins1
    item B weight 0.031
    }
    
    # rules
    rule replicated_ruleset {
    ruleset 0
    type replicated
    min_size 1
    max_size 10
    step take ssd
    step chooseleaf firstn 1 type host
    step emit
    
    step take hdd
    step chooseleaf firstn -1 type host
    step emit
    }
    
    # end crush map

    ceph osd tree的命令执行如下:

    [root@test ~]# ceph osd tree
    ID WEIGHT  TYPE NAME                UP/DOWN REWEIGHT PRIMARY-AFFINITY 
    -6 0.03099 root hdd                                                   
    -3 0.03099     host thinstack-test1                                   
     1 0.03099         osd.1                 up  1.00000          1.00000 
    -5 0.03099 root ssd                                                   
    -2 0.03099     host thinstack-test0                                   
     0 0.03099         osd.0                 up  1.00000          1.00000

    转载于:https://www.cnblogs.com/luohaixian/p/10329130.html

    展开全文
  • ceph crush算法分析

    2019-04-22 19:43:32
    (2)分布式算法,例如一致性哈希算法,如crush 算法步骤: 1、pool_id+hash(object_id)得到pg_id 2、针对每一个osd,通过同样的常量r,CRUSH_HASH(PG_ID, OSD_ID, r) 得出一个不同的随机数,然后使用自己的随机数与...

    数据分布算法
    (1)集中式的元数据查询,如hdfs
    (2)分布式算法,例如一致性哈希算法,如crush

    CRUSH算法步骤:
    1、pool_id+hash(object_id)得到pg_id
    2、针对每一个osd,通过同样的常量r,CRUSH_HASH(PG_ID, OSD_ID, r) 得出一个不同的随机数,然后使用自己的随机数与osd的weight相乘,得到draw,选出其中最大的draw值作为第一个osd;然后将常量r+1,对每一个osd再一次计算自己的随机数,然后使用自己的随机数与osd的weight相乘,得到draw,选出其中最大的draw值作为第二个osd;然后将常量r+2,对每一个osd再一次计算自己的随机数,然后使用自己的随机数与osd的weight相乘,得到draw,选出其中最大的draw值作为第三个osd。

    四种选择算法:
    1、Unique
    2、List
    3、Tree
    4、Straw(目前使用)

    crush算法源码分析:
    src\crush\CrushWrapper.h
    1、函数do_rule开始进行crush算法的处理,调用函数crush_do_rule

         void do_rule(int rule, int x, vector<int>& out, int maxout,
        	       const WeightVector& weight,
        	       uint64_t choose_args_index) const {
            int rawout[maxout];
            char work[crush_work_size(crush, maxout)];
            crush_init_workspace(crush, work);
            crush_choose_arg_map arg_map = choose_args_get_with_fallback(
              choose_args_index);
            // 调用函数crush_do_rule通过crush算法来找到合适的osd集合
            int numrep = crush_do_rule(crush, rule, x, rawout, maxout, &weight[0],
        			       weight.size(), work, arg_map.args);
            if (numrep < 0)
              numrep = 0;
            out.resize(numrep);
            for (int i=0; i<numrep; i++)
              out[i] = rawout[i];
          }
    

    \src\crush\mapper.c
    2、函数crush_do_rule根据给定的输入和rule计算出一个mapping。针对每一条rule中的操作类型,执行相应的设置和计算。这个过程就是根据step逐步选择bucket直到叶子节点,即OSD

    (1)、根据当前执行步骤的操作类型,选择不同的分支操作,首先一般是take操作,而且是take fault。即crush map树根节点。
    (2)、当rule的操作类型以下四种时:

            case CRUSH_RULE_CHOOSELEAF_FIRSTN:
        	case CRUSH_RULE_CHOOSE_FIRSTN:
        		firstn = 1;
        		/* fall through */
        	case CRUSH_RULE_CHOOSELEAF_INDEP:
        	case CRUSH_RULE_CHOOSE_INDEP:
    

    (3)、针对FIRSTN调用函数crush_choose_firstn计算mapping,传入的常量r为0;
    (4)、针对INDEP调用函数crush_choose_indep计算mapping,传入的常量r为0;

    3、通过函数crush_choose_firstn和crush_choose_indep进行位置选择:
    firstn: 适用于副本池,选择结果中rep(replica,指一份副本或者EC中的一个分块,下同)位置无明显意义
    indep: 适用于EC池,选择结果中rep位置不可随意变动
    举例来说,副本池中每份副本保存的是完全相同的数据,因此选择结果为[0, 1, 2](数字代表OSD编号)与[0, 2, 1]并无大的不同。但是EC池不一样,在2+1的配比下前两份是数据块,最后一份是校验块,后两份rep位置一交换就会导致数据出错。

    下面主要针对firstn的类型:
    4、函数crush_choose_firstn,目标是选出指定的numrep,type类型的节点,
    执行for循环,rep变量初始值为0,到rep等于numrep时跳出循环,每次rep加1。
    (1)、首先计算用于crush算法的常量值r,常量值r的取值由rep变量(从0开始,每次选取完一个osd则加1)+ ftotal(初始值0,每次选取结果不符合则加1)+ parent_r(从parent传递过来的值)【这里的传递的parent_r值都是0】
    (2)、调用函数crush_bucket_choose根据实际的crush算法(一般使用straw)来选出第一个符合的节点item;
    (3)、当!collide && recurse_to_leaf时,如果递归调用crush_choose_firstn函数找不到叶子节点,就去掉这个节点item,此时ftotal加1,回到步骤1;
    (4)、直到找到符合要求的numrep个节点,即完成for循环。

    5、函数crush_bucket_choose根据使用的是哪一种算法,找到对应算法的choose函数,这里以straw为例,会调用函数bucket_straw_choose。

        /* straw */
        
        static int bucket_straw_choose(const struct crush_bucket_straw *bucket,
        			       int x, int r)
        {
        	__u32 i;
        	int high = 0;
        	__u64 high_draw = 0;
        	__u64 draw;
        
        // 对于每一个节点,分别执行循环内容
        	for (i = 0; i < bucket->h.size; i++) {
               // 获得一个随机数
        		draw = crush_hash32_3(bucket->h.hash, x, bucket->h.items[i], r);
        		draw &= 0xffff;
               // 将随机数与节点的权重值相乘,得到签长
        		draw *= bucket->straws[i];
               // 保存签长最长的节点
        		if (i == 0 || draw > high_draw) {
        			high = i;
        			high_draw = draw;
        		}
        	}
        	return bucket->h.items[high];
        }
        // 返回签长最长的节点作为选取的节点
    

    crush算法应对情况一:osd.1挂掉,再回来
    当mapping中的osd挂掉,需要通过crush算法重新计算osd,此时即使是三个都重新计算,也应该只会是挂掉的osd.1被新的osd替换了。然后需要将pg的所有数据迁移到新的osd.3上去;当osd.1回来以后,重新计算的映射还是会变成[osd.0,osd.1,osd.2],因此会比对osd.1和其他osd上的pglog完成osd.1的recovery或者backfill。

    crush算法应对情况二:加入新的osd.4
    重新计算mapping,如果新加入的osd.4进入了mapping集合中,那么需要将pg的数据迁移到osd.4上;如果没有进入mapping集合,那么该pg不需要发生数据迁移。

    crush算法应对情况三:删除osd.2
    如果删除的osd处于mapping集合中,那么需要重新计算找到一个新的osd加入到mapping;如果删除的osd不处于mapping集合中,那么该pg不需要发生数据迁移。

    与使用hash算法的区别:
    如果是使用hash算法,对每一个pg_id取hash值以后,对osd总数取模,那么一旦osd挂掉或者删除osd或者加入新的osd,都会导致osd的总数产生变化,以致于大量的pg_id到osd的映射关系发生变化,会造成大量的数据迁移。
    同时每次使用hash算法都只能得到一个osd的映射关系,所以如果需要找到osd集合的话,需要执行多次hash。

    问题:
    Pgid到osd集合的映射中,需要先针对每一个osd通过一个CRUSH_HASH(PG_ID, OSD_ID, r) 得出一个随机数,然后与该osd的weight相乘,得到乘值最大的osd;然后将r+1,得到另一个不同的osd,再将r+2,得到第三个不同的osd。这里r是一个随机常量??只有每次都是同样的r才能每次计算都是一样的结果吧。所有这里的r是会保存起来吗?不然客户端计算得到的会一直都是一样的集合吗?
    解答:至少在目前看到的流程中r的初始值始终是1。

    参考:
    http://www.xuxiaopang.com/2016/11/08/easy-ceph-CRUSH/

    展开全文
  • Ceph Crush算法详解

    千次阅读 2018-03-05 21:03:23
    Ceph作为最近关注度比较高的统一分布式存储系统,其有别于其他分布式系统...另外,Crush算法还有效缓解了普通hash算法在处理存储设备增删时带来的数据迁移问题。接下面我会分三篇博文介绍这个重量级的算法,第一篇主...
  • 文档是高清中文版pdf,详细介绍了ceph crush算法
  • Ceph Crush 算法源码分析

    千次阅读 2017-01-11 15:57:07
    Ceph Crush算法是Ceph分布式系统中用于数据分布(定位)的核心算法,其核心组件有crush rule、bucket algorithm。crush rule是可以自定义的选择过程,bucket algorithm是从bucket选取item时使用的算法,该算法需要的...
  • 经过不断地实践和优化,Ceph作为开源云存储重要的后端之一,被大家认可,这也离不开CRUSH算法的先进设计。 CRUSH算法的基本特性 为一个分布式存储系统实现数据分布算法不简单,至少需要考虑下述情况。 · 实现...
  • CRUSH算法介绍

    千次阅读 2018-12-24 23:27:21
    CRUSH数据分布算法的全称是:Controlled, Scalable, Decentralized Placement of Replicated Data. 开源的分布式存储Ceph采用CRUSH数据分布算法以达到以下几个要求: 1. 数据分布均衡 2. 负载均衡 3. 灵活应对集群...
  • Ceph存储中基于温度因子的CRUSH算法改进_穆彦良.pdf
  • ceph的CRUSH算法的源码分析 2 Replies Contents [hide] 1 1 源文件分析 1.1 1.1 rule与bucket的关系 1.2 1.2 crush目录下的文件 1.3 1.3 crush.h中 1.4 1.4...
  • ceph的CRUSH算法

    千次阅读 2013-12-09 15:01:08
    Ceph中关于副本位置的选择,采用的算法是CRUSH。...Ceph采用的CRUSH算法的实现,跟openstack swift等采用一致性一致性hash有着明显的区别。先说相同之处,目的都是类似,都是为了保证副本分布的均匀,设备空间利用率的
  • 分布式文件系统CEPH的CRUSH算法原理。从国外的网站下载的,这恐怕是唯一能够找到的算法资料了。
  • 前一章介绍CRUSH算法的基本原理和一些基本的数据结构,这一节将介CRUSH的源码实现,主要是一些对算法实现的具体函数的介绍。 回顾 Ceph 学习——CRUSH算法及源码分析(一) CRUSH 相关源代码 位于源码文件的 ceph/...
  • 原文地址 CEPH CRUSH algorithm source code analysis ...文章比较深入的写了CRUSH算法的原理和过程.通过调试深入的介绍了CRUSH计算的过程.文章中添加了些内容.写在前面读本文前,
  • Ceph CRUSH算法

    2020-04-27 11:43:32
    1. 数据分布算法挑战数据分布和负载均衡:a. 数据分布均衡,使数据能均匀的分布到各个节点上。b. 负载均衡,使数据访问读写操作的负载在各个节点和磁盘的负载均衡。灵活应对集群伸缩a. 系统可以方便的增加或者删除...
  • 一致性hash与CRUSH算法总结 相同之处:都解决了数据缓存系统中数据如何存储与路由。 不同之处:区别在于虚拟节点和物理节点的映射办法不同 由于一般的哈希函数返回一个int(32bit)型的hashCode。...
  • CRUSH 算法解决了PG副本如何分布在集群OSD上的问题,本文先介绍CRUSH算法基本原理和相关的数据结构,主要是CRUSH map中的内容如bucket、placement rule等以及他们的源码初探。 ps: 代码目前都没加注释,也没有删除...
  • crush算法As of Chrome OS 69, support for Linux applications is a baked in part of the operating system. Once enabled, this installs the Terminal on your Chrome OS system, but what is it and how does ...
  • 参考文档: https://ceph.com/wp-content/uploads/2016/08/weil-crush-sc06.pdf Ceph剖析:数据分布之CRUSH算法与一致性Hash
  • Crush算法1、Crush的目的 优化分配数据,高效的重组数据,灵活的约束对象副本放置,硬件故障时候最大化保证数据安全 2、流程 Ceph 架构中,Ceph客户端是直接读写存放在OSD上的RADOS Object,因此,Ceph需要走完(Pool...
  • ceph存储 ceph的CRUSH算法的源码分析

    千次阅读 2014-11-06 10:27:18
    ceph的CRUSH算法的源码分析 2 Replies Contents [hide] 1 1 源文件分析 1.1 1.1 rule与bucket的关系1.2 1.2 crush目录下的文件1.3 1.3 crush.h中1.4 1.4 crush.c中1.5 1.5 build.c中1.6 1.6 在...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 250
精华内容 100
关键字:

crush算法