Imagine you're organizing a party where you want to distribute candies equally among your friends. Initially, you have a large bag of candies representing all the unique values available for the parameter in your LoadRunner script. Each friend (virtual user) needs a certain number of candies (block size) to perform their actions during the party (test execution).
Here's how the Dynamic Allocation Algorithm works:
- Calculating Ideal Distribution: You calculate how many candies each friend should ideally get based on the total number of candies in the bag and the number of friends. This ensures a fair distribution.
- Adjusting for Optimal Sharing: Sometimes, the ideal distribution might result in too many candies for each friend, which could be wasteful. So, you adjust the distribution to make it more optimal, ensuring everyone gets enough candies without excess.
- Updating Remaining Candies: After each round of distribution, you keep track of how many candies are left in the bag. This helps you manage the distribution better in subsequent rounds.
- Simulating Party Rounds: You repeat this distribution process for each round of the party (test execution), ensuring that each friend gets their fair share of candies according to the dynamically adjusted block size.
Sample code:
// Initialize variables
var totalUniqueValues = 1000; // Total number of unique values
var blockSize = 100; // Initial block size per vuser
var remainingValues = totalUniqueValues; // Initialize remaining unique values
var vusers = 10; // Total number of virtual users
// Function to dynamically allocate block size per vuser
function allocateBlockSize() {
// Calculate the ideal block size per vuser based on remaining values and vusers
var idealBlockSize = Math.ceil(remainingValues / vusers);
// Check if the ideal block size exceeds a certain threshold
if (idealBlockSize > 150) {
// Reduce the block size to ensure optimal distribution
blockSize = Math.ceil(idealBlockSize * 0.8); // Reduce by 20%
} else {
// Keep the block size within acceptable limits
blockSize = idealBlockSize;
}
// Update remaining values after allocation
remainingValues -= (blockSize * vusers);
// Log the allocated block size
lr.log("Allocated block size per vuser: " + blockSize);
}
// Main function to simulate test execution
function simulateTestExecution() {
// Simulate test execution for each vuser
for (var i = 1; i <= vusers; i++) {
// Perform actions using parameter values within allocated block size
lr.log("Vuser " + i + " executing with block size: " + blockSize);
// Here you would execute your LoadRunner script actions using parameter values within the allocated block size
}
}
// Main function to run the test scenario
function runTestScenario() {
// Simulate multiple iterations of test execution
for (var iteration = 1; iteration <= 5; iteration++) {
lr.log("Iteration: " + iteration);
allocateBlockSize(); // Dynamically allocate block size for each iteration
simulateTestExecution(); // Simulate test execution using allocated block size
}
}
// Run the test scenario
runTestScenario();
- The allocateBlockSize() function dynamically calculates the ideal block size per vuser based on the remaining unique values and the total number of virtual users. It adjusts the block size to ensure optimal distribution while considering thresholds.
- The simulateTestExecution() function represents the execution of the LoadRunner script actions for each virtual user, utilizing parameter values within the allocated block size.
- The runTestScenario() function orchestrates the test scenario by repeatedly allocating block sizes and simulating test execution across multiple iterations.