After adding a permanent license in LoadRunner 11.50 the Controller crashes when it is opened

When adding a permanent license in Load Runner 11.50 License Utility the license is displayed correctly. However, when opening the Controller it crashes silently and it is not possible to use it.

The length of one or more of the license keys applied in the License Utility is too big and the Controller is not able to handle it correctly.

The issue is resolved in LoadRunner Service Pack 11.51.

Try the following:

1. Open Windows Explorer and navigate to “%AllUsersProfile%\Application Data\HP\LoadRunner\data",
2. Open file LRKey.txt and then 
3. Remove the content in double quotes ("") in all occurrences in the file and save the changes. These are the license key descriptions. Removing them makes the keys shorter,
4. Finally Open the Controller.

VuGen does not launch any applications while recording

Turn off Data Execution Prevention in Windows

If this problem occurs with every application that it tries to launch, make sure Data Execution Prevention is turned off. To find Data Execution Prevention:

1. Right-click on My Computer, and choosing Properties.
2. Select the Advanced tab, and click on Performance, then Settings.
3. Select the Data Execution Prevention tab, and make sure the first option is selected which is “Turn on DEP for essential Windows programs and services only.

License Manager was not initialized

In the Controller when running a test if the following error is shown : Error Message "License Manager was not initialized"

The reason for this error to occur is because the user account doesn’t have the required permissions to initialize the LoadRunner libraries and interact with the operative system.

Be sure that you are using a full Administrator account over the machine where the Controller is installed. Any other permissions group will affect the load test.

Completely disable the DEP and reboot the machine.

Open an Elevated Command Prompt

i. Open the Start Menu

ii. Click All Programs and Accessories

iii. Right click on Command Prompt and click Run as Administrator

iv. Click on Continue

To Disable DEP

i. In the Elevated Command Prompt, type:

bcdedit.exe /set {current} nx AlwaysOff

ii. Restart the computer to apply

What is the relation between Response Time and Throughput?

The Throughput graph shows the amount of data in bytes that the Vusers received from the server in a second. When we compare this with the transaction response time, we will notice that as throughput decreased, the response time also decreased. Similarly, the peak throughput and highest response time would occur approximately at the same time

How did you plan the Load? What are the Criteria?

Load test is planned to decide the number of users, what kind of machines we are going to use and from where they are run. It is based on 2 important documents, Task Distribution Diagram and Transaction profile. Task Distribution Diagram gives us the information on number of users for a particular transaction and the time of the load. The peak usage and off-usage are decided from this Diagram. Transaction profile gives us the information about the transactions name and their priority levels with regard to the scenario we are deciding.

Analysis Scenario (Bottlenecks)

In Running Vuser graph correlated with the response time graph you can see that as the number of Vusers increases, the average response time of the check itinerary transaction very gradually increases. In other words, the average response time steadily increases as the load increases. At 56 Vusers, there is a sudden, sharp increase in the average response
time. We say that the test broke the server. That is the mean time before failure (MTBF). The response time clearly began to degrade when there were more than 56 Vusers running simultaneously.

How many types of graphs does LoadRunner have?

LoadRunner has in total 5 different types of flag which are as follows:
The Hits per second graph that depicts the traffic volume of the application being tested for.
Pages download per second graph shows the rate at which the download processes are carried out at a particular instance of time.
The Transaction response time (load )
The Transaction response time (percentile) graph
Network delay time graph shows the time elapsed for the request/ response activities in the application

What is injector in LoadRunner?

Injectors can also be called as load generators in LoadRunner. In order to create multiple Vuser script it is essential to create a scenario where the load generator has to be specified first. This provides vital host information such as it is local or remote host. The load generators must add the IP addresses of the participating machines from where the Vusers are assimilated to run scripts but prior to that the load generator must be installed in them as they are to be used as injectors

what is pacing?

Pacing is also like a wait but it is used to time count between two iteration.

