anchor.diff:  	      #alloc{name = A,
   		     alloc_util = true,
   		     instances = Insts,
  +		     acul = Acul,
  +		     strategy = Strategy,
   		     low_mbc_blocks_size = Low,
   		     high_mbc_blocks_size = High} = Alc) ->
       fcp(FTO, "Usage of mbcs: ~p - ~p kilobytes", [?B2KB(Low), ?B2KB(High)]),
  
positive.code: conf_size(Bytes) when is_integer(Bytes), Bytes < 0 ->
      exit({bad_value, Bytes});
  conf_size(Bytes) when is_integer(Bytes), Bytes < 1*?MB ->
      ?ROUNDUP(?B2KB(Bytes), 128);
  conf_size(Bytes) when is_integer(Bytes), Bytes < 10*?MB ->
      ?ROUNDUP(?B2KB(Bytes), ?B2KB(1*?MB));
  conf_size(Bytes) when is_integer(Bytes), Bytes < 100*?MB ->
  
negative.code: 	       end,
      server_loop(NewState).
  
  carrier_migration_support(aoff) ->
      true;
  carrier_migration_support(aoffcbf) ->
      true;
  carrier_migration_support(aoffcaobf) ->
      true;
  carrier_migration_support(_) ->
      false.
  
  allocator_instances(ll_alloc, Strategy) ->
      case carrier_migration_support(Strategy) of
  	true -> erlang:system_info(schedulers);
  	false -> 1
      end;
  allocator_instances(_A, undefined) ->
      1;
  allocator_instances(_A, _Strategy) ->
      erlang:system_info(schedulers).
  
  strategy(temp_alloc, _AI) ->
      af;
  strategy(A, AI) ->
      try
  	{A, OptList} = lists:keyfind(A, 1, AI),
  	{as, S} = lists:keyfind(as, 1, OptList),
  	S
      catch
  	_ : _ ->
  	    undefined
      end.
  
  strategy_str(af) ->
      "A fit";
  strategy_str(gf) ->
      "Good fit";
  strategy_str(bf) ->
      "Best fit";
  strategy_str(aobf) ->
      "Address order best fit";
  strategy_str(aoff) ->
      "Address order first fit";
  strategy_str(aoffcbf) ->
      "Address order first fit carrier best fit";
  strategy_str(aoffcaobf) ->
      "Address order first fit carrier adress order best fit".
  
  default_acul(A, S) ->
      case carrier_migration_support(S) of
  	false ->
  	    0;
  	true ->
  	    case A of
  		ll_alloc -> 85;
  		eheap_alloc -> 45;
  		_ -> 60
  	    end
      end.
  
  make_state() ->
      {_, _, _, AI} = erlang:system_info(allocator),
      #state{alloc = lists:map(fun (A) ->
  				     S = strategy(A, AI),
  				     #alloc{name = A,
  					    strategy = S,
  					    acul = default_acul(A, S),
  					    instances = allocator_instances(A, S)}
  			     end,
  			     ?ALLOCATORS)}.
  
  