放在现在平台上快了好多：

[raindy@free01 erlang]$ erl -eval “prime:start(a, 100000).” -s c q -noshell
total running time: 80 ms
found primes number:0
[raindy@free01 erlang]$ erl -eval “prime:start(e, 100000).” -s c q -noshell
total running time: 2620 ms
found primes number:9592
[raindy@free01 erlang]$ date
Sat Sep 17 21:36:58 CST 2011

test(N)->
statistics(runtime),
All=run(N),
{_, T} = statistics(runtime),
io:format("Total running time: ~p ms ~n", [T]).
%%io:format("Total:~p running time: ~p ms ~n", [All,T]).

run(1) -> error;
run(2) -> [2];
run(N) when N rem 2 == 0 -> run(N-1);
run(N) -> findPrime(3,N,[2],false). %%直接从3开始,到N为止

findPrime(X, N, L,true) -> findPrime(X,N,[X-2|L],false);
findPrime(N, N, L,_) -> [N|L];
findPrime(X, N, L,false) -> findPrime(X+2,N,L,isPrimeInt(X,3,trunc(math:sqrt(X)+1))).

isPrimeInt(_, S, E) when S >= E -> true;
isPrimeInt(X, S, _) when X rem S == 0 -> false;
isPrimeInt(X, S, E) -> isPrimeInt(X, S+2, E).
[/code]

> echo:test(1000000).
Total: running time: 1859 ms

-module(make_prime).
-export([start/1]).

start(Num) ->
statistics(runtime),
Pl = mapreduce(Num),
{_, T} = statistics(runtime),
io:format(“total running time: ~p ms ~n”, [T]),
io:format(“primes total : ~p ~n”, [erlang:length(Pl)]).

mapreduce(Num) ->
Server = self(),
Ref = erlang:make_ref(),
Pids = prime_map(Server, Ref, 1, Num, []),
reduce(Pids, Ref, []).

get_end(Start, Num) when Start == Num ->
Num;
get_end(Start, Num) when Start
End = if
Start =
Start + 5000;
Start =
Start + 500;
Start =
Start + 300;
Start > 500000 ->
Start + 100
end,
if
End = End;
End > Num -> Num
end.

prime_map(Server, Ref, Start, Num, Pids) when Start =
End = get_end(Start, Num),
Pid = spawn( fun() -> do_prime(Server, Ref, Start, End) end ),
prime_map(Server, Ref, End+1, Num, [Pid|Pids]);

prime_map(_Server, _Ref, Start, Num, Pids) when Start > Num ->
Pids.

do_prime(Server, Ref, Start, End) ->
Primes = find_primes(Start, End, []),
Server ! {self(), Ref, Primes}.

find_primes(Start, End, Primes) when Start
case is_prime(Start, trunc(math:sqrt(Start)+1)) of
true ->
find_primes(Start+1, End, [Start|Primes]);
_ ->
find_primes(Start+1, End, Primes)
end;
find_primes(Start, End, Primes) when Start == End ->
case is_prime(Start, trunc(math:sqrt(Start)+1)) of
true ->
lists:reverse([Start|Primes]);
_ ->
lists:reverse(Primes)
end.

is_prime(1, _) -> false;
is_prime(2, _) -> true;
is_prime(Int, Sqrt) ->
is_prime(2, Int, Sqrt).
is_prime(N, Int, Sqrt) when N =
case Int rem N of
0 ->
false;
_ ->
is_prime(N+1, Int, Sqrt)
end;
is_prime(_, _, _) -> true.

reduce([Pid|T], Ref, Primes) ->
receive
{Pid, Ref, Ret} ->
reduce(T, Ref, append_list(Ret, Primes))
end;
reduce([], _, Primes) ->
Primes.

append_list([H|T], List) ->
append_list(T, [H|List]);
append_list([], List) ->
List.

refactor :
采用NIF实现素数求解的运行效率和C几乎差不多
http://cryolite.javaeye.com/blog/534368

Awesome !

mryufeng :
上面的列表操作会导致GC 所以如果你能在命令行上 加上 +h 999999 那么速度会快很多。

测试结果没能证明 +h 参数调节 heap size 能带来正面影响。


jackyz@ubuntu:~$ erl -eval "prime:start(c, 100000)." -s c q -noshell
total running time: 730 ms
found primes number:9592
jackyz@ubuntu:~$ erl +h 999999 -eval "prime:start(c, 100000)." -s c q -noshell
total running time: 770 ms
found primes number:9592
jackyz@ubuntu:~$ erl -eval "prime:start(e, 100000)." -s c q -noshell
total running time: 6960 ms
found primes number:9592
jackyz@ubuntu:~$ erl +h 999999 -eval "prime:start(e, 100000)." -s c q -noshell
total running time: 11950 ms
found primes number:9592


可以发现 +h 对分支 C 无明显效果，对分支 E 还会导致其更慢，在这里，可能 GC 并非关键。

例子本身的讨论就到这里，下面来讲一点虚的。

mryufeng :
这样的简单的数学计算 不符合 small message, big computaion的原则。 所以即使是多进程并行计算 收益也是很小的。
erlang的优势不在于计算，而在于完善的网络和服务器的编程模式， 已经平台和工具支持。 所以定位非常重要。
http://yufeng.info

这一句也正是我想引用的，而且还要再引申一下：

erlang 的确以一种尽可能高效的方式在语言级别提供了 message 这样一种编程设施，但归根结底 message 仍然是有代价的。“small message, big computation”这一指导原则的内在逻辑是——只有当 computation 的代价要明显的比 message 的代价高时，引入 message 的意义才能得以体现。否则，就没有意义(甚至还可能会产生反效果)。

这里的 message，我们也可以推而广之，将其外延扩展到其他(同样也是有代价的)语言设施，比如 list 。在我们做算法设计时，如果计划引入某种设计(保存结果以备重用)来进行优化，以降低部分的计算量(整除计算)。那么，非常有必要根据实际情况来评估这两个方案各自的性能代价。只有当引入某种设计的代价明显低于计算的代价时，这样的优化才是“真正的优化”，否则就有可能是“草率的优化”。

这里的“实际情况”并不是个虚头八脑装13的词。对于“求素数”这个例子而言，显然，在我们目前尝试的运算规模下(10万~100万以内的素数)，运算(整除)的代价，要远远低于引入设计(保存结果以备重用)的代价。因而，这个设计并没有获得它预期的优化效果。但是，如果我们的运算规模足够巨大。比如，假设你现在要给 CIA 写一个专门用来破解 RSA 算法的超级程序(PS. RSA 加密体系是建立在大素数的基础之上)。那么，我们可以预计，随着运算规模的不断膨胀，每次求素数计算的代价会不断的膨胀，终于，会在某个数量级时，其代价将会大于引入设计的代价。此时，在这种“实际情况”下，此前显得多余的设计，就会开始发挥作用。

从这个意义上说， Erlang 不能只当作一种单纯的计算机语言或技术来对待，它同时也可以意味着一些不同的软件思想，对于我们当中的大多数人来说，工作当中也许不一定用得上，但至少，是一种“有益的补充”。

erlang的优势不在于计算，而在于完善的网络和服务器的编程模式， 已经平台和工具支持。 所以定位非常重要。

http://yufeng.info

老大能不能这样去计算一下….

初学的想法…大家不要喷我…