public void Run(ICLIOperation operation, ICLIOperation reverseOperation = null)
{
Dictionary <int, double> fileNumTime = new Dictionary <int, double>();
Dictionary <int, double> fileNumTimeSD = new Dictionary <int, double>();
string local = ".";
int fileNum = 2;
while (fileNum <= 128) //change to a smaller number(2048-->128) as we upload/download blobs in sequence now
{
var folderName = FolderName + "-" + fileNum;
var containerName = DownloadContainerPrefix + "-" + folderName;
var localFolder = local + "\\" + folderName;
if (operation.IsUploadTest)
{
FileUtil.PrepareData(folderName, fileNum, FILE_SIZE_MB * 1024);
containerName = UploadContainerPrefix + "-" + folderName;
}
else if (this.GenerateDataBeforeDownload && reverseOperation != null)
{
FileUtil.PrepareData(folderName, fileNum, FILE_SIZE_MB * 1024);
reverseOperation.BeforeBatch(remote: containerName, local: localFolder);
reverseOperation.GoBatch(remote: containerName, local: localFolder);
}
TransferTestFiles(
remote: containerName,
local: localFolder,
fileNum: fileNum,
fileNumTime: fileNumTime,
fileNumTimeSD: fileNumTimeSD,
operation: operation);
fileNum *= 4;
}
//print the results
string sizes = string.Empty;
string times = string.Empty;
string sds = string.Empty;
foreach (KeyValuePair <int, double> d in fileNumTime)
{
sizes += d.Key + " ";
times += d.Value + " ";
}
foreach (KeyValuePair <int, double> d in fileNumTimeSD)
{
sds += d.Value + " ";
}
Test.Info("[file_number] {0}", sizes);
Test.Info("[file_times] {0}", times);
Test.Info("[file_timeSDs] {0}", sds);
Helper.writePerfLog(TestContext.FullyQualifiedTestClassName + "." + TestContext.TestName);
Helper.writePerfLog(sizes.Replace(' ', ','));
Helper.writePerfLog(times.Replace(' ', ','));
Helper.writePerfLog(sds.Replace(' ', ','));
}
/// <summary>
/// Generate blob file with maximum size
/// <param name="bMax">indicates whether download a blob with the maximum size</param>
/// </summary>
public static void GenerateTestFiles_Max(ICLIOperation o)
{
string filename = "testfile_" + o.MaxSize + o.Unit;
//generate the file only when same file of same length already exists.
if (!File.Exists(filename) || new FileInfo(filename).Length != o.MaxSize * 1024 * 1024 * 1024)
{
Test.Info("Generating file: " + filename);
GenerateBigFile(filename, o.MaxSize);
}
}
/// <summary>
/// upload blob files
/// the following two parameters are only useful for upload blob file with maximum size
/// <param name="blobType"></param>
/// <param name="max">indicates whether download a blob with the maximum size</param>
/// </summary>
public void Run(ICLIOperation operation, ICLIOperation reverseOperation = null, bool max = false)
{
if (operation.IsUploadTest || (this.GenerateDataBeforeDownload && reverseOperation != null))
{
if (max)
{
GenerateTestFiles_Max(operation);
}
else
{
GenerateTestFiles();
}
}
Dictionary <long, double> fileSizeTime = new Dictionary <long, double>();
Dictionary <long, double> fileSizeTimeSD = new Dictionary <long, double>();
TransferTestFiles(fileSizeTime, fileSizeTimeSD, operation, max, reverseOperation);
//print the results
string sizes = string.Empty;
string times = string.Empty;
string sds = string.Empty;
foreach (KeyValuePair <long, double> d in fileSizeTime)
{
sizes += d.Key + " ";
times += d.Value + " ";
}
foreach (KeyValuePair <long, double> d in fileSizeTimeSD)
{
sds += d.Value + " ";
}
Test.Info("[file_sizes] {0}", sizes);
Test.Info("[file_times] {0}", times);
Test.Info("[file_timeSDs] {0}", sds);
Helper.writePerfLog(TestContext.FullyQualifiedTestClassName + "." + TestContext.TestName);
Helper.writePerfLog(sizes.Replace(' ', ','));
Helper.writePerfLog(times.Replace(' ', ','));
Helper.writePerfLog(sds.Replace(' ', ','));
}
/// <summary>
/// Upload/download blob files
/// <param name="bMax">indicates whether download a blob with the maximum size</param>
/// </summary>
public void TransferTestFiles(Dictionary <long, double> fileSizeTime,
Dictionary <long, double> fileSizeTimeSD, ICLIOperation operation, bool bMax = false, ICLIOperation reverseOperation = null)
{
if (!bMax)
{
TransferTestFiles(2, 512, "K", fileSizeTime, fileSizeTimeSD, operation, reverseOperation);
TransferTestFiles(2, 512, "M", fileSizeTime, fileSizeTimeSD, operation, reverseOperation);
TransferTestFiles(2, 16, "G", fileSizeTime, fileSizeTimeSD, operation, reverseOperation);
}
else
{
operation.CheckMD5 = false;
TransferTestFiles(
initSize: operation.MaxSize,
endSize: operation.MaxSize,
unit: operation.Unit,
fileSizeTime: fileSizeTime,
fileSizeTimeSD: fileSizeTimeSD,
operation: operation,
reverseOperation: reverseOperation,
iteration: 1); //for large scale testing, we only needs 1 iteration
}
}
/// <summary>
/// Upload/download blob files
/// <param name="initSize"></param>
/// <param name="endSize"></param>
/// <param name="unit">"K", "M", "G", "G_BLOCK", "G_PAGE"</param>
/// </summary>
public void TransferTestFiles(int initSize, int endSize, string unit, Dictionary <long, double> fileSizeTime,
Dictionary <long, double> fileSizeTimeSD, ICLIOperation operation, ICLIOperation reverseOperation = null, int?iteration = null)
{
var containerName = DownloadContainerPrefix;
if (operation.IsUploadTest)
{
containerName = UploadContainerPrefix;
}
for (int i = initSize; i <= endSize; i *= 4)
{
string fileName = "testfile_" + i + unit;
long fileSize = 0L;
if (operation.IsUploadTest)
{
if (!FileUtil.FileExists(fileName))
{
throw new Exception("file not found, path: " + fileName);
}
else
{
fileSize = FileUtil.GetFileSize(fileName);
}
}
else if (this.GenerateDataBeforeDownload && reverseOperation != null)
{
reverseOperation.Before(containerName, fileName);
reverseOperation.Go(containerName, fileName);
}
List <long> fileTimeList = new List <long>();
Stopwatch sw = new Stopwatch();
var iterations = iteration.HasValue ? iteration.Value : Constants.Iterations;
for (int j = 0; j < iterations; j++)
{
operation.Before(containerName, fileName);
sw.Reset(); sw.Start();
var bSuccess = operation.Go(
containerName: containerName,
fileName: fileName);
Test.Assert(bSuccess, operation.Name + " should succeed");
sw.Stop();
fileTimeList.Add(sw.ElapsedMilliseconds);
var error = string.Empty;
Test.Assert(operation.Validate(containerName, fileName, out error), error);
Test.Info("file name : {0} round : {1} time(ms) : {2}", fileName, j + 1, sw.ElapsedMilliseconds);
}
double average = fileTimeList.Average();
if (!operation.IsUploadTest)
{
fileSize = FileUtil.GetFileSize(fileName);
}
fileSizeTime.Add(fileSize, average);
var deviation = fileTimeList.Select(num => Math.Pow(num - average, 2));
double sd = Math.Sqrt(deviation.Average());
fileSizeTimeSD.Add(fileSize, sd);
Test.Info("file name : {0} average time : {1}", fileName, average);
Test.Info("file name : {0} standard dev : {1}", fileName, sd);
}
}
public static void TransferTestFiles(string local, string remote, int fileNum,
Dictionary <int, double> fileNumTime, Dictionary <int, double> fileNumTimeSD, ICLIOperation operation)
{
List <long> fileTimeList = new List <long>();
Stopwatch sw = new Stopwatch();
for (int j = 0; j < Constants.Iterations; j++)
{
operation.BeforeBatch(local, remote);
sw.Reset(); sw.Start();
Test.Assert(operation.GoBatch(local: local, remote: remote), operation.Name + " should succeed");
sw.Stop();
fileTimeList.Add(sw.ElapsedMilliseconds);
Test.Info("file number : {0} round : {1} time(ms) : {2}", fileNum, j + 1, sw.ElapsedMilliseconds);
var error = string.Empty;
Test.Assert(operation.ValidateBatch(local, remote, fileNum, out error), error);
}
double average = fileTimeList.Average();
var deviation = fileTimeList.Select(num => Math.Pow(num - average, 2));
double sd = Math.Sqrt(deviation.Average());
fileNumTime.Add(fileNum, average);
fileNumTimeSD.Add(fileNum, sd);
Test.Info("file number : {0} average time : {1}", fileNum, average);
Test.Info("file number : {0} standard dev : {1}", fileNum, sd);
}
public void Run(ICLIOperation operation, ICLIOperation reverseOperation = null)
{
var fileNumTime = new Dictionary <int, double>();
var fileNumTimeSD = new Dictionary <int, double>();
var fileNum = MAX_FILE_NUM; // 4096;
while (fileNum > 0)
{
var folder = FolderName + "-" + fileNum;
var size = MAX_SIZE_MB * 1024 / fileNum;
var containerName = DownloadContainerPrefix + "-" + folder;
var localFolder = ".\\" + folder;
if (operation.IsUploadTest)
{
FileUtil.PrepareData(folder, fileNum, size);
containerName = UploadContainerPrefix + "-" + folder;
}
else if (this.GenerateDataBeforeDownload && reverseOperation != null)
{
FileUtil.PrepareData(folder, fileNum, size);
reverseOperation.BeforeBatch(remote: containerName, local: localFolder);
reverseOperation.GoBatch(remote: containerName, local: localFolder);
}
TransferTestFiles(
remote: containerName,
local: localFolder,
fileNum: fileNum,
fileNumTime: fileNumTime,
fileNumTimeSD: fileNumTimeSD,
operation: operation);
fileNum /= 4;
}
//print the results
string sizes = string.Empty;
string times = string.Empty;
string sds = string.Empty;
foreach (KeyValuePair <int, double> d in fileNumTime)
{
sizes += d.Key + " ";
times += d.Value + " ";
}
foreach (KeyValuePair <int, double> d in fileNumTimeSD)
{
sds += d.Value + " ";
}
Test.Info("[file_number] {0}", sizes);
Test.Info("[file_times] {0}", times);
Test.Info("[file_timeSDs] {0}", sds);
Helper.writePerfLog(TestContext.FullyQualifiedTestClassName + "." + TestContext.TestName);
Helper.writePerfLog(sizes.Replace(' ', ','));
Helper.writePerfLog(times.Replace(' ', ','));
Helper.writePerfLog(sds.Replace(' ', ','));
}
