Mit6.824分布式系统课程 lab1 MapReduce

已于 2024-10-06 00:10:29 修改
阅读量696 收藏 15
点赞数 11
文章标签： mapreduce java go 分布式
于 2024-10-05 11:30:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nyf1007/article/details/142712288
版权

在此记录一下对6.824的学习过程

课程地址：​​​​​​​6.5840 Schedule: Spring 2024

个人实现参考：​​​​​​​​​​​​​​​​​​​​​https://github.com/NieYFeng/Mit-6.824-lab1-MapReduceicon-default.png?t=O83Ahttps://github.com/NieYFeng/Mit-6.824-lab1-MapReduce​​​​​​​

概述：

什么是分布式系统：多个计算机节点通过网络连接在一起，协同工作共同的任务，每个节点可以是物理上独立的计算机，但它们一起表现得像一个单一的系统

为什么要构建分布式系统：

  1. 可靠性：单一节点崩溃不影响全部系统

  2. 提高性能和处理能力：

  3. 负载均衡：大量请求分发

  4. 地理性：部署全球节点

Lab1：实现一个MapReduce分布式系统

MapReduce论文:https://static.googleusercontent.com/media/research.google.com/zh-CN//archive/mapreduce-osdi04.pdf

初始代码仓库：

git clone git://g.csail.mit.edu/6.5840-golabs-2024

任务要求和提示都可以在课程地址中找到。

image

论文中提供的思路：

  1. 输入数据分片与程序启动：

    • 将输入数据按块划分成 M 片（通常 16MB 到 64MB 每片，用户可调整），然后在集群上启动多个程序副本，其中一个是主节点，负责调度任务，其他是工作节点。

  2. 主节点分配任务：

    • 主节点（Master）负责分配任务。集群中有 M 个 Map 任务和 R 个 Reduce 任务。主节点选择空闲的工作节点，分配给它们 Map 或 Reduce 任务。

  3. Map 任务执行：

    • 被分配到 Map 任务的工作节点读取输入数据块，将其解析为键/值对，然后将其传递给用户定义的 Map 函数。产生的中间键/值对会暂时缓存在内存中。

  4. 中间数据的分区与存储：

    • 缓存的中间数据定期写入本地磁盘，并按 R 个分区函数进行划分。中间数据的存储位置会报告给主节点，主节点再将这些位置通知给 Reduce 任务。

  5. Reduce 任务读取中间数据：

    • Reduce 工作节点接到主节点通知后，通过远程过程调用（RPC）从 Map 工作节点的本地磁盘读取中间数据。读取完毕后，按照中间键对数据进行排序，确保相同键的所有数据分组到一起。如果数据过大，使用外部排序。

  6. Reduce 任务处理与输出：

    • Reduce 工作节点遍历排序后的中间数据，针对每个唯一的中间键，调用用户定义的 Reduce 函数，处理结果将追加到对应分区的最终输出文件中。

  7. 任务完成与程序返回：

    • 当所有 Map 和 Reduce 任务完成后，主节点通知用户程序任务已结束，MapReduce 调用返回结果。

记录一下完成实验中产生的问题和思考：

