erlang mnesia 脏写的性能瓶颈和解决办法

mnesia脏写的话和脏读最大的区别是要同步数据，假如一个项目有3个节点A,B,C。在A节点脏写一个数据，这个操作需要2步，1,对本地节点的mnesia写入数据。2，对B,C两个节点发消息，告诉他们要脏写一个数据，然后等待他们回应，B,C两个节点全部返回确认消息后整个操作才算完成。

做了一下测试：

1.当单独一个节点时，并发100000个进程去脏写mnesia，平均每次的耗时是18微秒左右。

2.但是2个节点的话，并发100000个进程去脏写mnesia，平均每次的耗时是54微秒左右。

3.而3个节点的话，并发100000个进程去脏写mnesia，平均每次的耗时是82微秒左右。

也就是说同步这个操作就是脏读的瓶颈所在了，随着节点的增加，同步耗费的时间越高。

那么怎么解决这个问题呢？首先要明白mnesia的dirty_write的运行过程，才能找到解决办法。那么其他节点收到同步的信息后怎么处理的呢？

当A节点的dirty_write被调用后，会对包括自己在内的所有节点发送一个{From, {sync_dirty, Tid, Commit, Tab}}消息，然后mnesia_tm的进程收到后判断需要操作的表是否在被用，如果是blocked的话，则把操作放入一个dirty_queue里面存储在自己的state中。当mnesia_tm处理完一个请求后，就会给From发送一个确认消息。当A收到所有节点发回的确认后，dirty_write操作完成。

现在能改动的就是尽量减少blocked的情况出现，最好就是所有的同步请求都能及时处理然后回发确认。所以我们要分表，分表的越多，遇到同表锁住的情况越少。

分表后做了个测试：

1.还是3个节点，并且分3张表，并发100000个进程去脏写mnesia，平均每次的耗时是54微秒左右。

2.还是3个节点，并且分4张表，并发100000个进程去脏写mnesia，平均每次的耗时是28微秒左右。

由此看出，性能有较大的提升，证明分表是个不错的解决方案。

下面是测试的代码：

-module (test_mnesia_split).

-export ([start/0, dw/0, tdw/0, stop/0, dw1/0, tdw1/0]).

-record (test_mnesia, {userid, pid}).
-record (test_mnesia1, {userid, pid}).
-record (test_mnesia2, {userid, pid}).
-record (test_mnesia3, {userid, pid}).

start() ->
    NodeList = node_list(),
    rpc_call(mnesia, stop, [], stopped),
    mnesia:delete_schema(NodeList),
    mnesia:create_schema(NodeList),
    rpc_call(mnesia, start, [], ok),
    {atomic,ok} = mnesia:create_table(test_mnesia, [{ram_copies, NodeList},
                                                    {attributes, record_info(fields, test_mnesia)}]),
    {atomic,ok} = mnesia:create_table(test_mnesia1, [{ram_copies, NodeList},
                                                    {attributes, record_info(fields, test_mnesia1)}]),
    {atomic,ok} = mnesia:create_table(test_mnesia2, [{ram_copies, NodeList},
                                                    {attributes, record_info(fields, test_mnesia2)}]),
    {atomic,ok} = mnesia:create_table(test_mnesia3, [{ram_copies, NodeList},
                                                    {attributes, record_info(fields, test_mnesia3)}]),
    {atomic,ok} = mnesia:add_table_index(test_mnesia, pid),
    rpc_call(mnesia, stop, [], stopped).

stop() ->
    NodeList = node_list(),
    rpc_call(mnesia, stop, [], stopped),
    mnesia:delete_schema(NodeList).


dw() ->
    <<A:32, B:32, C:32>> = crypto:strong_rand_bytes(12),
    random:seed (A, B, C),
    Random = random:uniform(3),
    UserId = <<"user_1@android">>,
    mnesia:dirty_write(#test_mnesia{userid = UserId, pid = UserId}).

tdw() ->
    tc:ct(?MODULE, dw, [], 100000).

dw1() ->
    <<A:32, B:32, C:32>> = crypto:strong_rand_bytes(12),
    random:seed (A, B, C),
    Random = random:uniform(3),
    UserId = <<"user_1@android">>,
    case Random of
        1 ->
            mnesia:dirty_write(#test_mnesia1{userid = UserId, pid = UserId});
        2 ->
            mnesia:dirty_write(#test_mnesia2{userid = UserId, pid = UserId});
        3 ->
            mnesia:dirty_write(#test_mnesia3{userid = UserId, pid = UserId});
        _ ->
            mnesia:dirty_write(#test_mnesia{userid = UserId, pid = UserId})
    end.

tdw1() ->
    tc:ct(?MODULE, dw1, [], 100000).



%% ===================================================================
%% Internal functions
%% ===================================================================
node_list() ->
    [node() | nodes()].

rpc_call(Module, Function, Args, Result) ->
    rpc_call(node_list(), Module, Function, Args, Result).
rpc_call([H|T], Module, Function, Args, Result) ->
    Result = rpc:call(H, Module, Function, Args),
    rpc_call(T, Module, Function, Args, Result);
rpc_call([], _, _, _, _) ->
    ok.

?

erlang mnesia 脏写的性能瓶颈和解决办法

原文：http://wudixiaotie.iteye.com/blog/2236630