anchor.diff:      [{Instance,[{Type1,N},{Type2,M}]} | average_group(Rest)].
   
   %% Get the total carrier size
  -carrier_size(Props, Keyword) ->
  -    Pos = key2pos(Keyword),
  -    SbcsProps = proplists:get_value(sbcs, Props),
  -    MbcsProps = proplists:get_value(mbcs, Props),
  -    Sbcs = element(Pos,lists:keyfind(carriers_size, 1, SbcsProps)),
  -    Mbcs = element(Pos,lists:keyfind(carriers_size, 1, MbcsProps)),
  +container_size(Props, Keyword, Container) ->
  +    Sbcs = container_value(Props, Keyword, sbcs, Container),
  +    Mbcs = container_value(Props, Keyword, mbcs, Container),
       Sbcs+Mbcs.
   
  -%% Get the total block size
  -block_size(Props, Keyword) ->
  -    Pos = key2pos(Keyword),
  -    SbcsProps = proplists:get_value(sbcs, Props),
  -    MbcsProps = proplists:get_value(mbcs, Props),
  -    Sbcs = element(Pos,lists:keyfind(blocks_size, 1, SbcsProps)),
  -    Mbcs = element(Pos,lists:keyfind(blocks_size, 1, MbcsProps)),
  -    Sbcs+Mbcs.
  +container_value(Props, Keyword, Type, Container)
  +  when is_atom(Keyword) ->
  +    container_value(Props, key2pos(Keyword), Type, Container);
  +container_value(Props, Pos, mbcs = Type, Container)
  +  when Pos == ?CURRENT_POS,
  +       ((Container =:= blocks) or (Container =:= blocks_size)
  +        or (Container =:= carriers) or (Container =:= carriers_size))->
  +    %% We include the mbcs pool into the value for mbcs
  +    Pool = case proplists:get_value(mbcs_pool, Props) of
  +               PoolProps when PoolProps =/= undefined ->
  +                   %% Mbcs Pool stats only exist pool is enabled
  +                   element(Pos,lists:keyfind(Container, 1, PoolProps));
  +               _ -> 0
  +           end,
  +    TypeProps = proplists:get_value(Type, Props),
  +    Pool + element(Pos,lists:keyfind(Container, 1, TypeProps));
  +container_value(Props, Pos, Type, Container)
  +  when Type =:= sbcs; Type =:= mbcs ->
  +    TypeProps = proplists:get_value(Type, Props),
  +    element(Pos,lists:keyfind(Container, 1, TypeProps)).
   
   %% Create a new snapshot
   snapshot_int() ->
  
positive.code:                     [{allocator(),pos_integer()}].
  memory(used,Keyword) ->
      lists:sum(lists:map(fun({_,Prop}) ->
                                  block_size(Prop,Keyword)
                          end,util_alloc()));
  memory(allocated,Keyword) ->
      lists:sum(lists:map(fun({_,Prop}) ->
                                  carrier_size(Prop,Keyword)
                          end,util_alloc()));
  memory(allocated_types,Keyword) ->
      lists:foldl(fun({{Alloc,_N},Props},Acc) ->
                          CZ = carrier_size(Props,Keyword),
                          orddict:update_counter(Alloc,CZ,Acc)
                  end,orddict:new(),util_alloc());
  memory(allocated_instances,Keyword) ->
      lists:foldl(fun({{_Alloc,N},Props},Acc) ->
                          CZ = carrier_size(Props,Keyword),
                          orddict:update_counter(N,CZ,Acc)
                  end,orddict:new(),util_alloc());
  memory(unused,Keyword) ->
  
negative.code: %% the worst the condition. The list is sorted accordingly.
  -spec sbcs_to_mbcs(max | current) -> [allocdata(term())].
  sbcs_to_mbcs(Keyword) ->
      WeightedList = [begin
        Sbcs = container_value(Props, Keyword, sbcs, blocks),
        Mbcs = container_value(Props, Keyword, mbcs, blocks),
        Ratio = case {Sbcs, Mbcs} of
          {0,0} -> 0;
          {_,0} -> infinity; % that is bad!
  