anchor.diff:  
   -record(state, { base_urls,          % Tuple of #url -- one for each IP
                    base_urls_index,    % #url to use for next request
  -                 path_params }).     % Params to append on the path
  +                 path_params,        % Params to append on the path
  +                 id,                 % Job ID passed through new/1 minus 1 -> 0... concurrent
  +                 concurrent,         % Number of Job Processed
  +                 check_integrity}).  % Params to test data integrity
   
   -define(S3_ACC_KEY,      "05236").
   -define(S3_SEC_KEY,      "802562235").
   -define(S3_CONTENT_TYPE, "application/octet-stream").
  +-define(ETS_BODY_MD5, ets_body_md5).
   
   %% ====================================================================
   %% API
   %% ====================================================================
  -new(_Id) ->
  +new(Id) ->
  +    %% Guaranteed One shot
  +    case Id of
  +        1 -> ets:new(?ETS_BODY_MD5, [public, named_table, {read_concurrency, true}]);
  +        _ -> void
  +    end,
       %% Make sure ibrowse is available
       case code:which(ibrowse) of
           non_existing ->
  
positive.code:     Sig = leo_s3_auth:get_signature(?S3_SEC_KEY, SignParams),
      io_lib:format("AWS ~s:~s", [?S3_ACC_KEY, Sig]).
  
  do_put(Url, Headers, ValueGen) ->
      case send_request(Url, Headers ++ [{'Content-Type', ?S3_CONTENT_TYPE}, {'Authorization', gen_sig("PUT", Url)}],
                        put, ValueGen(), [{response_format, binary}]) of
          {ok, "200", _Header, _Body} ->
              ok;
          {ok, "204", _Header, _Body} ->
  
negative.code:                                        || Ip <- Ips]),
              BaseUrlsIndex = random:uniform(tuple_size(BaseUrls))
      end,
      CI = basho_bench_config:get(
                        check_integrity, false), %% should be false when doing benchmark
      Concurrent = basho_bench_config:get(concurrent, 0),
      {ok, #state { base_urls = BaseUrls,
                    base_urls_index = BaseUrlsIndex,
                    path_params = Params,
                    id = Id - 1,
                    concurrent = Concurrent,
                    check_integrity = CI }}.
  
  keygen_global_uniq(Id, Concurrent, KeyGen) ->
      Base = KeyGen(),
      Rem = Base rem Concurrent,
      Diff = Rem - Id,
      Base - Diff.
  
  run(get, KeyGen, _ValueGen, #state{id = Id, concurrent = Concurrent} = State) ->
      Key = keygen_global_uniq(Id, Concurrent, KeyGen), 
      {NextUrl, S2} = next_url(State),
      case do_get(url(NextUrl, Key, State#state.path_params)) of
          {not_found, _Url} ->
              {ok, S2};
          {ok, _Url, _Headers, Body} ->
              case State#state.check_integrity of
                  true ->
                      case ets:lookup(?ETS_BODY_MD5, Key) of
                          [{_Key, LocalMD5}|_] ->
                              RemoteMD5 = erlang:md5(Body),
                              case RemoteMD5 =:= LocalMD5 of
                                  true -> {ok, S2};
                                  false -> {error, checksum_error, S2}
                              end;
                          _ -> {ok, S2}
                      end;
                  false -> {ok, S2}
              end;
          {error, Reason} ->
              io:format("~p~n",[Reason]),
              {error, Reason, S2}
      end;
  
  
  run(put, KeyGen, ValueGen, #state{id = Id, concurrent = Concurrent} = State) ->
      Key = keygen_global_uniq(Id, Concurrent, KeyGen), 
      Val = ValueGen(),
      {NextUrl, S2} = next_url(State),
      Url = url(NextUrl, Key, State#state.path_params),
      case do_put(Url, [], Val) of
          ok ->
              case State#state.check_integrity of
                  true ->
                      LocalMD5 = erlang:md5(Val),
                      ets:insert(?ETS_BODY_MD5, {Key, LocalMD5});
                  false -> void
              end,
              {ok, S2};
          {error, Reason} ->
              {error, Reason, S2}
      end;
  
  
  run(delete, KeyGen, _ValueGen, #state{id = Id, concurrent = Concurrent} = State) ->
      Key = keygen_global_uniq(Id, Concurrent, KeyGen), 
      {NextUrl, S2} = next_url(State),
      case do_delete(url(NextUrl, Key, State#state.path_params)) of
          {not_found, _Url} ->
              {ok, S2};
          {ok, _Url, _Headers} ->
              case State#state.check_integrity of
                  true ->
                      ets:delete(?ETS_BODY_MD5, Key);
                  false -> void
              end,
              {ok, S2};
          {error, Reason} ->
              {error, Reason, S2}
  