最后的 Lab 要求我们实现一个分片 k/v 存储系统。

Part A: The Controller and Static Sharding#

大概的框架直接照抄 lab4 就可以，麻烦的点在于如何平均分配切片并尽可能减少移动。

注意 golang 的 map 存储的是引用，所以新建 configuration 时要新建一个 map。

另外 golang 的 map 也是哈希的，所以 for k, v := range 遍历 map 会导致各节点的分片不同，要保证每次遍历 map 都是按照一定顺序的。

切片的分配#

首先分析一下：平均分配意味着每组会分配到 shardNum := len(conf.Shards) / len(conf.Groups) 个分片，而其中 toleranceNum := len(conf.Shards) % len(conf.Groups) 个组会多分配到一个分片。

而为了尽可能减少分片的移动，可以将分片数大于 shardNum 的节点多出来的分片以及 0 的分片标记为 待移出，而分片数少于 shardNum 的节点则标记缺少量个数的待补充。当 toleranceNum > 0 时可以“容忍” toleranceNum 个节点多一个分片。

标记完成后如果容忍的节点数仍小于 toleranceNum，则让差值数量的待补充节点额外承担切片。

最后将 待移出的分片分配到待补充节点即可。

代码实现如下：

1
func reorder(conf *Config) {
2
    if len(conf.Groups) == 0 {
3
        return
4
    }
5
    shardNum := len(conf.Shards) / len(conf.Groups)
6
    remainNum := len(conf.Shards) % len(conf.Groups)
7
    shardSingal := make(map[int]int)
8
    gidRemove := make([]int, 0, 5)
9
    gidAdd := make([]int, 0, 5)
10
    for key := range conf.Groups {
11
        shardSingal[key] = shardNum
12
    }
13
    shardSingal[0] = 0
14
    toleranceNum := remainNum
15
    for _, val := range conf.Shards {
16
        if _, ok := shardSingal[val]; ok {
17
            shardSingal[val]--
18
        }
19
    }
20
    keysSorted := make([]int, 0, len(shardSingal))
21
    for key := range shardSingal {
22
        keysSorted = append(keysSorted, key)
23
    }
24
    sort.Ints(keysSorted)
25
    for _, key := range keysSorted {
26
        for shardSingal[key] < 0 {
27
            if shardSingal[key] == -1 && toleranceNum > 0 && key != 0 {
28
                toleranceNum--
29
                break
30
            }
31
            gidRemove = append(gidRemove, key)
32
            shardSingal[key]++
33
        }
34
        for shardSingal[key] > 0 {
35
            gidAdd = append(gidAdd, key)
36
            shardSingal[key]--
37
        }
38
    }
39
    if shardNum == 0 && toleranceNum > 0 {
40
        for _, key := range keysSorted {
41
            if toleranceNum <= 0 {
42
                break
43
            }
44
            if key != 0 && shardSingal[key] == 0 {
45
                gidAdd = append(gidAdd, key)
46
                toleranceNum--
47
            }
48
        }
49
    }
50
    end := len(gidAdd)
51
    for ptr := 0; ptr < end && toleranceNum > 0; ptr++ {
52
        if ptr+1 < end && gidAdd[ptr] == gidAdd[ptr+1] {
53
            continue
54
        }
55
        gidAdd = append(gidAdd, gidAdd[ptr])
56
        toleranceNum--
57
    }
58
    ptr := 0
59
    for i := 0; i < len(conf.Shards) && ptr < len(gidRemove); i++ {
60
        if conf.Shards[i] == gidRemove[ptr] {
61
            conf.Shards[i] = gidAdd[ptr]
62
            ptr++
63
        }
64
    }
65
}

具体实现#

都做到这里了实现这些东西肯定是很轻松的，没什么好讲的。

