6.824(2020春) Lab1:MapReduce

目录

  • 前言
    • 一、 概况
    • 代码
    • 结果
    • 总结

前言

本来不打算记录这个实验过程的,一是有点懒;二是没太多好说。后来还是耐着自己那膨胀的小性子,简单记录下这个实验。

一、 概况

本次的实验是6.824分布式课程提供的,其提供了主要的代码框架部分,我们需要做的就是理解MapReduce的原理,然后在框架内实现它。
6.824(2020春) Lab1:MapReduce_第1张图片
  整个实现的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。到慢慢通过第一个测试,接着慢慢优化,最后通过所有的测试。
所以,我的感悟是对于一个重大的,庞大的,不知从何下手的任务,可以从小的地方开始,慢慢的,一点一点的,进而完成所有内容。

你可能感兴趣的:(项目实践)