PACING Calculation

Pacing Calculation :

D = Duration of the test(test window/time frame)

B = Baseline time(total time taken by 1 Vu to complete 1 whole iteration)

T = Total amount of Think time in the script

I = Expected/Target iteration

R = Residual time of the test window.

R = ( D - (T + B)*I)

P = Pacing interval

Dividing the residual time by target iteration gives pacing interval

Hence:

P = R/I

D is pacing time.
(T + B)*I represents the duration of a scenario
and P is the waiting time before the next scenario

Calculating Pacing Time/Think Time to achieve 50 TPS with an average response

time of 0.5 seconds with total of 100 Users
Let us start with calculating total number of transactions in an hour.
1 sec = 50 trnx
3600 sec = x
x = 3600 * 50 = 180000 trnx/hour by 100 Users

We have total number of users given as 100. Let us see how to calculate how many
transactions each user will perform.
Total Number of Users = 100
Each User will perform 180000/100=1800 transactions/hour

Since, every transaction is taking on an average 0.5 seconds, let us see how much
time is required to complete the each user transactions.
To complete 1800 trnx it will take 1800*0.5 = 15 minutes

So now, let us see how much think-time is required to complete the required
number transactions per User in an hour.
1800 transactions will complete in 15 minutes
hence, 45 minutes of thinktime is required in between 1800 transactions (i.e. 45*60
= 2700 seconds of thinktime required in between 1800 transactions (per user))
2700 seconds = 1800 trnx
x = 1 trnx
x = 1.5 seconds think time need to include

Let us see how much time is required to complete each iteration.

Total time required to complete each Iteration = x + 0.5 seconds
= 1.5 + 0.5

= 2 seconds

Verification: Let us verify if our above calculation is correct.

Total time = 1800 * 2
= 3600 seconds
= 1 Hr

So, Each User will perform 1800 transactions where we will provide 2 seconds for
each Iteration to complete.

Random Virtual User Pacing in LoadRunner:

I guess there's always a first time. I had never used LoadRunner's random virtual
user (VU) pacing earlier, but am working on a project that will need to use this
feature for the first time. And as I thought about it a little more, I may start using it
more frequently now. Here's how it happened

This is one of the rare projects that provided me with excellent documentation - not
only system documentation like the system specs, API Guides etc but also
performance requirements like actual production volume reports and capacity
models that estimated the projected volumes.

The capacity models estimated the maximum transaction load by hour as well as by
minute (max TPM). What I needed to do was take maximum hourly load, divide it by
60 to get a per minute transactional load and use this as the average TPM. The idea
was to vary the VU pacing so that over the whole duration of test, average load
stays at this Average TPM but it also reaches the Max TPM randomly.

For example, if the maximum hourly transaction rate is 720 requests and maximum
TPM is 20, the average TPM will be 720/60 = 12 and I will need to vary the pacing so
that the load varies between 4TPM and 20TPM and averages to around 12TPM.
The Calculation:

To vary the transactional load, I knew I had to vary the VU Pacing randomly. Taking
above example, I had to achieve 12TPM and I knew the transactions were taking
around 1-2 seconds to complete. So I could have the pacing of around 120 seconds
if I needed to generate a fixed load of 12TPM with a 5 second Ramp-up and 24
users.

Script TPM

Number of VUs

Pacing (sec) Ramp Up

Script 1

12

1 VU/5sec

24

120

So now to vary the TPM to x with the same 24 virtual users, I will need to have a
pacing of 24*60/x. I got this from an old-fashioned logic which goes in my head this
way:
24 users with a pacing of 60 seconds generate a TPM of 24
24 users with a pacing of 120 seconds generate a TPM of 24 * 60/120
24 users with a pacing of x seconds generate a TPM of 24 * 60/x

So using above formula, to vary the load from 20 to 4TPM I will need to vary the VU
pacing from 72 to 360. So now we have:
Script TPM

Number of VUs

Pacing (sec) Ramp Up

Script 1

4 to 20

Random (72 to 360)

24

1 VU/5sec

Of course, there's a caveat. The range of 72 to 360 seconds has an arithmetic mean
of 216. 120 is actually the harmonic mean of the 2 numbers. So the actual variation
in TPM will depend on the distribution of random numbers that LoadRunner
generates within the given range. If it generates the numbers with a uniform
distribution around the arithmetic mean of the range, then we have a problem.

I ran a quick test to find this out. I created an LR script and used the rand() function
to generate 1000 numbers between the range with the assumption that LR uses a
similar function to generate the random pacing values.

int i;
srand(time(NULL));
for (i=0;i<1000 br="" i="">lr_output_message("%d\n", rand() % 289 + 72);
}

And of course, the average came out close to the arithmetic mean of 72 and 360,
which is 216.

So with the assumption that the function used by LoadRunner for generating
random pacing values generates numbers that are uniformly distributed around the
arithmetic mean of the range, we'll need to modify the range of pacing values so
that the arithmetic mean of the range gives us the arithmetic mean of the TPM that
we want...phew. What it means is that the above pacing values need to be modified
from 72 to 360 (arithmetic mean = 216) to 72 to 168 (arithmetic mean = 120).
However, this gives us the TPM range of 20 to 8.6 TPM with a harmonic mean of
12TPM.

But I'll live with it. I would rather have the average load stay around 12TPM. So here
are the new values. Note the asterisk on TPM. I need to mention in the test plan that
the actual TPM will vary from 8.6 to 20TPM with an average of 12TPM.

Script TPM* Number of VUs

Pacing (sec) Ramp Up

Script 1

Random (72 to 168)

4 to 20

24

1 VU/5sec