MIT 6.824 分布式系统 lab1 MapReduce 遇到死锁问题

记录学习6.824的lab1遇到的坑（死锁了）

代码逻辑借鉴：https://blog.csdn.net/weixin_45938441/article/details/124018485

问题描述

目前处于编写worker与coordinate进行RPC通信的环节，worker中的Map和Reduce方法还都没有开动只有一个打印逻辑，只是想先测一下，worker和coordinate之间能否正常通信。随后在map阶段，worker端可以正常拿到task信息，但是一切换到reduce阶段，程序就发生了死锁，情况如下。

以上是map阶段的程序运行结果，左边是coordinator端，右边是worker端，coordinator可以正常创建task，worker可以正常拿到task，并且进行打印

到了reduce阶段之后是这样的

正常创建了任务，但是之后就一动不动了。。。。。。

解决历程

发生死锁的程序如下

coordinator

package mr

import (
	"fmt"
	"log"
	"sync"
	"time"
)
import "net"
import "os"
import "net/rpc"
import "net/http"

type TaskPhase int
type TaskStatus int

const (
	MAP_PHASE    TaskPhase = 0
	REDUCE_PHASE TaskPhase = 1
)

const (
	// 刚创建还没有进入到队列中
	CREATE TaskStatus = 0
	// 进入到队列中，但是还没有被worker获取到的状态
	PREPARE TaskStatus = 1
	// 正在运行中
	RUNNING TaskStatus = 2
	// 运行失败
	FAILED TaskStatus = 3
	// 完成
	COMPLETE TaskStatus = 4
)

const (
	// 任务超过10秒就算失败
	TASK_TIMEOUT = time.Second * 10
	// 定时扫描任务队列状态的时间间隔
	SCHEDULE_TIME = time.Second
)

type Task struct {
	// 任务处理的文件名
	FileName string
	// 任务的序列号
	SeqId int
	// 任务的workerid
	WorkerId int
	// 任务是否可用
	IsAlive bool
	// 任务阶段
	TaskPhase TaskPhase
}

type TaskState struct {
	// 任务开始时间
	StartTime time.Time
	// 任务状态
	Status TaskStatus
	// 任务序列
	SeqId int
	// 任务名
	FileName string
	// workerId
	WorkerId int
}

type Coordinator struct {

	// map的数量
	MapNumber int

	// reduce的数量
	ReduceNumber int

	// 任务队列
	TaskList chan Task

	// 任务状态
	TaskStates []TaskState

	// 任务阶段
	TaskPhase TaskPhase

	// 锁
	lock sync.Mutex

	// Worker的序列号
	WorkerSeq int

	// 是否完成
	done bool
}

// start a thread that listens for RPCs from worker.go
func (c *Coordinator) server() {
	rpc.Register(c)
	rpc.HandleHTTP()
	//l, e := net.Listen("tcp", ":1234")
	sockname := coordinatorSock()
	os.Remove(sockname)
	l, e := net.Listen("unix", sockname)
	if e != nil {
		log.Fatal("listen error:", e)
	}
	go http.Serve(l, nil)
}

// main/mrcoordinator.go calls Done() periodically to find out
// if the entire job has finished.
func (c *Coordinator) Done() bool {
	c.lock.Lock()
	defer c.lock.Unlock()
	return c.done
}

func (c *Coordinator) schedule() {
	for {
		//utils.DPrintf("scheduling ...\n")
		fmt.Println("scheduling ...")
		c.scanOneSchedule()
		time.Sleep(SCHEDULE_TIME)
		if c.done {
			return
		}
	}
}