1
func (sc *ShardCtrler) apply() {
2
    for {
3
        applyMsg := <-sc.applyCh
4
        if applyMsg.CommandValid {
5
            op, _ := applyMsg.Command.(Op)
6
            sc.mu.Lock()
7
            if _, ok := sc.history[op.ID]; ok {
8
                sc.mu.Unlock()
9
                continue
10
            }
11
            switch op.Operation {
12
            case "Join":
13
                lastConfig := sc.configs[len(sc.configs)-1]
14
                lastConfig.Groups = map[int][]string{}
15
                for k, v := range sc.configs[len(sc.configs)-1].Groups {
16
                    lastConfig.Groups[k] = v
17
                }
18
                for k, v := range op.Servers {
19
                    lastConfig.Groups[k] = v
20
                }
21
                lastConfig.Num = len(sc.configs)
22
                reorder(&lastConfig)
23
                sc.configs = append(sc.configs, lastConfig)
24
                sc.lastApplied = "Join"
25
                sc.history[op.ID] = "1"
26
            case "Leave":
27
                lastConfig := sc.configs[len(sc.configs)-1]
28
                lastConfig.Num = len(sc.configs)
29
                lastConfig.Groups = map[int][]string{}
30
                for k, v := range sc.configs[len(sc.configs)-1].Groups {
31
                    lastConfig.Groups[k] = v
32
                }
33
                for _, val := range op.GIDs {
34
                    for i, v := range lastConfig.Shards {
35
                        if v == val {
36
                            lastConfig.Shards[i] = 0
37
                        }
38
                    }
39
                    delete(lastConfig.Groups, val)
40
                }
41
                reorder(&lastConfig)
42
                sc.configs = append(sc.configs, lastConfig)
43
                sc.lastApplied = "Leave"
44
                sc.history[op.ID] = "1"
45
            case "Move":
46
                if !(sc.lastApplied == "Join" || sc.lastApplied == "Leave") {
47
                    sc.lastApplied = "Move"
48
                    lastConfig := sc.configs[len(sc.configs)-1]
49
                    lastConfig.Shards[op.Shard] = op.GID
50
                    lastConfig.Num = len(sc.configs)
51
                    sc.configs = append(sc.configs, lastConfig)
52
                }
53
                sc.history[op.ID] = "1"
54
            case "Query":
55
                sc.lastApplied = "Query"
56
                sc.history[op.ID] = "1"
57
            }
58
            delete(sc.history, op.LastOpID)
59
            sc.mu.Unlock()
60
        }
61
    }
62
}

Part B: Shard Movement#

首先将 lab4 的代码 copy 过来，就可以 pass 第一个 test。

在每次接收请求后判断分片是否正确，不正确则直接返回，实现后即可 pass 第二个 test。

分片的迁移#

采用向之前持有分片的组发送 RPC 请求。

获取分片时肯定是向每组的 leader 发送，但如果组内的每个 server 都发送 RPC 的话比较复杂，并且不好处理 challenge1 中的删除分片。思考了一下，应当让每组中只有 leader 不断检测，其他节点的作用单纯是在分布式系统保持数据一致性。

起一个协程不断查询是否有更新的 configuration，如果有更新且待接收的分片为空时将其写入 raft 通知组内所有节点更新配置。应用新的配置时找出需要发送的分片和待接收的分片。

1
func (kv *ShardKV) poll() {
2
    _, isLeader := kv.rf.GetState()
3
    kv.mu.Lock()
4
    if !isLeader || len(kv.newShard) > 0 {
5
        kv.mu.Unlock()
6
        return
7
    }
8
    next := kv.conf.Num + 1
9
    kv.mu.Unlock()
10
    conf := kv.mck.Query(next)
11
    if conf.Num == next {
12
        kv.rf.Start(conf)
13
    }
14
}
15

16
func (kv *ShardKV) updateDataShard(conf shardctrler.Config) {
17
    kv.mu.Lock()
18
    defer kv.mu.Unlock()
19
    if conf.Num <= kv.conf.Num {
20
        return
21
    }
22
    lastConf, outShard := kv.conf, kv.authFlags
23
    kv.authFlags, kv.conf = make(map[int]bool), conf
24
    for shard, gid := range conf.Shards {
25
        if gid != kv.gid {
26
            continue
27
        }
28
        if _, ok := outShard[shard]; ok || lastConf.Num == 0 {
29
            kv.authFlags[shard] = true
30
            delete(outShard, shard)
31
        } else {
32
            kv.newShard[shard] = lastConf.Num
33
        }
34
    }
35
    if len(outShard) > 0 {
36
        kv.outShards[lastConf.Num] = make(map[int]map[string]string)
37
        for shard := range outShard {
38
            targetPairs := make(map[string]string)
39
            for k, v := range kv.pairs {
40
                if key2shard(k) == shard {
41
                    targetPairs[k] = v
42
                }
43
            }
44
            kv.outShards[lastConf.Num][shard] = targetPairs
45
        }
46
    }
47
}