实现思路：

  1. 1、worker中根据mrsequential和课程hints来完成map和reduce操作

  2. func Worker(mapf func(string, string) []KeyValue,
	reducef func(string, []string) string) {
	for {
		workerId := registerWorker()
		go sendHeartbeat(workerId)
		args := TaskRequest{WorkerState: Idle, WorkerId: workerId}
		reply := TaskResponse{}
		call("Coordinator.AllocateTasks", &args, &reply)
		// 如果任务类型为 idle，休眠一段时间，避免频繁请求
		if reply.TaskType == "idle" {
			time.Sleep(3 * time.Second)
			continue
		}
		if reply.TaskType == "map" {
			doMapWork(reply.FileName, mapf, reply.MapId, reply.NReduce)
			args = TaskRequest{WorkerState: MapFinished, WorkerId: workerId, FileName: reply.FileName}
			call("Coordinator.AllocateTasks", &args, &reply)
		} else {
			doReduceWork(reply.ReduceId, reducef, reply.MapCounter)
			args = TaskRequest{WorkerState: ReduceFinished, WorkerId: workerId, ReduceId: reply.ReduceId}
			call("Coordinator.AllocateTasks", &args, &reply)
		}
	}
}
    func doMapWork(filename string, mapf func(string, string) []KeyValue, mapId int, n int) {
	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()
	kvs := mapf(filename, string(content))
	intermediateFiles := make([]*os.File, n)
	encoders := make([]*json.Encoder, n)
	for i := 0; i < n; i++ {
		name := fmt.Sprintf("mr-%d-%d", mapId, i)
		intermediateFiles[i], err = os.Create(name)
		if err != nil {
			log.Fatalf("cannot create file %v", name)
		}
		encoders[i] = json.NewEncoder(intermediateFiles[i])
		defer intermediateFiles[i].Close()
	}
	for _, kv := range kvs {
		reduceId := ihash(kv.Key) % n
		err := encoders[reduceId].Encode(&kv)
		if err != nil {
			log.Fatalf("cannot encode kv pair: %v", err)
		}
	}
}
    func doReduceWork(reduceId int, reducef func(string, []string) string, n int) {
	intermediate := []KeyValue{}
	for i := 0; i < n; i++ {
		name := fmt.Sprintf("mr-%d-%d", i, reduceId)
		file, err := os.Open(name)
		if err != nil {
			log.Fatalf("cannot open file %v", name)
		}
		dec := json.NewDecoder(file)
		for {
			var kv KeyValue
			if err := dec.Decode(&kv); err != nil {
				if err == io.EOF {
					break
				} else {
					log.Fatalf("Decode error: %v", err)
				}
			}
			intermediate = append(intermediate, kv)
		}
		file.Close()
	}
	sort.Sort(ByKey(intermediate))
	oname := fmt.Sprintf("mr-out-%d.txt", reduceId)
	ofile, _ := os.Create(oname)
	i := 0
	for i < len(intermediate) {
		j := i + 1
		for j < len(intermediate) && intermediate[j].Key == intermediate[i].Key {
			j++
		}
		values := []string{}
		for k := i; k < j; k++ {
			values = append(values, intermediate[k].Value)
		}
		output := reducef(intermediate[i].Key, values)
		fmt.Fprintf(ofile, "%v %v\n", intermediate[i].Key, output)
		i = j
	}
}

  3. 2、coordinator负责分发任务，主要是根据worker状态和管道任务数量分发

  4. func (c *Coordinator) AllocateTasks(args *TaskRequest, reply *TaskResponse) error {
	workerId := args.WorkerId
	reply.NReduce = c.taskReduce
	c.mutex.Lock()
	defer c.mutex.Unlock()
	if args.WorkerState == Idle {
		if len(c.mapCh) > 0 {
			task := <-c.mapCh
			filename := task.FileName
			c.mapState[filename] = Allocated
			reply.TaskType = "map"
			reply.FileName = filename
			reply.MapId = task.MapId
			c.workerTasks[workerId] = TaskInfo{"map", filename, task.MapId}
			c.checkHeartBeat(workerId)
			return nil
		} else if len(c.reduceCh) != 0 && c.mapFinished == true {
			reduceId := <-c.reduceCh
			c.reduceState[reduceId] = Allocated
			reply.TaskType = "reduce"
			reply.ReduceId = reduceId
			reply.MapCounter = c.mapCounter
			c.workerTasks[workerId] = TaskInfo{"reduce", strconv.Itoa(reduceId), -1}
			c.checkHeartBeat(workerId)
			return nil
		}
	} else if args.WorkerState == MapFinished {
		c.mapState[args.FileName] = Finished
		if checkMapTask(c) {
			c.mapFinished = true
		}
	} else if args.WorkerState == ReduceFinished {
		c.reduceState[args.ReduceId] = Finished
		if checkReduceTask(c) {
			c.reduceFinished = true
		}
	}
	reply.TaskType = "idle"
	return nil
}

  5. 3、通过心跳机制检查worker是否崩溃，包括重新分发任务给管道

  6. func (c *Coordinator) checkHeartBeat(workerId int) {
	go func() {
		for {
			time.Sleep(5 * time.Second)
			c.mutex.Lock()
			now := time.Now()
			if lastHeartbeat, ok := c.workerHeartbeats[workerId]; ok {
				// 检查心跳超时
				if now.Sub(lastHeartbeat) > 10*time.Second {
					delete(c.workerHeartbeats, workerId)
					// 任务重新分配
					if taskInfo, ok := c.workerTasks[workerId]; ok {
						value, _ := strconv.Atoi(taskInfo.Value)
						if taskInfo.TaskType == "map" && c.mapState[taskInfo.Value] != Finished {
							c.mapCh <- MapTask{taskInfo.MapId, taskInfo.Value} // 将 map 任务重新放回队列
							c.mapState[taskInfo.Value] = UnAllocated
						} else if taskInfo.TaskType == "reduce" && c.reduceState[value] != Finished {
							id, err := strconv.Atoi(taskInfo.Value)
							if err != nil {
								log.Printf("Failed to convert value to int: %v", err)
								continue
							}
							c.reduceCh <- id // 将 reduce 任务重新放回队列
							c.reduceState[id] = UnAllocated
						}
						delete(c.workerTasks, workerId) // 移除该 worker 的任务记录
					}
				}
			}
			c.mutex.Unlock()
		}
	}()
}

  7. 4、RPC中定义coordinator和worker的交互参数

  8. const (
	MapFinished = iota
	ReduceFinished
	Idle
)

