anchor.diff:      {ok, Timeuuid} = erlcass_uuid:gen_time(),
       Inet = <<"127.0.0.1">>,
   
  -    {ok, []} = erlcass:execute(InsertQuery,
  -        [
  -            {?CASS_TEXT, AsciiValBin},
  -            {?CASS_BIGINT, BigIntPositive},
  -            {?CASS_BLOB, Blob},
  -            {?CASS_BOOLEAN, BooleanTrue},
  -            {?CASS_DECIMAL, DecimalPositive},
  -            {?CASS_DOUBLE, DoublePositive},
  -            {?CASS_FLOAT, FloatPositive},
  -            {?CASS_INT, IntPositive},
  -            {?CASS_BIGINT, Timestamp},
  -            {?CASS_UUID, Uuid},
  -            {?CASS_TEXT, Varchar1},
  -            {?CASS_BLOB, Varint1},
  -            {?CASS_UUID, Timeuuid},
  -            {?CASS_INET, Inet}]).
  +    {ok, []} = erlcass:execute(add_load_test_record, [
  +            AsciiValBin,
  +            BigIntPositive,
  +            Blob,
  +            BooleanTrue,
  +            DecimalPositive,
  +            DoublePositive,
  +            FloatPositive,
  +            IntPositive,
  +            Timestamp,
  +            Uuid,
  +            Varchar1,
  +            Varint1,
  +            Timeuuid,
  +            Inet
  +    ]).
   
   display_progress(Results) ->
       if
  
positive.code: start() ->
      case application:ensure_all_started(erlcass) of
          {ok, [_|_]} ->
              ok = erlcass:add_prepare_statement(execute_query, ?QUERY);
          {ok, []} ->
              ok;
          UnexpectedError ->
              UnexpectedError
  
negative.code:             consumer_loop(TotalResults +1 , SuccessResults, FailedResults + 1, LimitReq -1)
      end.
  
  producer_loop(0) ->
      ok;
  producer_loop(NumRequests) ->
      erlcass:async_execute(execute_query, ?QUERY_ARGS),
      producer_loop(NumRequests -1).
  
  load_test(1, NrReq) ->
      producer_loop(NrReq),
      consumer_loop(0, 0, 0, NrReq);
  
  load_test(NrProcesses, NrReq) ->
      ReqPerProcess = round(NrReq/NrProcesses),
  
      Fun = fun() ->
          producer_loop(ReqPerProcess),
          consumer_loop(0, 0, 0, ReqPerProcess)
      end,
  
      multi_spawn:do_work(Fun, NrProcesses).
  
  run_test(0, _NrProc, _RequestsNr) ->
      ok;
  
  run_test(RepeatNr, NrProc, RequestsNr) ->
      load_test(NrProc, RequestsNr),
      run_test(RepeatNr -1, NrProc, RequestsNr).
  
  profile(NrProc, RequestsNr) ->
      profile(NrProc, RequestsNr, 1).
  
  profile(NrProc, RequestsNr, RepeatNumber) ->
      Fun = fun() -> do_profiling(NrProc, RequestsNr, RepeatNumber) end,
      spawn(Fun).
  
  do_profiling(NrProc, RequestsNr, RepeatNumber) ->
      erlcass:add_prepare_statement(execute_query, ?QUERY),
  
      eprof:start(),
      eprof:start_profiling([self()]),
      ok = application:set_env(erlcass, keyspace, ?KEYSPACE),
      start(),
  
      {Time, _} = timer:tc( fun() -> run_test(RepeatNumber, NrProc, RequestsNr) end),
  
      io:format("Cpp Driver Metrics: ~p ~n", [erlcass:get_metrics()]),
      eprof:stop_profiling(),
  