再起一个协程不断检测是否有待接收的分片，若有则向对应组发送获取分片请求。

1
func (kv *ShardKV) getDataShard() {
2
    for !kv.killed() {
3
        _, isLeader := kv.rf.GetState()
4
        kv.mu.Lock()
5
        if !isLeader || len(kv.newShard) == 0 {
6
            kv.mu.Unlock()
7
            time.Sleep(50 * time.Millisecond)
8
            continue
9
        }
10
        var wg sync.WaitGroup
11
        for shard, num := range kv.newShard {
12
            wg.Add(1)
13
            go func(shard int, conf shardctrler.Config) {
14
                kv.sendShardRequest(shard, conf)
15
                wg.Done()
16
            }(shard, kv.mck.Query(num))
17
        }
18
        kv.mu.Unlock()
19
        wg.Wait()
20
        time.Sleep(50 * time.Millisecond)
21
    }
22
}
23

24
func (kv *ShardKV) sendShardRequest(shard int, conf shardctrler.Config) {
25
    args := ShardArgs{Shard: shard, Num: conf.Num}
26
    for _, srv := range conf.Groups[conf.Shards[shard]] {
27
        srv := kv.make_end(srv)
28
        reply := ShardReply{}
29
        ok := srv.Call("ShardKV.ReceiveShardRequest", &args, &reply)
30
        if ok && reply.Err == OK {
31
            kv.rf.Start(ShardMove{Pairs: reply.AppendPairs, Sequence: reply.Sequence, Shard: shard, Num: conf.Num})
32
            return
33
        }
34
    }
35
}

成功后将新分片数据写入 raft 共享给全组。

快照#

因为要保证每次重启从上次快照点重新应用日志能够完全还原系统状态，像是待移出的切片等数据也要保存在快照中。

1
func (kv *ShardKV) MakeSnapshot(persister *raft.Persister, maxraftstate int) {
2
    for !kv.killed() {
3
        kv.mu.Lock()
4
        kv.cond.Wait()
5
        if persister.RaftStateSize() > maxraftstate*4/5 {
6
            w := new(bytes.Buffer)
7
            e := labgob.NewEncoder(w)
8
            e.Encode(kv.pairs)
9
            e.Encode(kv.sequence)
10
            e.Encode(kv.newShard)
11
            e.Encode(kv.outShards)
12
            e.Encode(kv.authFlags)
13
            e.Encode(kv.conf)
14
            e.Encode(kv.garbages)
15
            snapshot := w.Bytes()
16
            kv.rf.Snapshot(kv.lastIndex, snapshot)
17
        }
18
        kv.mu.Unlock()
19
    }
20
}

去重#

因为之前一直采用存储操作历史记录的方式来去重，而分片迁移时无法特定对应切片的历史记录。所以需要更改历史记录为history map[int]map[int64]Result，分切片存储历史记录。

在进行重复测试时，发现 TestConcurrent3_5B 中，有可能出现已经完成的指令在分片迁移之后才进行 RPC 的回复，这会导致 Get 无法及时回复有效的结果。

所有最后还是用通道回复结果（

而且 go 从设计就能看出是奉行通过通信来共享内存，而不是通过共享内存来通信的。

这里参考了简书上的一篇博文¹，为每个客户端分配 id 而非为操作分配 id，并让每个客户端记下每次请求的序号。server 侧存储每个客户端的最新已进行操作序号，序号小于记录的操作不再进行，以此达到去重。

1
type Clerk struct {
2
    sm       *shardctrler.Clerk
3
    config   shardctrler.Config
4
    make_end func(string) *labrpc.ClientEnd
5
    // You will have to modify this struct.
6
    id  int64
7
    num int
8
}
9

10
func MakeClerk(ctrlers []*labrpc.ClientEnd, make_end func(string) *labrpc.ClientEnd) *Clerk {
11
    ck := new(Clerk)
12
    ck.sm = shardctrler.MakeClerk(ctrlers)
13
    ck.make_end = make_end
14
    // You'll have to add code here.
15
    ck.id = nrand()
16
    ck.num = 0
17
    return ck
18
}

Challenge 1#