func (c *Coordinator) scanOneSchedule() {
	c.lock.Lock()
	defer c.lock.Unlock()
	allDone := true
	for index, state := range c.TaskStates {
		status := state.Status
		if status == CREATE {
			allDone = false
			c.TaskList <- c.CreateNewTask(index, state)
			c.TaskStates[index].Status = PREPARE
		} else if status == PREPARE {
			allDone = false
		} else if status == RUNNING {
			// 检测运行时间
			allDone = false
			if time.Now().Sub(state.StartTime) > TASK_TIMEOUT {
				// 如果超时，直接重发
				c.TaskList <- c.CreateNewTask(index, state)
				c.TaskStates[index].Status = PREPARE
			}
		} else if status == FAILED {
			// 运行失败了
			allDone = false
			c.TaskList <- c.CreateNewTask(index, state)
			c.TaskStates[index].Status = PREPARE
		} else if status == COMPLETE {
			fmt.Printf("task %s\n", state.FileName)
		} else {
			panic("task status is error")
		}
	}

	if allDone {
		if c.TaskPhase == MAP_PHASE {
			c.TaskPhase = REDUCE_PHASE
			// 切换状态
			c.TaskStates = make([]TaskState, c.ReduceNumber)
		} else {
			c.done = true
		}
	}

}

func (c *Coordinator) CreateNewTask(seqId int, state TaskState) Task {
	task := Task{
		FileName:  "",
		SeqId:     seqId,
		IsAlive:   true,
		TaskPhase: c.TaskPhase,
	}
	if c.TaskPhase == MAP_PHASE {
		task.FileName = state.FileName
	}
	fmt.Printf("create new task, +%v\n", task)
	return task
}

// create a Coordinator.
// main/mrcoordinator.go calls this function.
// nReduce is the number of reduce tasks to use.
func MakeCoordinator(files []string, nReduce int) *Coordinator {
	c := Coordinator{
		MapNumber:    len(files),
		ReduceNumber: nReduce,
		TaskPhase:    MAP_PHASE,
		TaskStates:   make([]TaskState, len(files)),
		TaskList:     make(chan Task, len(files)),
		WorkerSeq:    0,
		done:         false,
	}

	// 根据文件创建任务队列
	// 初始化
	for i := 0; i < len(files); i++ {
		c.TaskStates[i] = TaskState{
			StartTime: time.Now(),
			Status:    CREATE,
			SeqId:     i,
			FileName:  files[i],
		}
	}

	// 定时扫描队列
	go c.schedule()

	// Your code here.
	// 查看文件信息
	c.server()
	fmt.Println("master init~")
	return &c
}

rpc

package mr

//
// RPC definitions.
//
// remember to capitalize all names.
//

import (
	"errors"
	"fmt"
	"log"
	"net/rpc"
	"os"
	"time"
)
import "strconv"

// Cook up a unique-ish UNIX-domain socket name
// in /var/tmp, for the coordinator.
// Can't use the current directory since
// Athena AFS doesn't support UNIX-domain sockets.
func coordinatorSock() string {
	//s := "/var/tmp/5840-mr-"
	s := "E:\\project\\tmp\\5840-mr-"
	s += strconv.Itoa(os.Getuid())
	return s
}

type RegArgs struct {
	WorkerId int
}

type RegReply struct {
}

func (w *worker) register() {
	fmt.Println("注册")
	args := &RegArgs{}
	reply := &RegReply{}
	err := call("Coordinator.RegWorker", args, reply)
	if !err {
		log.Fatal("worker register error!", err)
	}
	w.WorkerId = args.WorkerId
}

type TaskArgs struct {
	// work节点的id
	WorkerId int
}

type TaskReply struct {
	Task *Task
}

func (w *worker) getTask() (*Task, error) {
	fmt.Println("获取task")
	args := &TaskArgs{WorkerId: w.WorkerId}
	reply := &TaskReply{}
	res := call("Coordinator.GetOneTask", args, reply)
	if !res {
		return nil, errors.New("worker getTask error!")
	}
	return reply.Task, nil
}

type ReportArgs struct {
	// 任务的运行结果
	Result bool
	// 任务阶段
	TaskPhase TaskPhase
	// workerID
	WorkerId int
	// 任务
	Task Task
}

type ReportReply struct {
}

func (w *worker) reportTask(task Task, res bool) error {
	fmt.Printf("通知master, %v的执行结果\n", task)
	args := &ReportArgs{
		Result:    res,
		TaskPhase: task.TaskPhase,
		WorkerId:  w.WorkerId,
		Task:      task,
	}
	reply := &ReportReply{}
	err := call("Coordinator.Report", args, reply)
	if err {
		return errors.New("report task failed!")
	}
	return nil
}

