anchor.diff:  
       TmpTN = trunc(ThreadsNum/ConflictedThreads),
       WLength = length(Workers),
  +    Multip = min(WLength, min(ThreadsNum, ConflictedThreads)),
       {NewTN, NewCT} = case Level of
                            local_only ->
  -                             {round(TmpTN / ClearRatio) * WLength, WLength};
  +                             {round(TmpTN / ClearRatio) * Multip, Multip};
                            locally_cached ->
  -                             {round(TmpTN / ClearRatio) * WLength, WLength};
  +                             {round(TmpTN / ClearRatio) * Multip, Multip};
                            _ ->
                                {round(TmpTN / ClearRatio), 1}
                        end,
       DelOpsNum = DocsPerThead * NewTN,
   
       AnsExt2 = case Level of
  -        local_only ->
  -            [];
  -        locally_cached ->
  -            [];
  -        _ ->
  -            ClearManyLinks = fun(DocsSet) ->
  -                for(1, DocsPerThead, fun(I) ->
  -                    BeforeProcessing = os:timestamp(),
  -                    Ans = ?call_store(delete_links, Level, [
  -                        Doc, [list_to_binary("link" ++ DocsSet ++ integer_to_list(I))]]),
  -                    AfterProcessing = os:timestamp(),
  -                    Master ! {store_ans, AnswerDesc, Ans, timer:now_diff(AfterProcessing, BeforeProcessing)}
  -                end)
  -            end,
  -
  -            spawn_at_nodes(Workers, NewTN, NewCT, ClearManyLinks),
  -            {DelLinkOkNum, DelLinkTime, _DelLinkErrorNum, _DelLinkErrorTime, DelLinkErrorsList} =
  -                count_answers(DelOpsNum),
  -            ?assertEqual([], DelLinkErrorsList),
  -            ?assertEqual(DelOpsNum, DelLinkOkNum),
  -            ?assertMatch(ok, ?call(Worker1, TestRecord, delete, [Key])),
  -
  -            AnsExt ++ [#parameter{name = del_links_time, value = DelLinkTime / DelOpsNum, unit = "us",
  -                description = "Average time of delete links"}
  -            ]
  -    end,
  +                  local_only ->
  +                      [];
  +                  locally_cached ->
  +                      [];
  +                  _ ->
  +                      ClearManyLinks = fun(DocsSet) ->
  +                          for(1, DocsPerThead, fun(I) ->
  +                              BeforeProcessing = os:timestamp(),
  +                              Ans = ?call_store(delete_links, Level, [
  +                                  Doc, [list_to_binary("link" ++ DocsSet ++ integer_to_list(I))]]),
  +                              AfterProcessing = os:timestamp(),
  +                              Master ! {store_ans, AnswerDesc, Ans, timer:now_diff(AfterProcessing, BeforeProcessing)}
  +                          end)
  +                      end,
  +
  +                      spawn_at_nodes(Workers, NewTN, NewCT, ClearManyLinks),
  +                      {DelLinkOkNum, DelLinkTime, _DelLinkErrorNum, _DelLinkErrorTime, DelLinkErrorsList} =
  +                          count_answers(DelOpsNum),
  +                      ?assertEqual([], DelLinkErrorsList),
  +                      ?assertEqual(DelOpsNum, DelLinkOkNum),
  +                      ?assertMatch(ok, ?call(Worker1, TestRecord, delete, [Key])),
  +
  +                      AnsExt ++ [#parameter{name = del_links_time, value = DelLinkTime / DelOpsNum, unit = "us",
  +                          description = "Average time of delete links"}
  +                      ]
  +              end,
   
       ClearMany = fun(DocsSet) ->
           for(1, DocsPerThead, fun(I) ->
  
positive.code: 
      TmpTN = trunc(ThreadsNum/ConflictedThreads),
      WLength = length(Workers),
      {NewTN, NewCT} = case Level of
                           local_only ->
                               {TmpTN * WLength, WLength};
                           locally_cached ->
                               {TmpTN * WLength, WLength};
                           _ ->
                               {TmpTN, 1}
                       end,
  
negative.code:     ?assertEqual(OpsNum, OkNum + ErrorNum),
      TmpTN = trunc(ThreadsNum/ConflictedThreads),
      WLength = length(Workers),
      Multip = min(WLength, min(ThreadsNum, ConflictedThreads)),
      NewTN = case {Level, Fun} of
                  {local_only, _} ->
                      TmpTN * Multip;
                  {locally_cached, create} ->
                      TmpTN * Multip;
                  _ ->
                      TmpTN
              end,
      ModelConfig = TestRecord:model_init(),
      case ModelConfig#model_config.transactional_global_cache of
          true ->
  