用Erlang实现MapReduce算法（一） - TonyHuang

由于cnblogs的代码着色系统不支持erlang，所以就直接从博客上贴过来了，如果大家看的不习惯的话，就直接来我的博客上看吧

本文章为本人个人博客相应文章的镜像：

原文地址： http://www.greatony.com/index.php/2010/03/21/mapreduce-algorithm-implemented-in-erlang-i/

Google曾经发过3篇引起巨大反响的论文：

这三篇论文对于大规模并行计算这个领域，无疑是三颗“小男孩”，就是在这三篇论文的基础上，有了著名的开源项目Apache Hadoop。
GFS是一个高性能、分布式、高可靠的文件存储系统，MapReduce是一种在大规模集群上，进行高效的并行计算的方法，而BigTable类似于分布式的数据库系统。

在本文中，我们讨论MapReduce算法的思想，以及如何在Erlang中实现一个简单、高效、可靠的MapReduce算法。

MapReduce算法

MapReduce算法讲大规模计算的过程分成了两个阶段：

Map阶段：在这个阶段，通过Map过程，将原始数据列表，处理成中间数据，用于Reduce过程的处理
Reduce阶段：将Map阶段产生的中间数据综合归纳成输出结果

这样说起来似乎比较抽象，我们用一个实例（好像是mr论文里面的例子，otz）来说明这个过程：
任务：我们现在有200篇文章，我们需要统计这200篇文章中，每一个英文单词都出现了几次。
Map阶段：这个阶段是分别针对每一篇文章的，统计出这一篇文章中，每个单词出现了几次。它的运算结果类似这样：
在第1篇文章中：找到了hello * 1, world * 1
在第2篇文章种：找到了hello * 1, tony * 1, huang * 1
...
Reduce阶段：这个阶段就是将上面的中间结果进行综合，它的运算结果类似这样：
在所有文章中，一共有：hello * 2, tony * 1, world * 1, huang * 1
所以，我们就会发现，我们很容易将Map过程分配到不同的计算机上执行（最简单的，每台机器计算一篇文章），而对于Reduce阶段也可以并行化（比如第一台机器Reduce1～4篇文章的数据，第二台机器Reduce5～8篇文章的数据，最后通过递归的reduce过程就可以把所有文章的数据整合在一起了）。
所以，这个算法非常有利于对巨大的数据的并行化处理（paper的副标题里就这么写的嘛）

Erlang实现 - 原型1

罗唆了那么久，终于讲到该如何实现这个算法了。
好了，首先，我们直接根据MapReduce的思想，利用erlang内置的lists库的函数来实现这个功能，代码如下：

1map_reduce(Map, Reduce, Source) ->
2    MapResult=lists:map(Map, Source),
3    lists:foldl(Reduce, [], MapResult).

哇，这也太简单了吧？！首先调用lists:map函数将原结果通过Map函数生成中间结果（MapResult），然后又通过foldl进行Reduce过程。
（电视购物的口气）没错，用Erlang就是那么简单！
观众：这样你不是在串行执行嘛？！MapReduce的优势一点也没有发挥出来嘛。
别着急嘛，这个是第一个原型嘛，下面我们就对它进行并行化的改造！

Erlang实现 - 原型2

在Erlang中实现并行化的最简单的方式（也是唯一的方式）当然就是进程（process）啦。所有的erlang大大们都教导我们，开erlang的进程的开销是很小的，所以，我们的思路就是针对源数据中的每一个元素创建一个map的进程，并发的执行map操作。同时呢，创建一个monitor进程去进行Reduce操作，最后再把最终结果返回给主进程。
ok，直接上代码：

01-module(emr).
02-export([map_reduce/3]).
03 
04% the monitor waiting for the map result, and then call the reduce to generate the final result
05monitor(ProcessPid, Result, Reduce, Count) ->
06    receive
07        MapResult ->
08            ReducedResult = Reduce(MapResult, Result),
09            case Count of
10                1 -> ProcessPid ! ReducedResult;
11                _ -> monitor(ProcessPid, ReducedResult, Reduce, Count - 1)
12            end
13    end.
14 
15% a delegate to send the map result to the monitor
16map(MonitorPid, Map, Element) -> MonitorPid ! Map(Element).
17 
18% the map-reduce main function
19map_reduce(_Map, _Reduce, []) -> [];
20map_reduce(Map, Reduce, List) ->
21    Self = self(),
22    Length = length(List),
23    MonitorPid = spawn(fun() -> monitor(Self, [], Reduce, Length) end),
24    lists:foreach(fun(Element) -> spawn(fun()->map(MonitorPid, Map,Element)end) end, List),
25    receive
26        Result -> Result
27    end.

这里的map_reduce函数首先创建一个monitor进程，去处理计算结果，然后针对源数据中的没一个元素创建一个map函数的进程，最后再等待monitor进程把最终的计算结果发送回来。
这里的map方法不是原始的Map函数，而是Map函数的一个马甲，map函数会把Map函数的计算结果发送给monitor进程。

测试1

写了这两个map_reduce函数，总得找点东西来测试一下吧？！，erlang的例子里面不是必然会出现阶乘函数嘛？！我们也就不要免俗了：

01-module(emr_test).
02-export([factorial/1, test/3, exec_test/4]).
03 
04% an algorithm function for test
05factorial(1) -> 1;
06factorial(N) -> N * factorial(N - 1).
07 
08% test a method on (Size) data for (Times) times, and give the {TotalTimeCost, AverageTimeCost}
09test(Method, Size, Times) ->
10    Map = fun(X) -> factorial(X) end,
11    Reduce = fun(MapResult, FinalResult) -> FinalResult ++ [MapResult]end,
12    Source = lists:seq(1, Size),
13    {TimeCost, _Result} = timer:tc(?MODULE, exec_test, [Map, Reduce,Method, Source]),
14    case Times of
15        1 -> {TimeCost, TimeCost};
16        N -> {OtherTimeCost, _OtherAvgTimeCost} = test(Method, Size, N - 1),
17             {TimeCost + OtherTimeCost, (TimeCost + OtherTimeCost) / N}
18    end.
19 
20% execute the real test progress
21exec_test(Map, Reduce, Method, Source) ->
22    case Method of
23        map_reduce -> emr:map_reduce(Map, Reduce, Source);
24        sequence -> AllMapResult = lists:map(Map, Source),
25                    lists:foldl(Reduce, [], AllMapResult)
26    end.

这里的factorial就是标准的阶乘函数，这里的test是为了方便测试运算速度的一个代理。第一个参数表示了用什么方法来进行计算（map_reduce表示并行计算，sequence表示串行计算，也就是原型1的方法），第2个参数表示要计算到几的阶乘，第3个参数表示要进行几次测试计算平均值。而exec_test就是具体进行计算的函数了。

这里放上我的测试环境和结果：
测试环境：
CPU：Intel Core 2 Quad Q9400S 2.66GHz (4 cores)
内存：Kingston 2GB DDR3 1333MHz * 2
操作系统：Apple Mac OS X Snow Leopard (10.6.2)
（没错拉，是黑苹果。。。）
计算1～10000的所有数的阶乘

测试结果：

1emr_test:test(sequence, 10000, 2).

总时间：361.98s，每次时间：180.99s

1emr_test:test(map_reduce, 10000, 2).

总时间：107.22s，每次时间：53.61s

观众们：这个还没有分布到其他计算机上呢～～～
不要着急嘛，下一篇文章，就讲如何分布到多台机器上。

posted on 2010-03-21 18:03 TonyHuang 阅读(1661) 评论(4) 编辑收藏举报

刷新页面返回顶部