/*
*
进行rpc通信，返回是否成功通信
*/
func call(rpcname string, args interface{}, reply interface{}) bool {
	sockname := coordinatorSock()
	conn, err := rpc.DialHTTP("unix", sockname)
	if err != nil {
		log.Fatal("dialing: ", err)
	}
	// 离开之前关闭连接
	defer conn.Close()

	// 调用方法
	err = conn.Call(rpcname, args, reply)
	if err != nil {
		fmt.Println(err)
		return false
	}
	return true
}

func (c *Coordinator) RegWorker(args *RegArgs, reply *RegReply) error {
	fmt.Println("worker reg!")
	c.lock.Lock()
	defer c.lock.Unlock()
	args.WorkerId = c.WorkerSeq
	c.WorkerSeq++
	return nil
}

func (c *Coordinator) GetOneTask(args *TaskArgs, reply *TaskReply) error {
	fmt.Printf("GetOneTask, workerId is %d\n", args.WorkerId)
	fmt.Printf("taskList len is %d\n", len(c.TaskList))

	task := <-c.TaskList
	task.WorkerId = args.WorkerId
	reply.Task = &task

	fmt.Printf("get Task is %v\n", task)
	if !task.IsAlive {
		// 如果当前任务是不可用的
		fmt.Printf("task not alive, task is %v\n", task)
		return errors.New("task not alive")
	}
	if task.TaskPhase != c.TaskPhase {
		// 当前任务的阶段不是已经切换过来的阶段
		fmt.Printf("task phase not truth, jump it\n")
		return errors.New("task phase not truth jump")
	}
	if c.TaskStates[task.SeqId].Status != PREPARE {
		// 任务不是prepare直接不能拿
		fmt.Printf("new task must prepare, task %v\n", task)
		return errors.New("task mush prepare")
	}
	c.lock.Lock()
	// 修改对应任务的状态
	c.TaskStates[task.SeqId].Status = RUNNING
	c.TaskStates[task.SeqId].StartTime = time.Now()
	c.TaskStates[task.SeqId].WorkerId = args.WorkerId
	c.lock.Unlock()

	return nil
}

func (c *Coordinator) Report(args *ReportArgs, reply *ReportReply) error {
	c.lock.Lock()
	defer c.lock.Unlock()
	seqId := args.Task.SeqId
	// 如果发现当前阶段不一致，或者当前的任务已经分配给了其他任务
	if c.TaskPhase != args.TaskPhase || c.TaskStates[seqId].WorkerId != args.WorkerId {
		fmt.Printf("in report task, workerId = %v report a useless task = %v\n", args.WorkerId, args.Task)
		return errors.New("task report error")
	}
	if args.Result {
		// 任务执行成功了
		// 修改任务状态
		c.TaskStates[seqId].Status = COMPLETE
	} else {
		// 任务执行失败
		c.TaskStates[seqId].Status = FAILED
	}
	go c.scanOneSchedule()
	return nil
}

当切换至Reduce阶段后，执行到GetOneTask方法的c.lock.Lock()之后，协程就停了，之后会跳到每隔一秒刷新状态的协程中，即方法scanOneSchedule中，之后程序就彻底死锁了，因此，猜测问题的切入口应该是在这两个方法中寻找，必然是哪里出现了逻辑错误，导致释放锁程序没有执行。

经调试后发现，问题出现在这里，如下。

当程序切换至Reduce阶段，TaskStates的长度会由8切换至10，但是TaskList长度在初始化时，就设定为了8，因此会出现异常，导致后续的Unlock()逻辑无法触发导致死锁。

解决方案

在初始化阶段设置TaskList长度的时候，判断map的长度和reduce的长度，如果哪个更长，就用哪个去初始化TaskList，程序如下.

由于不熟悉Go语言(一天速成)，导致寻找bug的过程花了很长时间，在此记录一下。

得出的结论是，果然释放锁的程序无论如何一定要执行，得放finally中。