生成矩阵
命名模块，配置编译选项
-module(matrix_test).
-compile(export_all).
随机生成M*N矩阵
%% 随机产生M*N矩阵
generateMatrix(M,N) ->
row(M,N,[]).
row(M,N,Result) ->
case 0 =:= M of
true -> Result;
false -> row(M-1,N,Result++[column(N,[])])
end.
column(N,Result) ->
case 0 =:= N of
true -> Result;
false -> column(N-1,Result++[random:uniform(2)])
end.
测试,在erlang shell输入:
1> c(matrix_test).
[2,1,2,2,2]]
{ok,matrix_test}
2> matrix_test:generateMatrix(5,5).
[[2,1,1,1,1],
[2,2,1,1,2],
[1,2,2,1,2],
[1,1,2,2,2],
单线程实现
%% 单线程
matrixMultiply(A,B) ->
R = lists:foldl(fun(Element,Acc) -> Acc++[rowMultiplyColumn(Element,B,[],1)] end, [], A),
printMatrix(R,'C').
%%@param
% A,B:list
% Result:存放结果，初始为[]
% Count:控制列数,初始为1
% Result：存放结果，初始为[]
%%将某一行A与矩阵B相乘，得出一组向量
rowMultiplyColumn(A,B,Result,Count) ->
case Count =:= length(lists:nth(1,B))+1 of
true -> Result;
false ->
rowMultiplyColumn(A,B,Result ++ [multiply(A,getMatrixColumn(B,Count),0)],Count+1)
end.
%% 得到矩阵B的第Num列
getMatrixColumn(B,Num) ->
lists:foldl(fun(A,Acc) -> Acc++[lists:nth(Num, A)] end, [],B).
%% 计算两个向量List的数量积
multiply([H1|T1],[H2|T2],Sum) when length(T1) =:= length(T2) ->
multiply(T1,T2,Sum+H1*H2);
multiply([],[],Sum) -> Sum.
为便于查看,按一定格式打印矩阵
%
printMatrix(A,Name) ->
% P = fun(A, AccIn) -> io:format("~p ~n", [A]) end,
io:format("Matrix ~p is :~n",[Name]),
lists:foldl(fun printRow/2, [], A).
%
printRow(Row, AccIn) ->
io:format("| "),
P = fun(Row,AccIn) -> io:format(" ~p ", [Row]) end,
lists:foldl(P, [], Row),
io:format("| ~n").
测试入口:
%%
io:format("Single Thread:~p[ms]~n",[Time/1000]).
test(M,N,R) ->
A = generateMatrix(M,N),
B = generateMatrix(N,R),
printMatrix(A,'A'),
printMatrix(B,'B'),
{Time,Value} = timer:tc(matrix_test,matrixMultiply,[A,B]),
测试,在erlang shell输入:
1> c(matrix_test).
matrix_test.erl:10: Warning: variable 'Value' is unused
{ok,matrix_test}
2> matrix_test:test(5,5,5).
Matrix 'A' is :
|12211|
|12212|
|12111|
|12112|
|12221|
Matrix 'B' is :
|11122|
|21111|
|12212|
|22112|
|21211|
Matrix 'C' is :
| 11 10 10 8 11 |
| 13 11 12 9 12 |
| 10 8 8 7 9|
| 12 9 10 8 10|
| 13 12 11 9 13 |
Single Thread:0.619[ms]
ok
5*5矩阵相乘的单线程实现时间为0.619ms ,经检验,计算结果也正确。
多线程实现
由于要比较串行运算与并行运算的时间花销，所以将matrixMultiply的打印结果语句去掉，改为：
%% 单线程
matrixMultiply(A,B) ->
R = lists:foldl(fun(Element,Acc) -> Acc++[rowMultiplyColumn(Element,B,[],1)] end, [], A).
多线程实现矩阵相乘
%% 多线程
multiThread(A,B) ->
P = self(),
%% 启动矩阵A的行数个进程，分别发送A的每一行，计算A的每一行与矩阵B的乘积
lists:foldl(fun(Element,Acc) -> spawn(fun() -> P! {self(),Acc,rowMultiplyColumn(Element,B,[],1)} end) end, 1, A),
%% 接收，当前进程如果收到了A行数个消息，表明已经计算完毕
loop(length(A)).
%% 统计当前进程是否已经收到了Count条消息
loop(Count) ->
receive
{Pid,N,Result} ->
%% io:format("Count=~p,Message=~w~n",[Count,{Pid,N,Result}]),
case 1=:= Count of
true -> io:format("Compute end~n");
false -> loop(Count-1)
end
end.
矩阵相乘结果的正确性已经验证，打印高维矩阵意义不大，所以在测试入口将打印矩阵的语句去掉，并加入多线程运算：
%%测试入口
test(M,N,R) ->
A = generateMatrix(M,N),
B = generateMatrix(N,R),
% 串行运算
{Time,Value} = timer:tc(matrix_test,matrixMultiply,[A,B]),
io:format("Single Thread:~p[ms]~n",[Time/1000]),
% 并行运算
{Time1,Value1} = timer:tc(matrix_test,multiThread,[A,B]),
io:format("Multi Thread:~p[ms]~n",[Time1/1000]).
注意：为了你的笔记本，不要测试过高维的矩阵相乘。
测试，在erlang shell输入：
14> c(matrix_test).
matrix_test.erl:11: Warning: variable 'Value' is unused
{ok,matrix_test}
15> matrix_test:test(5,5,5).
Single Thread:0.033[ms]
Compute end
Multi Thread:0.121[ms]
ok
5*5矩阵相乘的单线程实现时间为0.033ms，多线程计算时间为0.121ms，造成多线程时间花销高于单线程的原因主要是计算量还较小，而建立线程的时间花销大于并行计算节省的时间。
进而测试100*100矩阵相乘：
19> matrix_test:test(100,100,100).
Single Thread:1507.563[ms]
Compute end
Multi Thread:836.394[ms]
ok
单线程实现时间为1507.563ms，多线程计算时间为836.394ms，由此可知多线程对高维矩阵运算的计算速度有所提高。
测试200*200矩阵相乘：
20> matrix_test:test(200,200,200).
Single Thread:25639.889[ms]
Compute end
Multi Thread:15294.531[ms]
ok
单线程实现时间为25639.889ms，多线程计算时间为15294.531ms，随着矩阵维度的增加，多线程的优势又下降了。
测试400*400矩阵相乘：
21> matrix_test:test(400,400,400).
当运行到多线程时，CPU负载达到400%以上，笔记本铝合金外壳都发黑了，着实吓出一身冷汗，迅速关闭终端，单线程运行的结果也就很遗憾地没有保存。所以大家还是不要在自己的笔记本上测试这个了。