Challenge 1 要求实现对无用内存的释放。

首先要明确我们可以删除什么样的数据。当一个节点向另一组发送分片后，如果能够确保该分片已被接受，则本地节点的分片数据可以不再保留。

1
func (kv *ShardKV) applyShardMove(data ShardMove) {
2
    kv.mu.Lock()
3
    defer kv.mu.Unlock()
4
    if data.Num != kv.conf.Num-1 {
5
        return
6
    }
7
    delete(kv.newShard, data.Shard)
8
    if _, ok := kv.authFlags[data.Shard]; !ok {
9
        kv.authFlags[data.Shard] = true
10
        for k, v := range data.Pairs {
11
            kv.pairs[k] = v
12
        }
13
        for k, v := range data.Sequence {
14
            kv.sequence[k] = max(v, kv.sequence[k])
15
        }
16
        if _, ok := kv.garbages[data.Num]; !ok {
17
            kv.garbages[data.Num] = make(map[int]bool)
18
        }
19
        kv.garbages[data.Num][data.Shard] = true
20
    }
21
    kv.cond.Broadcast()
22
}

也就是说要采取二阶段提交来确保正确的垃圾回收。

另起协程不断检测是否有垃圾需要进行处理，若有则向对应组发送 RPC 通知对方可以清除。

1
func (kv *ShardKV) requestGarbageCollection() {
2
    _, isLeader := kv.rf.GetState()
3
    kv.mu.Lock()
4
    if !isLeader || len(kv.garbages) == 0 {
5
        kv.mu.Unlock()
6
        return
7
    }
8
    var wg sync.WaitGroup
9
    for num, shards := range kv.garbages {
10
        for shard := range shards {
11
            wg.Add(1)
12
            go func(shard int, cfg shardctrler.Config) {
13
                defer wg.Done()
14
                args := ShardArgs{Shard: shard, Num: cfg.Num}
15
                gid := cfg.Shards[shard]
16
                for _, server := range cfg.Groups[gid] {
17
                    srv := kv.make_end(server)
18
                    reply := ShardReply{}
19
                    if ok := srv.Call("ShardKV.GarbageCollection", &args, &reply); ok && reply.Err == OK {
20
                        kv.mu.Lock()
21
                        defer kv.mu.Unlock()
22
                        delete(kv.garbages[cfg.Num], shard)
23
                        if len(kv.garbages[cfg.Num]) == 0 {
24
                            delete(kv.garbages, cfg.Num)
25
                        }
26
                    }
27
                }
28
            }(shard, kv.mck.Query(num))
29
        }
30
    }
31
    kv.mu.Unlock()
32
    wg.Wait()
33
}
34

35

36
func (kv *ShardKV) GarbageCollection(args *ShardArgs, reply *ShardReply) {
37
    reply.Err = ErrWrongLeader
38
    kv.mu.Lock()
39
    if _, ok := kv.outShards[args.Num]; !ok {
40
        kv.mu.Unlock()
41
        return
42
    }
43
    if _, ok := kv.outShards[args.Num][args.Shard]; !ok {
44
        kv.mu.Unlock()
45
        return
46
    }
47
    gc := GC{CfgNum: args.Num, Shard: args.Shard}
48
    kv.mu.Unlock()
49
    index, _, isLeader := kv.rf.Start(gc)
50
    if isLeader {
51
        ch := kv.getNotifyCh(index, true)
52
        msg := kv.getNotified(index, ch)
53
        if msg.success {
54
            reply.Err = OK
55
        }
56
    }
57
}

Challenge 2#

按照上面的实现，Challenge 2 可以直接 pass。

configuration 的依次更新保证了即便在配置更新过程中系统也能正常运行，而采用区分分片的处理权限状态就可以在配置完全更新前保证已完成分片的处理。

总结#

历经千辛万苦，终于完成了所有 Lab。

虽然最终还是参考了别人的解决方案完成了 Lab 5B，但这段极度折磨的经历真的可以让人深刻体会到分布式系统的复杂性，前几天每天早上醒来想到还要继续调试 Lab5B 就不想起床了。。。

个人对所有 Lab 的难度排序是：Lab5B >>> Lab3B >> Lab3其他Part > Lab4 > 其他

Footnotes#

https://www.jianshu.com/p/f5c8ab9cd577 ↩