Pacing is nothing but scheduling the next iteration.It consist of options:

1.as soon as previous iteration

2.start iteration with delay

Embedding Pacing In LoadRunner Script (Includes Pacing For Blocks Too)

We come accross many pacing logics in the LoadRunner script which is based on the multiple iterations. But if we need to have a pacing if there are Action blocks involved and if in case we need to re-calculate the pacing time after each iterations (which will be a good idea) as few iterations may not take the same time to execute in the LoadRunner Script, then, we need to implement a different Pacing Logic. Here it is.......

The below pacing logic calculates the pacing time after completion of each iterations and based on the test duration left.

This pacing logic have three different functions embedded in a .C function File.
1. InitCore()
2. TopOfIterations()
3. BottomOfIterations()

1. InitCore():
The InitCore() Function takes 3 parameters as mentioned in the below syntax:
InitCore(TestDuration(in Seconds), TotalBlockIterations, MaxNumberOfIterations);
Example: InitCore(180, 12, 2); - Script will execute for 24 iterations and for 180 seconds [i.e. 3 Min]
Refer the below screen for more understanding:

So, in this case the Total Number Of Iterations becomes 24 [TotalNoOfIterations = TotalBlockIterations + MaxNumberOfIterations].
This InitCore Function should be the first line in vuser_init section.

2. TopOfIterations():
This function calculates the Pacing Time based on the Test Duration and Total Number Of Iterations which will be used for the actual pacing time in the main script. This Function Call should be the first line in the Main Action Block.

3. BottomOfIterations():
This function does the main calculations of the Pacing Time when a Block Execution is completed based on the Test Durations left and the Total Number of Iterations left. This is same as re-calculating the Pacing Time instead of fixed Pacing Time each time the iterations is completed. Please note, here each BLOCK execution is considered as each ITERATIONS. This Function Call should be the last line in the Main Action Block.

These TopOfIterations() and BottomOfIterations() functions can be added in different Actions Blocks.

Bottleneck:
Since the Pacing Time is calculated based on the Test Durations left and Iterations left, there could be a possibility that few iterations might take long time to finish and if this is the case then at some point of time the Test Durations time becomes 0, in this case the rest of the Iterations are executed without calculating the Pacing Time and hence the Pacing Time becomes 0.

Actual Code Comes Here:double TestDuration, pacing_time, Origpacing_time;
int Counter = 1,MaxCounter = 0, TotalIterations;
merc_timer_handle_t timer;
double duration;

InitCore(double TDuration, int TotalBlockIterations, int MaxNumberOfIterations)
{
TestDuration = TDuration;
TotalIterations = TotalBlockIterations * MaxNumberOfIterations;
}

TopOfIterations()
{
if (Counter == 1) {
lr_output_message("Action1 - Total Test Durations - First Time: %lf",TestDuration);
pacing_time = (double)TestDuration / TotalIterations;
lr_output_message("Action1 - Total Iterations Left - First Time: %d",TotalIterations);
lr_output_message("Action1 - Pacing - First Time: %lf ",pacing_time);
}
}

BottomOfIterations()
{
if ((duration <> 0) {
TestDuration = TestDuration - pacing_time; //Is equal to Pacing time
MaxCounter = 1;
}

TotalIterations = TotalIterations - 1;
if (MaxCounter != 0) {
lr_think_time(pacing_time - duration);
pacing_time = TestDuration / TotalIterations;
MaxCounter = 0;
}
else if (TestDuration > 0) {
TestDuration = TestDuration - duration;
pacing_time = TestDuration / TotalIterations;
}

if (TestDuration <= 0) {
pacing_time = 0;
}
lr_output_message("Action1 - Total Iterations Left: %d",TotalIterations);
lr_output_message("Action1 - Total Test Durations Left: %lf",TestDuration);
lr_output_message("Action1 - New Pacing: %lf",pacing_time);
Counter = 0;
}