anchor.diff:                      [{allocator(),pos_integer()}].
   memory(used,Keyword) ->
       lists:sum(lists:map(fun({_,Prop}) ->
  -                                block_size(Prop,Keyword)
  +                                container_size(Prop,Keyword,blocks_size)
                           end,util_alloc()));
   memory(allocated,Keyword) ->
       lists:sum(lists:map(fun({_,Prop}) ->
  -                                carrier_size(Prop,Keyword)
  +                                container_size(Prop,Keyword,carriers_size)
                           end,util_alloc()));
   memory(allocated_types,Keyword) ->
       lists:foldl(fun({{Alloc,_N},Props},Acc) ->
  -                        CZ = carrier_size(Props,Keyword),
  +                        CZ = container_size(Props,Keyword,carriers_size),
                           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),
  +                        CZ = container_size(Props,Keyword,carriers_size),
                           orddict:update_counter(N,CZ,Acc)
                   end,orddict:new(),util_alloc());
   memory(unused,Keyword) ->
  
positive.code:     NewMbcsProp = [FactorFun(Prop) || Prop <- orddict:fetch(mbcs,Props)],
      NewSbcsProp = [FactorFun(Prop) || Prop <- orddict:fetch(sbcs,Props)],
      NewProps = orddict:store(sbcs,NewSbcsProp,
                               orddict:store(mbcs,NewMbcsProp,Props)),
      [{AI,NewProps}|conv_alloc(R,Factor)];
  conv_alloc([],_Factor) ->
      [].
  
  
negative.code:     [{Instance,[{Type1,N},{Type2,M}]} | average_group(Rest)].
  
  %% Get the total carrier size
  container_size(Props, Keyword, Container) ->
      Sbcs = container_value(Props, Keyword, sbcs, Container),
      Mbcs = container_value(Props, Keyword, mbcs, Container),
      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() ->
  