anchor.diff:  
   start_jobs_as_possible(#state{target_pids           = [Id|Rest],
                                 max_num_of_concurrent = MaxProc,
  -                              filter_fun            = FunHasChargeOfNode,
  +                              inspect_fun           = FunHasChargeOfNode,
                                 in_progress_pids      = InProgPids,
                                 child_pids            = ChildPids} = State, NumChild) when NumChild < MaxProc ->
       Pid  = spawn_link(fun() ->
  
positive.code: 
  state_suspend({done_child,_DonePid,_DoneId}, #state{target_pids      = [],
                                                      in_progress_pids = [_H|_Rest],
                                                      child_pids       = ChildPids} = State) ->
      [erlang:send(Pid, stop) || {Pid, _} <- orddict:to_list(ChildPids)],
      {next_state, state_idle, State#state{in_progress_pids = [],
                                           child_pids = orddict:new()}}.
  
  %% @doc Handle events
  %%
  
negative.code: -spec(state_idle({start, list(), pos_integer(), function()} | suspend | resume,
                   From::pid(), State::#state{}) ->
               {next_state, state_running | state_idle, #state{}}).
  state_idle({start, TargetPids, MaxConNum, InspectFun}, From, State) ->
      AllPids    = leo_object_storage_api:get_object_storage_pid('all'),
      RemainPids = State#state.target_pids,
  
      ReservePids = case (length(TargetPids) == length(AllPids)) of
                        true  ->
                            [];
                        false when RemainPids == [] ->
                            lists:subtract(AllPids, TargetPids);
                        false when RemainPids /= [] ->
                            lists:subtract(RemainPids, TargetPids)
                    end,
  
      NewState = start_jobs_as_possible(State#state{target_pids           = TargetPids,
                                                    max_num_of_concurrent = MaxConNum,
                                                    inspect_fun           = InspectFun,
                                                    reserve_pids          = ReservePids,
                                                    start_datetime        = leo_date:now()}),
      gen_fsm:reply(From, ok),
      {next_state, state_running, NewState};
  
  
  state_idle(suspend, From, State) ->
      gen_fsm:reply(From, {error, badstate}),
      {next_state, state_idle, State};
  
  state_idle(resume, From, State) ->
      gen_fsm:reply(From, {error, badstate}),
      {next_state, state_idle, State}.
  