anchor.diff:      RingSize  = length(CurRing),
       GroupSize = leo_math:ceiling(RingSize / ?DEF_NUM_OF_DIV),
   
  -    {_,_,Index,Ring} =
  +    {_,_,Ring,_} =
           lists:foldl(
  -          fun({VNodeId, _Node}, {Id, GId, IdxAcc, TblAcc}) ->
  -                  case redundancies(ETS_Tbl, VNodeId, NumOfReplicas, NumOfAwarenessL2, Members) of
  +          fun({AddrId, _Node}, {Id, GId, IdxAcc, TblAcc}) ->
  +                  case redundancies(ETS_Tbl, AddrId, NumOfReplicas, NumOfAwarenessL2, Members) of
                         {ok, #redundancies{nodes = Nodes}} ->
                             case (GId == GroupSize) of
  -                              true  -> {Id - 1, 0,
  -                                        [{Id, VNodeId}|IdxAcc], [{Id, VNodeId, Nodes}|TblAcc]};
  -                              false -> {Id - 1, GId + 1,
  -                                        IdxAcc,                 [{Id, VNodeId, Nodes}|TblAcc]}
  +                              true ->
  +                                  RingGroup = [#addrid_nodes{id = Id,
  +                                                             addr_id = AddrId,
  +                                                             nodes   = Nodes}|TblAcc],
  +                                  #addrid_nodes{id = LastId,
  +                                                addr_id = LastAddrId} = lists:last(TblAcc),
  +                                  {Id - 1, 0,
  +                                   [#ring_group{index_from = {Id, AddrId},
  +                                                index_to   = {LastId, LastAddrId},
  +                                                addrid_nodes_list = RingGroup}|IdxAcc], []};
  +                              false ->
  +                                  {Id - 1, GId + 1, IdxAcc,
  +                                   [#addrid_nodes{id = Id,
  +                                                  addr_id = AddrId,
  +                                                  nodes   = Nodes}|TblAcc]}
                             end
                     end
             end, {RingSize, 0, [], []}, lists:reverse(CurRing)),
  -    ?debugVal({Index,Ring}),
  -    {ok, {Checksum, lists:reverse(Index), length(Ring), Ring}}.
  +
  +    %% @TODO - debug (unnecessary-codes)
  +    %% lists:foreach(fun(#ring_group{index_from = From,
  +    %%                               index_to   = To,
  +    %%                               addrid_nodes_list = List}) ->
  +    %%                       ?debugVal({From, To}),
  +    %%                       lists:foreach(fun(AddrId_Nodes) ->
  +    %%                                             ?debugVal(AddrId_Nodes)
  +    %%                                     end, List)
  +    %%               end, Ring),
  +    {ok, {Checksum, Ring}}.
   
   
   %% @doc get redundancies by key.
  
positive.code:     N  = leo_misc:get_value(?PROP_N,  Options),
      L2 = leo_misc:get_value(?PROP_L2, Options, 0),
  
      {ok, {Checksum, Index, RingSize, Ring}} =
          gen_routing_table(?SYNC_MODE_PREV_RING, N, L2, Members),
      NewState = State#state{prev = #routing_table{checksum = Checksum,
                                                   index    = Index,
                                                   rows     = RingSize,
                                                   table    = Ring}},
      {reply, ok, NewState};
  
  
  
negative.code: 
  -define(DEF_NUM_OF_DIV, 32).
  
  -record(addrid_nodes, {
            id = 0        :: integer(),
            addr_id = 0   :: integer(),
            nodes         :: list(atom())
           }).
  
  -record(ring_group, {
            index_from    :: tuple(integer(),integer()),
            index_to      :: tuple(integer(),integer()),
            addrid_nodes_list :: list(#addrid_nodes{})
           }).
  
  -record(ring_info, {
            %% index = []    :: list(pos_integer()),
            %% table = []    :: list(),
            %% rows  = -1    :: integer(),
            %% min_addr_id   :: integer(),
            %% max_addr_id   :: integer(),
            checksum = -1 :: integer(),
            ring_group_list  :: list(#ring_group{})
           }).
  
  -record(state, {
            cur  = #ring_info{} :: #ring_info{},
            prev = #ring_info{} :: #ring_info{},
            min_interval = ?DEF_SYNC_MIN_INTERVAL :: pos_integer(),
            max_interval = ?DEF_SYNC_MAX_INTERVAL :: pos_integer(),
            timestamp = 0 :: pos_integer()
           }).
  
  %%--------------------------------------------------------------------
  %% API
  