type RegisterArgs struct {
	WorkerId int
}

type RegisterReply struct {
	WorkerId int
}

type HeartRequest struct {
	WorkerId int
}

type HeartReply struct {
}

type TaskRequest struct {
	WorkerState int
	WorkerId    int
	FileName    string
	ReduceId    int
}

type TaskResponse struct {
	TaskType   string
	FileName   string
	ReduceId   int
	MapId      int
	MapCounter int
	NReduce    int
}

中间文件：

("hello", "1")
("world", "1")
("hello", "1")
("foo", "1")
("bar", "1")
("foo", "1")

处理后：

kvs = {
  "hello": ["1", "1"],
  "world": ["1"],
  "foo":   ["1", "1"],
  "bar":   ["1"]
}

reducef：

result = {
    "hello": "2",
    "world": "1",
    "foo":   "2",
    "bar":   "1"
}

问题1：管道缓冲问题，对go中的管道特性不了解导致的

问题2：dialing:dial unix /var/tmp/5840-mr-1000: connect: connection refused（这应该是访问coordinator时没反应挂起，提示里写到出现少量的这样的报错是正常的，包括我最后的结果里也有这样的报错）

问题3: crash-test中fail，原因：

if args.WorkerState == Idle {
    if len(c.mapCh) > 0 {
      filename := <-c.mapCh
      c.mapState[filename] = Allocated
      reply.TaskType = "map"
      reply.FileName = filename
      reply.MapId = c.generateMapId()
      c.workerTasks[workerId] = TaskInfo{"map", filename}
      log.Printf("mapCh length: %d", len(c.mapCh))
      c.checkHeartBeat(workerId)
      return nil
    }
  
func (c *Coordinator) generateMapId() int {
  c.mapCounter++ 
  return c.mapCounter
}

如果worker崩溃，mapId会被重新生成，生成的中间文件名称就会出现问题，如，原本的mr-1-0，因为worker中途崩溃导致文件没有生成，因为重新添加至队列，当再取出该任务时，重新赋值id导致中间文件名称变为mr-9-0，reduce找不到对应文件。

考虑2种解决方案：

1、原先map管道中存储的是filename，维护一个哈希表，保证filename对应正确的mapId使中间文件生成的更加正确

2、将管道中的任务换成存储一个含MapId的结构，当worker崩溃时，将该任务重新添加进管道保证正确性

最后选择第二种

实验的总结和反思：

  经过多次调试之后终于将lab1结束了，在写这个lab中我认识到自己缺乏对项目总体的设计，当时的我希望赶紧上手，没有都想清楚再开始写，遇到什么问题属于是现加现解决，导致一部分代码看起来比较臃肿。

栩栩如枫
关注
MIT6.824分布式系统的C++版本实现
01-10
MIT6.824分布式系统的C++版本实现，能学到分布式系统设计、rpc使用、mapreduce、基本数据库设计、raft算法、分布式一致性等后端知识点，结合了linux系统的许多系统调用。所有源码均经过严格测试，可以直接运行，可以...
MIT6.824-2017-Chinese:MIT 6.824（分布式系统）的中文版
03-11
6.824是用Go语言实现的一个简单的分布式系统。学习该课程可以让你对分布式系统原理有一个广泛深入的认识。 在开始学习之前，最好能拥有一定的计算机网络以及操作系统的知识。 之所以选择这一门课，我主要有以下几个...
6.824:MIT 6.824分布式系统的实现
03-11
实施，分布式系统，2014年Spring。 分布式系统很棘手...很多角落的情况下，正确和良好的设计并不容易。 实验1：mapreduce，熟悉golang。 实验2：主/备份键/值服务，配置被更改为视图。 实验3：基于paxos和基于...
MIT6.824分布式系统的C++版本实现.zip
01-15
MIT6.824分布式系统的C++版本实现，能学到分布式系统设计、rpc使用、mapreduce、基本数据库设计、raft算法、分布式一致性等后端知识点，结合了linux系统的许多系统调用 软件开发设计：应用软件开发、系统软件开发、...
MIT6.824-2018-Chinese:MIT 6.824（分布式系统）的中文版
03-11
MIT6.824-2018-中文MIT 6.824（分布式系统）的中文版有关详细信息，请参见 。介绍之前的项目（ ）由于个人原因（懒狗一条，外加毕业和工作的事）虎头蛇尾地扔在了一边。最近突然翻出来一看，觉得自己写的真的很shi。...
mit6824-01-MapReduce详解
FLJS_T的博客
09-29 912
在远程读取进程中，文件是否会传输到reducer？会。map函数产生的中间结果存放在执行map函数的worker机器的磁盘上，而之后解调器分配文件给reducer执行reduce函数时，中间结果数据需要通过网络传输到reducer机器上。这里其实很少有网络通信，因为一个worker在一台机器上，而每台机器同时运行着worker进程和GFS进程。
(undone) 阅读 MapReduce 论文笔记
shimly123456的博客
09-28 398
参考：https://pdos.csail.mit.edu/6.824/papers/mapreduce.pdf。
Hadoop三大组件之MapReduce（二）
m0_58076578的博客
09-28 8367
在HDFS（Hadoop Distributed File System）中，数据块是物理上将数据分成一块块的单位，是HDFS存储数据的基本单位。数据切片是在逻辑上对输入数据进行分块，它并不代表在磁盘上的物理切分。数据切片是MapReduce程序计算输入数据的单位，每个切片会对应启动一个MapTask。环形缓冲区是为了解决数据传输和处理效率而设计的，它在Map和Reduce阶段之间扮演着至关重要的角色。是MapReduce中默认的输入格式，负责将输入数据划分为切片。默认情况下，切片大小等于Block大小。
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 924
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 446
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 855
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 553
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 803
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 342
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1113
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 886
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
第十三届蓝桥杯真题Java 斐波那契与7(持续更新)
音符犹如代码的博客
09-29 330
这是一道结果填空的题, 你只需要算出结果后提交即可。本题的结果为一 个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。斐波那契数列的递推公式为: Fn=Fn−1+Fn−2Fn​=Fn−1​+Fn−2​, 其中 F1=F2=1F1​=F2​=1。请问, 斐波那契数列的第 1 至 202202011200 项（含）中, 有多少项的个位 是 7。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1245
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 387
记忆中，两个指针合并即可。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值