Why is this code taking very long to execute on a server - c

Question

We use LoadRunner to run performance tests for an application. The tests are generally written in Ansi-C.
We have a simple base64 encoding function:
void base64encode(char *src, char *dest, int srcLen, int destLen)
{
int i=0;
int slen= srcLen;
for(i=0;i<slen && i<destLen;i+=3,src+=3)
{
*(dest++)=base64encode_lut[(*src&0xFC)>>0x2];
*(dest++)=base64encode_lut[(*src&0x3)<<0x4|(*(src+1)&0xF0)>>0x4];
*(dest++)=((i+1)<slen)?base64encode_lut[(*(src+1)&0xF)<<0x2|(*(src+2)&0xC0)>>0x6]:'=';
*(dest++)=((i+2)<slen)?base64encode_lut[*(src+2)&0x3F]:'=';
}
*dest='\0';
}
This code when ran on a developer machine (64-bit Windows 10 machines) the code runs in under a sec for a simple image (srcLen around 7k).
When ran on the production server (32-bit Windows 2012, VM) the execution takes between 10 to 20 minutes for the same image.
Can anyone explain why and how to avoid this issue? I'm not sure if it's LoadRunner or the code to blame.
EDIT: adding the code that is calling the encoding function:
long infile; // file pointer
char *buffer; // buffer to read file contents into
char *filename = "DFC_COLOR.jpg"; // file to read
int fileLen; // file size
int bytesRead; // bytes read from file
char *encoded;
int dest_size;
web_set_max_html_param_len("999999999");
infile = fopen(filename, "rb");
if (!infile) {
lr_error_message("Unable to open file %s", filename);
return;
}
// get the file length
fseek(infile, 0, SEEK_END);
fileLen = ftell(infile);
fseek(infile, 0, SEEK_SET);
lr_log_message("File length is: %9d bytes.", fileLen);
// Allocate memory for buffer to read file
buffer = (char *)malloc(fileLen + 1);
if (!buffer) {
lr_error_message("Could not malloc %10d bytes", fileLen + 1);
fclose(infile);
return;
}
// Read file contents into buffer
bytesRead = fread(buffer, 1, fileLen, infile);
if (bytesRead != fileLen)
{
lr_error_message("File length is %10d bytes but only read %10d bytes", fileLen, bytesRead);
}
else
{
lr_log_message("Successfully read %9d bytes from file: ", bytesRead);
}
fclose(infile);
// Save the buffer to a loadrunner parameter
lr_save_var(buffer, bytesRead, 0, "fileDataParameter");
// calculate the destination size
dest_size = 1 + ((bytesRead + 2) / 3 * 4);
encoded = (char *)malloc(dest_size);
memset(encoded, 0, dest_size);
// encode the buffer
base64encode(buffer, encoded, bytesRead, dest_size);

Answer 1

Run a single virtual user on a non shared/brokered resource physical machine and see if you have the same performance. You have no want to determine what your priority and resource pool is within the virtual machine environment. You could be running on a VM host which is highly overloaded and you are simply having to wait as the hypervisor makes decisions on who gets a given resource set at which time. Moving a single virtual user to a single hardware host provides a common apples to pears basis (oranges to kumquats) for making your comparison.
LoadRunner also includes an RFC compliant base64 encoding and decoding algorithm as a part of its core set so you do not need to recode this. Normally this is used as part of the SMTP or DNS virtual users, but you can load the DLL, prototype the functions and move forward. You can find existing function prototypes in the \include\mic_socket.h header file Here is a great article on how this is accomplished. I know the editors are going to scream and demote this as an external link, so you may want to capture the link fast
https://northwaysolutions.com/blog/loadrunner-vugen-encoding-and-decoding-base64/#.WL1vZxLytlc
The other way to handle this is as a Data Format extension. Decode is already covered as a base extension, so you would only have to handle the encode if you so desired. Use Google to pull references to Loadrunner, DFE and base64 for the appropriate items. You can also find a DFE developers guide in your local documentation set, installed with your copy of LoadRunner.