简介
当我们要统计数亿文本的词频，单个机器性能一般，况且是数亿级数据，处理是十分缓慢的，对于这样的任务，希望的是多台电脑共同处理，大幅度减少任务时间。联合多台电脑一起工作的系统就是分布式系统。
最近在学MIT6.824分布式系统课程，第一个Lab就是MapReduce，MapReduce是Google公司2004年发表的一篇论文，介绍很多任务都可以分为两步操作——Map和Reduce(比如要统计词频，Map分别对每个文件生成单词和单一数目，分不同区块保存，Reduce对不同区块进行统计，得到最终结果)，可以将这两个操作之外的包装起来，只提供Map和Reduce的接口，不同任务只需要替换不同的Map函数和Reduce函数即可。论文中还讲述了MapReduce分布式系统的实现细节以及应用场景。本文将以MIT6.824课程的Lab1为例，讲述如何完成MapReduce Lab1以及实现过程中遇到一些的困难。
需要的基础：
笔记中的全部代码可以在https://github.com/FangYang970206/MIT6.824-2020中查看下载。
环境配置
环境配置可以看Lab1流程，手把手地教怎么配置，主要分两步：
第一步安装Go环境
wget -qO- https://dl.google.com/go/go1.13.6.linux-amd64.tar.gz | sudo tar xz -C /usr/local
第二步克隆Lab1仓库
git clone git://g.csail.mit.edu/6.824-golabs-2020 6.824
克隆出来的仓库的src文件夹中只有几个是与MapReduce相关的，分别是：
- main目录下的mrmaster.go, mrworker.go, mrsequential.go和test-mr.sh，还有pg*.txt代表的8个文件是要分布式处理的输入，这个文件内容也不需要变，test-mr.sh有五个任务，运行test-mr.sh可以知道自己是否通过所有任务。
- mr文件夹，这个是MapReduce主要实现代码，工作量就在这了
- mrapps是不同任务的Map和Reduce函数包，这个不需要管
系统框架一览
MapReduce系统是由一个master进程和多个worker进程组成，master和worker之间是通过RPC(Remote Procedure Call)进行通信，master进程负责给多个worker分配任务，记录任务完成状态，并且需要处理worker奔溃或者超时运行等问题，worker需要处理相应的任务，处理完毕发送报告给master，再请求下一个任务。我根据代码函数调用逻辑画出了一个系统框图，可以更好的理解MapReduce系统的工作原理：
代码详解
根据上面的系统框图，现在来从代码中理解系统。
Master结构
type Flag struct {
processing bool
finished bool
}
type Master struct {
FileNames []string
MapFlags []Flag
ReduceFlags []Flag
MapTaskCnts []int
ReduceTaskCnts []int
MapAllDone bool
ReduceALLDone bool
MapNum int
ReduceNum int
Mut sync.Mutex
}
- FileNames：pg*.txt这八个文件名
- MapFlags：对应八个文件的Map任务状态，processing代表正在处理，finished表示已完成
- ReduceFlag：同上
- MapTaskCnts：这是记录Map的当前任务序列号，如果某个map任务发生timeout，HandleTimeout函数对这个map任务的processing标志清0，重新分配，当前任务的序列号在上一个任务号中加1，如果之前发生timeout的任务来报告完成，由于小于当前任务号，HandleWorkerReport函数可无需记录，直接退出
- ReduceTaskCnts：同上
- MapAllDone：Map任务全部完成为true
- ReduceAllDone：Reduce任务全部完成为true
- MapNum：Map任务数
- ReduceNum：Reduce任务数
- Mut：互斥锁，由于有多个worker，避免条件竞争发生不确定行为，master内部数据需要互斥访问
Worker结构
type TaskState int
const (
MapState TaskState = 0
ReduceState TaskState = 1
StopState TaskState = 2
WaitState TaskState = 3
)
type WorkerTask struct {
MapID int
ReduceID int
ReduceNum int
MapNum int
MapTaskCnt int
ReduceTaskCnt int
State TaskState
FileName string
MapFunction func(string, string) []KeyValue
ReduceFunction func(string, []string) string
}
- MapID和ReduceID：Map任务ID和Reduce任务ID
- MapNum和ReduceNum：Map的任务总数和Reduce任务总数
- MapTaskCnt和ReduceTaskCnt：Map任务序列号和Reduce序列号
- State：任务有四种状态，分别是MapState，ReduceState，StopState和WaitState，MapState表示当前需要处理Map任务，ReduceState表示当前需要处理Reduce任务，WaitState表示当前没有需要处理的任务，开始睡眠等待，StopState代表任务已全部完成，可以退出。
- FileName：表示Map任务需要的文件名
- MapFunction和ReduceFunction：任务根据State需要进行的Map函数或者Reduce函数
Master接口
创建Master
func MakeMaster(files []string, nReduce int) *Master {
m := Master{FileNames: files,
MapFlags: make([]Flag, len(files), len(files)),
ReduceFlags: make([]Flag, nReduce, nReduce),
MapNum: len(files),
ReduceNum: nReduce,
MapAllDone: false,
ReduceALLDone: false,
MapTaskCnts: make([]int, len(files)),
ReduceTaskCnts: make([]int, nReduce),
}
m.server()
args, reply := NoArgs{}, NoReply{}
go m.HandleTimeOut(&args, &reply)
return &m
}
这个函数会由mrmaster.go文件的主函数调用，创建一个master对象，需要传入文件名数组，以及要进行多少个Reduce任务，根据这两个输入，可以初始化master参数。m.server()是关于RPC的内容，这里不去谈，有兴趣可以看看博客最后关于RPC内容, 只需要知道master函数要使用RPC，函数需要是两个参数（没参数会有警告），都为指针形式，第一个表示输入参数，第二个表示输出参数，返回错误，无错误返回nil。然后创建一个线程专门处理timeout，然后将master返还给mrmaster的主函数，mrmaster主函数会确认master的MapAllDone和ReduceALLDone是否都为真，都为真则退出，否则睡眠一段时间再确认。
生成worker task
func (m *Master) CreateWorkerTask(args *NoArgs, workerTask *WorkerTask) error {
m.Mut.Lock()
defer m.Mut.Unlock()
if !m.MapAllDone {
for idx := 0; idx < m.MapNum; idx++ {
if !m.MapFlags[idx].processing && !m.MapFlags[idx].finished {
workerTask.ReduceNum = m.ReduceNum
workerTask.MapNum = m.MapNum
workerTask.State = MapState
workerTask.MapID = idx
workerTask.FileName = m.FileNames[idx]
m.MapTaskCnts[idx]++
workerTask.MapTaskCnt = m.MapTaskCnts[idx]
m.MapFlags[idx].processing = true
return nil
}
}
workerTask.State = WaitState
return nil
}
if !m.ReduceALLDone {
for idx := 0; idx < m.ReduceNum; idx++ {
if !m.ReduceFlags[idx].processing && !m.ReduceFlags[idx].finished {
workerTask.State = ReduceState
workerTask.ReduceNum = m.ReduceNum
workerTask.MapNum = m.MapNum
workerTask.ReduceID = idx
m.ReduceTaskCnts[idx]++
workerTask.ReduceTaskCnt = m.ReduceTaskCnts[idx]
m.ReduceFlags[idx].processing = true
return nil
}
}
workerTask.State = WaitState
return nil
}
workerTask.State = StopState
return nil
}
函数首先会获得互斥锁，然后判断MapAllDone是否为false，为false进入循环遍历，如果某个任务的processing状态和finished状态都为false，说明这个任务可以需要被处理，可以分配，讲配置参数写入到输出参数中，并标志master中当前任务的状态processing为true以及序列号。如果没有任务需要处理，说明map有些任务正在处理，有些已完成。进入等待阶段。判断ReduceALLDone与前面类似。不加以叙述。
处理worker report
func (m *Master) HandleWorkerReport(wr *WorkerReportArgs, task *NoReply) error {
m.Mut.Lock()
defer m.Mut.Unlock()
if wr.IsSuccess {
if wr.State == MapState {
if wr.MapTaskCnt == m.MapTaskCnts[wr.MapID] {
m.MapFlags[wr.MapID].finished = true
m.MapFlags[wr.MapID].processing = false
}
} else {
if wr.ReduceTaskCnt == m.ReduceTaskCnts[wr.ReduceID] {
m.ReduceFlags[wr.ReduceID].finished = true
m.ReduceFlags[wr.ReduceID].processing = false
}
}
} else {
if wr.State == MapState {
if m.MapFlags[wr.MapID].finished == false {
m.MapFlags[wr.MapID].processing = false
}
} else {
if m.ReduceFlags[wr.ReduceID].finished == false {
m.ReduceFlags[wr.ReduceID].processing = false
}
}
}
for id := 0; id < m.MapNum; id++ {
if !m.MapFlags[id].finished {
break
} else {
if id == m.MapNum-1 {
m.MapAllDone = true
}
}
}
for id := 0; id < m.ReduceNum; id++ {
if !m.ReduceFlags[id].finished {
break
} else {
if id == m.ReduceNum-1 {
m.ReduceALLDone = true
}
}
}
return nil
}
输入参数有一个标识位，表示任务是否成功，成功判断任务状态以及序列号，如果序列号与master对应上，可以表明这个任务成功，如果对不上，说明这是个timeout任务，无需处理。如果任务标志位为false，进入错误处理，判断任务是否完成，因为可能是timeout任务标志位为false，未完成让processing置0，CreateWorkerTask可以重新分配。最后判断Map任务和Reduce任务是否相应全部完成，全部完成可以设置MapALLDone和ReduceALLDone为true。
处理timeout
func (m *Master) HandleTimeOut(args *NoArgs, reply *NoReply) error {
for {
m.Mut.Lock()
if m.MapAllDone && m.ReduceALLDone {
m.Mut.Unlock()
break
}
time.Sleep(30 * time.Millisecond)
if !m.MapAllDone {
for idx := 0; idx < m.MapNum; idx++ {
if m.MapFlags[idx].finished == false {
m.MapFlags[idx].processing = false
}
}
} else {
for idx := 0; idx < m.ReduceNum; idx++ {
if m.ReduceFlags[idx].finished == false {
m.ReduceFlags[idx].processing = false
}
}
}
m.Mut.Unlock()
time.Sleep(2000 * time.Millisecond)
}
return nil
}
处理timeout很简单，先判断MapALLDone和ReduceALLDone是否都为true，都为true则退出即可。然后判断M任务那些还没有完成，对没有完成的任务的processing清0，就可以让CreateWorkerTask重新分配没有完成的任务了。最后释放锁，睡眠2s，可以看到Handletimeout函数是以2s为间隔的，2s内没有完成的任务视为timeout。
Worker接口
生成worker
func Worker(mapf func(string, string) []KeyValue,
reducef func(string, []string) string) {
wt := WorkerTask{
MapFunction: mapf,
ReduceFunction: reducef,
}
for {
wt.GetWorkerTask()
if wt.State == MapState {
wt.DoMapWork()
} else if wt.State == ReduceState {
wt.DoReduceWork()
} else if wt.State == StopState {
break
} else if wt.State == WaitState {
time.Sleep(300 * time.Millisecond)
}
}
return
}
func (wt *WorkerTask) GetWorkerTask() {
cwa := NoArgs{}
newWt := WorkerTask{}
call("Master.CreateWorkerTask", &cwa, &newWt)
if newWt.State == MapState {
wt.ReduceNum = newWt.ReduceNum
wt.MapNum = newWt.MapNum
wt.State = newWt.State
wt.MapID = newWt.MapID
wt.FileName = newWt.FileName
wt.MapTaskCnt = newWt.MapTaskCnt
} else if newWt.State == ReduceState {
wt.State = newWt.State
wt.ReduceID = newWt.ReduceID
wt.ReduceTaskCnt = newWt.ReduceTaskCnt
wt.MapNum = newWt.MapNum
wt.ReduceNum = newWt.ReduceNum
} else if newWt.State == StopState {
wt.State = newWt.State
} else {
wt.State = newWt.State
}
}
mrworker会调用worker函数，传入map函数和reduce函数，根据函数参数创建一个worker，然后进入循环，调用GetWorkerTask函数，这个函数会调用Master.CreateWorkerTask函数，并传入两个参数，得到任务分配后，讲相应的参数和状态赋值给worker。worker就可以根据状态进入处理相应任务或者睡眠，或者退出。
Map work
func (wt *WorkerTask) DoMapWork() {
file, err := os.Open(wt.FileName)
content, err := ioutil.ReadAll(file)
file.Close()
kvs := wt.MapFunction(wt.FileName, string(content))
intermediate := make([][]KeyValue, wt.ReduceNum, wt.ReduceNum)
for _, kv := range kvs {
idx := ihash(kv.Key) % wt.ReduceNum
intermediate[idx] = append(intermediate[idx], kv)
}
for idx := 0; idx < wt.ReduceNum; idx++ {
intermediateFileName := fmt.Sprintf("mr-%d-%d", wt.MapID, idx)
file, err = os.Create(intermediateFileName)
data, _ := json.Marshal(intermediate[idx])
_, err = file.Write(data)
file.Close()
}
wt.ReportWorkerTask(nil)
}
func (wt *WorkerTask) ReportWorkerTask(err error) {
wra := WorkerReportArgs{
MapID: wt.MapID,
ReduceID: wt.ReduceID,
State: wt.State,
IsSuccess: true,
}
if wt.State == MapState {
wra.MapTaskCnt = wt.MapTaskCnt
} else {
wra.ReduceTaskCnt = wt.ReduceTaskCnt
}
wrr := NoReply{}
if err != nil {
wra.IsSuccess = false
}
call("Master.HandleWorkerReport", &wra, &wrr)
}
为了增加可读性，我将处理错误的代码删除了，更好看一些，Map work就是读取相应的文件，调用MapFunction生成KeyValue对，然后根据哈希函数得到要讲当前key分配到哪一块中，总共有ReduceNum块，最后根据这么块生成对应map以及reduce块的文件。然后调用ReportWorkerTask报告成功，传入nil表示成功。ReportWorkerTask内部会调用Master.HandleWorkerReport函数来汇报这一执行结果。
Reduce work
func (wt *WorkerTask) DoReduceWork() {
kvsReduce := make(map[string][]string)
for idx := 0; idx < wt.MapNum; idx++ {
filename := fmt.Sprintf("mr-%d-%d", idx, wt.ReduceID)
file, err := os.Open(filename)
content, err := ioutil.ReadAll(file)
file.Close()
kvs := make([]KeyValue, 0)
err = json.Unmarshal(content, &kvs)
for _, kv := range kvs {
_, ok := kvsReduce[kv.Key]
if !ok {
kvsReduce[kv.Key] = make([]string, 0)
}
kvsReduce[kv.Key] = append(kvsReduce[kv.Key], kv.Value)
}
}
ReduceResult := make([]string, 0)
for key, val := range kvsReduce {
ReduceResult = append(ReduceResult, fmt.Sprintf("%v %v
", key, wt.ReduceFunction(key, val)))
}
outFileName := fmt.Sprintf("mr-out-%d", wt.ReduceID)
err := ioutil.WriteFile(outFileName, []byte(strings.Join(ReduceResult, "")), 0644)
wt.ReportWorkerTask(nil)
}
同样把一些错误处理删除了，首先读取相同块的所有文件，需要对相同key的内容聚合在一起，然后循环调用ReduceFunction得到reduce的结果，最后生成输出。
遇到过的坑
主要遇到的两个坑，一个是关于GetWorkerTask，一个是CreateWorkerTask
首先说GetWorkerTask，最开始代码是下面这样子，我把wt作为参数传入进去，我发现后期调用的时候，wt的参数是不会更新的，一直处于WaitState，导致任务worker无法工作。新创建一个WorkerTask为参数，传入即可解决问题。
func (wt *WorkerTask) GetWorkerTask() {
cwa := NoArgs{}
call("Master.CreateWorkerTask", &cwa, wt)
}
第二个是思维还没有转变过来的问题，分布式系统需要有分布式的思想，这是CreateWorkerTask的截取代码，可以看到少了两行，没有对MapNum和ReduceNum进行初始化，为什么会做不初始化呢，因为当时我想的是上面的Map任务已经初始化，没有必要再进行初始化，这就是错误的根源，万一之前初始化的worker crash掉了，map任务全部完成，那新的worker进入reduce，你不初始化MapNum和ReduceNum就会有bug，最明显的你运行CrashTest任务时，发现最后生成的结果有的有，有的没有，有的是之前运行Map任务的，现在运行Reduce任务，没有的就是新的worker直接进入Reduce任务，默认初始化为0，则循环读文件直接退出。
if !m.ReduceALLDone {
for idx := 0; idx < m.ReduceNum; idx++ {
if !m.ReduceFlags[idx].processing && !m.ReduceFlags[idx].finished {
workerTask.State = ReduceState
workerTask.ReduceID = idx
m.ReduceTaskCnts[idx]++
workerTask.ReduceTaskCnt = m.ReduceTaskCnts[idx]
m.ReduceFlags[idx].processing = true
return nil
}
}
workerTask.State = WaitState
return nil
}
RPC
Go语言进行RPC非常简单，有现成的RPC的包，非常方便。
func masterSock() string {
s := "/var/tmp/824-mr-"
s += strconv.Itoa(os.Getuid())
return s
}
func (m *Master) server() {
rpc.Register(m)
rpc.HandleHTTP()
sockname := masterSock()
os.Remove(sockname)
l, e := net.Listen("unix", sockname)
go http.Serve(l, nil)
}
func call(rpcname string, args interface{}, reply interface{}) bool {
sockname := masterSock()
c, err := rpc.DialHTTP("unix", sockname)
defer c.Close()
c.Call(rpcname, args, reply)
}
删减了一些错误处理代码，核心代码就是上面这些，只需要20来行就可以构建好RPC流程，首先master要调用server函数，进行rpc注册以及rpc处理http，然后得到套接字名，移除系统中套接字名，然后开始监听，创建线程进行http服务。server函数运行好之后。worker就可以根据套接字名进行拨号，然后调用master的函数。
结语
MapReduce介绍就到这了，推荐自己尝试实现一遍，收获还是很大的，包括mapreduce细节实现，更加熟悉Go，分布式调试（可以看看这个commit下的代码，没有删减打印，可以清楚看输出，特别是Crashtest，可以将test-mr.sh前四个任务注释掉，看CrashTest输出）。