6.824（2020春） Lab1：MapReduce
目录
- 前言
- 一、 概况
- 代码
- 结果
- 总结
前言
本来不打算记录这个实验过程的，一是有点懒；二是没太多好说。后来还是耐着自己那膨胀的小性子，简单记录下这个实验。
一、 概况
本次的实验是6.824分布式课程提供的，其提供了主要的代码框架部分，我们需要做的就是理解MapReduce的原理，然后在框架内实现它。
整个实现的MapReduce框架和paper中差不多，一个Master结点用于协调，还有多个Worker结点，每个结点可以向Master请求Map任务或者Reduce任务。
note:
（1）、实验提供的代码中的worker.go文件中的Worker函数，并不是生成所有的worker，而仅仅只是一个worker的执行流程。 多个worker函数是由上层应用进行生成的（实验中是测试代码test-mr.sh生成的）。
（2）、各个worker之间基本上没有通信，信息的传递是利用rpc向Master进行传递，进而被其他的worker了解到的。
（3）、一开始老是通不过最后一个crash测试，后来发现可能是原先用的内部逻辑架构不太好。原先设计的方案是由worker询问master是否所有的任务（CallForReduceFinishReply）都已经完成，然后在这个rpc调用的过程中顺便丢弃还未完成的任务，将其状态重新置为未分配，以便调度其他的worker完成这个任务。但是这样有一个问题，就是可能刚刚被分配的任务，又会被丢弃（因为有其他woker进行询问所有任务是否完成）。
后来利用了时间片的方式，在Master中每一个时间滴答(TimeTick)，将所有正在执行中的任务（RUNNING状态）加一个滴答计时，当超过了10秒之后，就把其状态改为(NOTALLOCATED)。这样操作之后，被动修改就变主动了。优秀的完成了任务。( ●＾o＾●)
代码
由于官方说明，不推荐贴代码，这里为了记录就粘贴下主要的部分吧。
master部分
// Your code here -- RPC handlers for the worker to call.
//响应Map任务请求
func (m *Master) ReplyForMapTask(args *CallForMapTaskArgs, reply *CallForMapTaskReplyArgs) error {
reply.FileName = "" //默认返回是空的
reply.MapId = -1
reply.Ok = false
m.MasterLock.Lock()
//遍历寻找未分配的任务
for mapId, mapTask := range m.AllMapTask {
//fmt.Printf("asker:pid:%v--mapId:%v--mapTask:%v\n", args.TestPid, mapId, mapTask)
if mapTask.status == NOTALLOCATED { //未分配
reply.MapId = mapId
reply.FileName = mapTask.TaskFileName
reply.Ok = true
m.AllMapTask[mapId].status = RUNNING //已分配，正在运行中
m.AllMapTask[mapId].UsedTime = 0 //初始化任务的时间
break
}
}
m.MasterLock.Unlock()
return nil
}
//响应MapWorker结束的任务
func (m *Master) ReplyForMapFinish(args *CallForMapFinishArgs, reply *CallForMapFinishReplyArgs) error {
m.MasterLock.Lock()
MapId := args.MapId //完成任务的MapID号
m.AllMapTask[MapId].status = FINISHED //已完成
for _,fileName := range args.FileNames{
//提取Id号
idInFileNameIndex := len(fileName) - 1 //文件名中的ReduceId号
tmpReduceId, _ := strconv.Atoi(string(fileName[idInFileNameIndex]))
//准备Reduce任务的输入文件
m.AllReduceTask[tmpReduceId].ReduceTaskFiles = append(m.AllReduceTask[tmpReduceId].ReduceTaskFiles,fileName)
}
m.MasterLock.Unlock()
reply.Ok = true
return nil
}
//请求是否Map任务都结束了
func (m *Master) ReplyForAllMapFinish(args *CallForAllMapFinishArgs, reply *CallForAllMapFinishReplyArgs) error {
reply.IsFinished = true
reply.Ok = true
m.MasterLock.Lock()
finishedFlag := true
for _, mapTask := range m.AllMapTask {
if mapTask.status != FINISHED {
reply.IsFinished = false //有任务未结束，需要等待
//m.AllMapTask[i].status = NOTALLOCATED //需要重新分配
finishedFlag = false
break
}
}
m.AllMapTasksFinished = finishedFlag //更新所有Map任务完成标记
m.MasterLock.Unlock()
return nil
}
//响应Reduce申请任务请求
func (m *Master) ReplyForReduceTask(args *CallForReduceTaskArgs, reply *CallForReduceTaskReplyArgs) error {
reply.Ok = false //默认分配失败
reply.ReduceId = -1
m.MasterLock.Lock()
//分配Reduce编号
for reduceId, tmpReduceTask := range m.AllReduceTask {
if tmpReduceTask.status == NOTALLOCATED { //未分配
m.AllReduceTask[reduceId].status = RUNNING //已分配，运行中
m.AllReduceTask[reduceId].UsedTime = 0 //初始化使用时间
//返回的Id和文件名
reply.ReduceFileNames = m.AllReduceTask[reduceId].ReduceTaskFiles
reply.ReduceId = reduceId
reply.Ok = true
break
}
}
m.MasterLock.Unlock()
return nil
}
//标记reduceId的任务完成
func (m *Master) ReplyForReduceFinish(args *CallForReduceFinishArgs, reply *CallForReduceFinishReplyArgs) error {
reply.OK = true
reduceId := args.ReduceId
m.MasterLock.Lock()
m.AllReduceTask[reduceId].status = FINISHED //此编号为ReduceId的任务完成
m.MasterLock.Unlock()
return nil
}
//回复是否所有的Reduce任务都已经完成
func (m *Master) ReplyForAllReduceFinish(args *CallForAllReduceFinishArgs, reply *CallForAllReduceFinishReplyArgs) error {
reply.IsFinished = true
reply.Ok = true
m.MasterLock.Lock()
finishedFlag := true
for _, tmpReduceTask := range m.AllReduceTask {
if tmpReduceTask.status != FINISHED {
finishedFlag = false //未完成标记
reply.IsFinished = false
break
}
}
m.ALlReduceTasksFinished = finishedFlag //更新所有的reduce任务完成标记
m.MasterLock.Unlock()
return nil
}
//不使用参数，无返回值，只是标记所有任务均已完成
func (m *Master) ReplyForAllTaskFinish(args *CallForAllTaskFinishArgs, reply *CallForAllTaskFinishReplyArgs) error {
m.MasterLock.Lock()
m.AllTaskFinished = true //标记所有任务均已完成
m.MasterLock.Unlock()
return nil
}
//
// start a thread that listens for RPCs from worker.go
//
func (m *Master) server() {
rpc.Register(m)
rpc.HandleHTTP()
//l, e := net.Listen("tcp", ":1234")
sockname := masterSock()
os.Remove(sockname)
l, e := net.Listen("unix", sockname)
if e != nil {
log.Fatal("listen error:", e)
}
go http.Serve(l, nil)
}
//给运行中的任务计时
func (m *Master) TimeTick() {
m.MasterLock.Lock()
defer m.MasterLock.Unlock()
if m.AllMapTasksFinished == false{
//计时Map任务
for i,tmpMapTask := range m.AllMapTask {
if tmpMapTask.status == RUNNING {
m.AllMapTask[i].UsedTime++ //所用时间更新
if m.AllMapTask[i].UsedTime > 10 { //如果运行超过10s
m.AllMapTask[i].status = NOTALLOCATED //更新状态为未分配
}
}
}
} else {
//计时Reduce任务
for i,tmpReduceTask := range m.AllReduceTask{
if tmpReduceTask.status == RUNNING {
m.AllReduceTask[i].UsedTime++
if m.AllReduceTask[i].UsedTime > 10 {
m.AllReduceTask[i].status = NOTALLOCATED
}
}
}
}
}
worker部分
//map任务:或许应该把所有的中间数据暂时放在内存中，完全结束之后再放在文件系统中。
func MapWorker(mapf func(string, string) []KeyValue, fileName string, MapId int) error {
file, err := os.Open(fileName)
if err != nil {
log.Fatalf("cannot open %v", fileName)
}
content, err := ioutil.ReadAll(file)
if err != nil {
log.Fatalf("cannot read %v", fileName)
}
file.Close()
kvRet := mapf(fileName, string(content)) //执行用户提供的Map函数，返回键值对
////将kv写入文件，并通知master///
ok, outFileNames := WriteToIntFile(kvRet, MapId) //写入到中间文件中去
if !ok {
fmt.Printf("mapTask %v failed.\n", MapId)
} else {
fmt.Printf("mapTask：%v finished.\n", MapId)
CallForMapFinishReply(outFileNames, MapId) //返回给master写入的文件名信息
}
return nil
}
//写入到中间文件中去
func WriteToIntFile(mapInterData []KeyValue, mapId int) (bool, []string) {
reduceNum := 10 //默认reducer的数量为10
//初始化一个二维切片
tmpInterData := make([][]KeyValue, reduceNum)
for i := range tmpInterData {
tmpInterData[i] = make([]KeyValue, reduceNum)
}
//将键值对写入到缓冲区中
for _, keyVal := range mapInterData {
reduceId := ihash(keyVal.Key) % reduceNum
tmpInterData[reduceId] = append(tmpInterData[reduceId], keyVal) //添加到缓冲区中
}
var outFileNames []string
for _, tmpKeyVals := range tmpInterData {
if len(tmpKeyVals) > reduceNum {
tmpKeyVals = tmpKeyVals[reduceNum:] //从第reduceNum开始为第一个元素
reduceId := ihash(tmpKeyVals[0].Key) % reduceNum
outFileName := "mr-" + strconv.Itoa(mapId) + "-" + strconv.Itoa(reduceId) //拼接输出的文件名 mr-X-Y
outFile, _ := os.OpenFile(outFileName, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0777)
enc := json.NewEncoder(outFile)
//一次写入
err := enc.Encode(tmpKeyVals) //写入到中间文件中
if err != nil {
fmt.Printf("write wrong!\n")
return false, outFileNames
}
//fmt.Printf("reduceId: %v num: %v\n",reduceId,len(tmpKeyVals))
outFile.Close()
outFileNames = append(outFileNames, outFileName)
}
}
return true, outFileNames
}
//reducer的任务详情
func ReduceWork(reducef func(string, []string) string, reduceId int, inputFileNames []string) bool {
var kva []KeyValue //保存从文件中读入的kv值
//读取所有reduceId匹配的文件
for _, inputFileName := range inputFileNames {
inputFile, err := os.OpenFile(inputFileName, os.O_RDONLY, 0777)
if err != nil {
fmt.Printf("open mr-*-%v file failed\n", reduceId)
}
//成批读入
dec := json.NewDecoder(inputFile)
for {
var tmpKv []KeyValue
if err := dec.Decode(&tmpKv); err != nil {
break
}
kva = append(kva, tmpKv...)
}
inputFile.Close() //关闭输入文件
}
//排序，是key值按照从小到大的顺序
sort.Sort(ByKey(kva))
//reduce操作后输出到不同的oname文件中去
oname := "mr-out-" + strconv.Itoa(reduceId)
ofile, err := ioutil.TempFile("./", "mr-out-tmp*") //先写道tmp文件中
if err != nil {
fmt.Printf("open tmp file failed\n")
return false
}
i := 0
for i < len(kva) {
j := i + 1
for j < len(kva) && kva[j].Key == kva[i].Key {
j++
}
values := []string{}
for k := i; k < j; k++ {
values = append(values, kva[k].Value)
}
output := reducef(kva[i].Key, values)
// this is the correct format for each line of Reduce output.
fmt.Fprintf(ofile, "%v %v\n", kva[i].Key, output)
i = j
}
ofile.Close()
os.Rename(ofile.Name(), oname) //Reduce操作，完成之后修改名字
//删除中间文件
for _, inputFileName := range inputFileNames {
os.Remove(inputFileName)
}
fmt.Printf("reduce task %v finished \n", reduceId)
CallForReduceFinishReply(reduceId) //通知master,编号为reduceId的任务已完成
return true
}
//
// main/mrworker.go calls this function.
//总体的worker调度函数
func Worker(mapf func(string, string) []KeyValue, reducef func(string, []string) string) {
var sleepTime int = 5 //睡眠时间
//执行map任务
for {
fileName, taskId, ok := CallForMapTask() //向master申请一个任务
if ok { //返回成功代表，Map任务还未完全处理完毕
MapWorker(mapf, fileName, taskId) //开启map进程,传入要操作的文件名
time.Sleep(time.Second * time.Duration(sleepTime))
} else { //所有的map任务已分派，但是还未完成
isAllMapTaskFinished := CallForAllMapFinishReply()
if isAllMapTaskFinished { //如果全部Map任务都结束了，跳出循环继续执行Reduce任务，否则继续循环
break
}else{
fmt.Printf("map:%v sleep for a while\n",taskId)
time.Sleep(time.Second * time.Duration(sleepTime)) //任务分配完毕，休息一会儿等待任务执行完毕
}
}
}
fmt.Printf("all map tasks finished!\n")
fmt.Printf("reduce tasks begin...\n")
//此处开始，可以执行reduce操作
for {
reduceId, inputFileNames, ok := CallForReduceTask() //向master请求Reduce任务
if ok { //返回成功代表reduce还未分配结束
fmt.Printf("ReduceId:%v running....\n", reduceId)
ReduceWork(reducef, reduceId, inputFileNames)
time.Sleep(time.Second * time.Duration(sleepTime))
} else { //返回失败，代表所有的任务都已经分配结束，但是还未完成
isFinished := CallForAllReduceFinishReply() //判断是否全部Reduce任务结束
if isFinished {
break
}else{
fmt.Printf("reduce:%v sleep for a while\n",reduceId)
time.Sleep(time.Second * time.Duration(sleepTime)) //任务分配完毕，休息一会儿等待任务执行完毕
}
}
}
fmt.Printf("all reduce tasks finished!\n")
CallAllTaskFinished() //通知master，所有任务都已经完成
}
结果
总结
稍微总结一点无关的内容，就是在做这个实验的时候，一开始一点头绪的没有，虽然基本了解paper的内容，但是，你懂的，感觉好庞大，好多内容，不知从哪开始。
后来，慢慢的，从实现一个小的功能开始，可以跑 word-count。到慢慢通过第一个测试，接着慢慢优化，最后通过所有的测试。
所以，我的感悟是对于一个重大的，庞大的，不知从何下手的任务，可以从小的地方开始，慢慢的，一点一点的，进而完成所有内容。