anchor.diff:                                   EndPos::non_neg_integer(),
                                    IsForcedCheck::boolean()).
   get(Id, AddrIdAndKey, StartPos, EndPos, IsForcedCheck) ->
  -    gen_server:call(Id, {get, AddrIdAndKey, StartPos, EndPos, IsForcedCheck}, ?DEF_TIMEOUT).
  +    {InTime, _} = erlang:statistics(wall_clock),
  +    gen_server:call(Id, {get, AddrIdAndKey, StartPos, EndPos, IsForcedCheck, InTime}, ?DEF_TIMEOUT).
   
   
   %% @doc Remove an object from the object-storage - (logical-delete)
  
positive.code:                           true  -> IsForcedCheck;
                            false -> IsStrictCheck
                        end,
      Fun = fun() ->
                    BackendKey = ?gen_backend_key(StorageInfo#backend_info.avs_ver_cur,
                                                  AddrId, Key),
                    Reply = leo_object_storage_haystack:get(
                              MetaDBId, StorageInfo, BackendKey, StartPos, EndPos, IsStrictCheck_1),
                    State_1 = after_proc(Reply, State),
                    {Reply, State_1}
            end,
      {Reply_1, State_2} = execute(get, Key, Fun, ThresholdSlowProcessing),
      erlang:garbage_collect(self()),
      {reply, Reply_1, State_2};
  
  %% Remove an object
  handle_call({delete,_}, _From, #obj_server_state{is_locked = true} = State) ->
      {reply, {error, ?ERROR_LOCKED_CONTAINER}, State};
  handle_call({delete,_}, _From, #obj_server_state{is_del_blocked = true} = State) ->
      {reply, {error, ?ERROR_LOCKED_CONTAINER}, State};
  handle_call({delete, _}, _From, #obj_server_state{privilege = ?OBJ_PRV_READ_ONLY} = State) ->
      {reply, {error, ?ERROR_NOT_ALLOWED_ACCESS}, State};
  handle_call({delete, #?OBJECT{addr_id = AddrId,
                                key = Key} = Object}, _From,
              #obj_server_state{object_storage = StorageInfo,
                                threshold_slow_processing = ThresholdSlowProcessing} = State) ->
      Fun = fun() ->
                    Key_1 = ?gen_backend_key(StorageInfo#backend_info.avs_ver_cur,
                                             AddrId, Key),
                    delete_1(Key_1, Object, State)
            end,
      {Reply, State_1} = execute(delete, Key, Fun, ThresholdSlowProcessing),
      {reply, Reply, State_1};
  
  %% Head an object
  handle_call({head, {AddrId, Key}},
              _From, #obj_server_state{meta_db_id = MetaDBId,
                                       object_storage = StorageInfo} = State) ->
      BackendKey = ?gen_backend_key(StorageInfo#backend_info.avs_ver_cur,
                                    AddrId, Key),
      Reply = leo_object_storage_haystack:head(MetaDBId, StorageInfo, BackendKey),
      {reply, Reply, State};
  
  %% Fetch objects with address-id and key to maximum numbers of keys
  handle_call({fetch, {AddrId, Key}, Fun, MaxKeys},
              _From, #obj_server_state{meta_db_id     = MetaDBId,
                                       object_storage = StorageInfo} = State) ->
      BackendKey = ?gen_backend_key(StorageInfo#backend_info.avs_ver_cur, AddrId, Key),
      Reply = case catch leo_object_storage_haystack:fetch(
                           MetaDBId, BackendKey, Fun, MaxKeys) of
  
negative.code:                                                 Fun::function(),
                                                  MaxKeys::non_neg_integer()|undefined).
  fetch(Id, Key, Fun, MaxKeys) ->
      {InTime, _} = erlang:statistics(wall_clock),
      gen_server:call(Id, {fetch, Key, Fun, MaxKeys, InTime}, ?DEF_TIMEOUT).
  
  
  %% @doc Store metadata and data
  