protected internal virtual void processRow(IList <object> row, PerfTestResult passResult, PerfTestResults results)
{
// add duration
row.Add(passResult.Duration);
// add throughput per second
long duration = passResult.Duration;
float numberOfRuns = results.Configuration.NumberOfRuns;
float throughput = (numberOfRuns / duration) * 1000;
row.Add(throughput);
// add speedup
float durationForSequential = 0;
foreach (PerfTestResult perfTestResult in results.PassResults)
{
if (perfTestResult.NumberOfThreads == 1)
{
durationForSequential = perfTestResult.Duration;
}
}
double speedUp = durationForSequential / passResult.Duration;
decimal bigDecimalSpeedUp = new decimal(speedUp);
bigDecimalSpeedUp.setScale(1, decimal.ROUND_HALF_UP);
row.Add(bigDecimalSpeedUp.doubleValue());
}
protected internal virtual IList <object> processRow(PerfTestResult passResult, PerfTestResults results)
{
IList <object> row = new List <object>();
PerfTestConfiguration configuration = results.Configuration;
// test name
row.Add(results.TestName);
// number of runs
int numberOfRuns = configuration.NumberOfRuns;
row.Add(numberOfRuns);
// database
row.Add(configuration.DatabaseName);
// history level
row.Add(configuration.HistoryLevel);
// start time
row.Add(configuration.StartTime);
// platform
row.Add(configuration.Platform);
// number of threads
row.Add(passResult.NumberOfThreads);
// add duration
long duration = passResult.Duration;
row.Add(duration);
// throughput
float numberOfRunsFloat = numberOfRuns;
float throughput = (numberOfRunsFloat / duration) * 1000;
row.Add(throughput);
return(row);
}
public virtual PerfTestResult GetPerfMetrics(string functionName, DateTime testStartTime, DateTime testEndTime, string inputTriggerName = null, string outputTriggerName = null, int expectedExecutionCount = 0)
{
var perfResults = new PerfTestResult();
var perfCalculatingMethods = GetType().GetRuntimeMethods().Where(m => m.IsDefined(typeof(PerfMetric)));
foreach (var method in perfCalculatingMethods)
{
var result = method.Invoke(this, new object[] { functionName, testStartTime, testEndTime }).ToString();
var perfMetricAttribute = method.GetCustomAttribute(typeof(PerfMetric)) as PerfMetric;
var metricName = perfMetricAttribute.MetricName;
perfResults.AddMetric(metricName, result);
}
var additionalPerfResults = ObtainAdditionalPerfMetrics(perfResults, functionName, testStartTime, testEndTime) ?? new Dictionary <string, string>();
var additionalPerfResultsList = additionalPerfResults.ToList();
foreach (var additionalPerfResult in additionalPerfResultsList)
{
perfResults.AddMetric(additionalPerfResult.Key, additionalPerfResult.Value);
}
return(perfResults);
}
protected abstract Dictionary <string, string> ObtainAdditionalPerfMetrics(PerfTestResult genericPerfTestResult, string functionName, DateTime testStartTime, DateTime testEndTime);
protected override Dictionary <string, string> ObtainAdditionalPerfMetrics(PerfTestResult genericPerfTestResult,
string functionName, DateTime testStartTime, DateTime testEndTime, List <OutputLogEvent> lambdaExecutionLogs)
{
return(null);
}
void OnNext(PerfTestResult value)
{
this.list.Add(value);
Console.WriteLine(value);
}
protected override Dictionary <string, string> ObtainAdditionalPerfMetrics(PerfTestResult genericPerfTestResult, string functionName, DateTime testStartTime,
DateTime testEndTime)
{
return(ObtainAdditionalPerfMetrics(genericPerfTestResult, functionName, testStartTime, testEndTime, FunctionLogs(functionName, testStartTime, testEndTime)));
}
protected internal virtual void addTableBody(TabularResultSet tabularResultSet, IList <string> watchActivities, PerfTestResult passResult)
{
// get first and last timestamp
DateTime firstStartTime = null;
DateTime lastEndTime = null;
foreach (IList <ActivityPerfTestResult> activityResults in passResult.ActivityResults.Values)
{
foreach (ActivityPerfTestResult activityResult in activityResults)
{
if (firstStartTime == null || activityResult.StartTime < firstStartTime)
{
firstStartTime = activityResult.StartTime;
}
if (lastEndTime == null || activityResult.EndTime > lastEndTime)
{
lastEndTime = activityResult.EndTime;
}
}
}
long firstTimestamp = firstStartTime.Ticks;
long lastTimestamp = lastEndTime.Ticks;
IList <IDictionary <string, ActivityCount> > resultTable = new List <IDictionary <string, ActivityCount> >();
for (long t = firstTimestamp; t <= lastTimestamp + INTERVAL; t += INTERVAL)
{
IDictionary <string, ActivityCount> activitiesMap = new Dictionary <string, ActivityCount>();
foreach (string activity in watchActivities)
{
activitiesMap[activity] = new ActivityCount(this);
}
resultTable.Add(activitiesMap);
}
foreach (IList <ActivityPerfTestResult> activityResults in passResult.ActivityResults.Values)
{
foreach (ActivityPerfTestResult activityResult in activityResults)
{
string activityId = activityResult.ActivityId;
int startSlot = calculateTimeSlot(activityResult.StartTime, firstTimestamp);
int endSlot = calculateTimeSlot(activityResult.EndTime, firstTimestamp);
resultTable[startSlot][activityId].incrementStarted();
resultTable[endSlot][activityId].incrementEnded();
resultTable[endSlot][activityId].addDuration(activityResult.Duration);
}
}
List <object> row = null;
IDictionary <string, ActivityCount> sumMap = new Dictionary <string, ActivityCount>();
foreach (string activity in watchActivities)
{
sumMap[activity] = new ActivityCount(this);
}
long sumActivitiesEnded = 0;
for (int i = 0; i < resultTable.Count; i++)
{
row = new List <object>();
row.Add(i * INTERVAL / TIME_UNIT);
long currentActivitiesEnded = 0;
foreach (string activity in watchActivities)
{
sumMap[activity].addStarted(resultTable[i][activity].Started);
sumMap[activity].addEnded(resultTable[i][activity].Ended);
sumMap[activity].addDuration(resultTable[i][activity].Duration);
currentActivitiesEnded += resultTable[i][activity].Ended;
}
foreach (string activity in watchActivities)
{
long started = resultTable[i][activity].Started;
long ended = resultTable[i][activity].Ended;
double endedFraction = 0;
long avgDuration = 0;
if (sumMap[activity].Ended > 0)
{
avgDuration = sumMap[activity].Duration / sumMap[activity].Ended;
}
if (currentActivitiesEnded > 0)
{
endedFraction = ended * 100.0 / currentActivitiesEnded;
}
row.Add(started);
row.Add(sumMap[activity].Started);
row.Add(string.Format("{0:D} ({1:F1}%)", ended, endedFraction));
row.Add(sumMap[activity].Ended);
row.Add(avgDuration + " ms");
}
sumActivitiesEnded += currentActivitiesEnded;
row.Add(currentActivitiesEnded / INTERVAL_SECONDS);
row.Add(sumActivitiesEnded / ((i + 1) * INTERVAL_SECONDS));
tabularResultSet.addResultRow(row);
}
}
protected internal virtual TabularResultSet processPassResult(IList <string> watchActivities, PerfTestResult passResult)
{
TabularResultSet tabularResultSet = new TabularResultSet();
addTableHeaders(tabularResultSet, watchActivities);
addTableBody(tabularResultSet, watchActivities, passResult);
return(tabularResultSet);
}
protected internal virtual string getPassTitle(string testName, PerfTestConfiguration configuration, PerfTestResult passResult)
{
return(testName + " (Runs: " + configuration.NumberOfRuns + ", Threads: " + passResult.NumberOfThreads + ", Duration: " + passResult.Duration + " ms)");
}
