anchor.diff:  
   -type utilization() :: float().
   
  --record(node, {utilization = ?required(node, utilization)    :: utilization(),
  +-record(node, {utilization = ?required(node, utilization)    :: utilization(), %% erlang sorts by first element in record/tuple
  +               pid      = ?required(node, pid)               :: comm:mypid(),
                  capacity = 1                                  :: number(),
  -               load     = ?required(node, load)              :: number(),
  -               pid      = ?required(node, pid)               :: comm:mypid()
  +               load     = ?required(node, load)              :: number()
                  }).
   
   -type directory_name() :: string().
   
   -record(directory, {name         = ?required(directory, name) :: directory_name(), 
                       last_balance = nil                        :: nil | os:timestamp(),
  -                    pool         = gb_sets:new()              :: gb_set()
  -                    %light_nodes  = []                         :: [node()],
  -                    %heavy_nodes  = []                         :: [node()]
  +                    pool         = gb_sets:new()              :: gb_set(),
  +                    schedule     = []                         :: [reassign()]
                       }).
  +
  +-record(reassign, {from = ?required(reassign, from) :: node:node_type(),
  +                   to   = ?required(reassign, to)   :: node:node_type()
  +                   }).
  +
  +-type reassign() :: #reassign{}.
   
   -record(state, {capacity = 1500, %% free cpu usage, free memory, bandwith...
                   my_dirs = [],
  
positive.code: handle_dht_msg({lb_active, Msg}, DhtState) ->
      DhtState.
  
  request_dht_range() ->
      MyDHT = pid_groups:get_my(dht_node),
      comm:send_local(MyDHT, {get_state, comm:this(), my_range}).
  
negative.code:     end,
      State;
  
  %% In case of an emergency, we check immediately
  handle_msg({emergency, LoadInfo, DirKey}, State) ->
      %% TODO just write directly to db instead
      post_load_to_directory(LoadInfo, DirKey),
      %% TODO Emergency Threshold has been already check at the node overloaded...
      EmergencyThreshold = State#state.threshold_emergency,
      case LoadInfo#node.utilization > EmergencyThreshold of
          true  ->
              MyDirKeys = State#state.my_dirs,
              directory_routine(DirKey, emergency);
          false -> State
      end;
  
  handle_msg({directory_trigger}, State) ->
      trigger(directory_trigger),
      ?TRACE("~p My Directories: ~p~n", [self(), State#state.my_dirs]),
      %% Threshold k_p = Average laod in directory
      %% Threshold k_e = 1 meaning full capacity
      %% Upon receipt of load information:
  