private async Task RampUpAsync(TestRunInfo testRunInfo)
{
// Handle ramp up if defined
if (testRunInfo.RampUpTimeSeconds > 4 && !_terminate)
{
Tracer.TraceInfo($"Ramping up starts.");
DateTime startTime = DateTime.Now;
DateTime endTime = startTime + TimeSpan.FromSeconds(testRunInfo.RampUpTimeSeconds);
int numberIntervals = Math.Min(testRunInfo.RampUpTimeSeconds / 5, 6);
TimeSpan intervalLength = (endTime - startTime) / numberIntervals;
double intervalRpsDelta = ((double)testRunInfo.TargetRPS) / ((double)numberIntervals);
for (int i = 0; i < numberIntervals && !_terminate; i++)
{
var apiInfo = _mixInfo.ApiMix[i % _mixInfo.ApiMix.Count];
long intervalRps = (long)Math.Round((i + 1) * intervalRpsDelta);
Tracer.TraceInfo($"Ramping up. RPS = {intervalRps}");
AsyncFor myRampUpFor = new AsyncFor(intervalRps, GetResourceDescription(apiInfo, _mixInfo), GetTestDescription(apiInfo), testRunInfo.MeasureServerSideTime);
myRampUpFor.PerSecondMetricsAvailable += new ConsoleMetricsHandler().MetricsAvailableHandler;
_asyncForInstances.Add(myRampUpFor);
await myRampUpFor.For(intervalLength, testRunInfo.SimultaneousConnections, new MaaServiceApiCaller(apiInfo, _mixInfo.ProviderMix, testRunInfo.EnclaveInfoFile, testRunInfo.ForceReconnects).CallApi);
}
Tracer.TraceInfo($"Ramping up complete.");
}
}
public static async Task <Arm11LocalSystemCapabilities> Load(IReadOnlyBinaryDataAccessor data)
{
var capabilities = new Arm11LocalSystemCapabilities
{
ProgramId = await data.ReadInt64Async(0),
CoreVersion = await data.ReadInt32Async(0x8),
Flag1 = await data.ReadByteAsync(0xC),
Flag2 = await data.ReadByteAsync(0xD),
Flag0 = await data.ReadByteAsync(0xE),
Priority = await data.ReadByteAsync(0xF),
ResourceLimitDescriptors = await data.ReadArrayAsync(0x10, 0x20),
StorageInformation = await StorageInfo.Load(data.Slice(0x30, 0x20)),
};
var accessControl = new long[32];
await AsyncFor.For(0, 32 - 1, async i =>
{
accessControl[i] = await data.ReadInt64Async(0x50 + 8 * i);
});
capabilities.ServiceAccessControl = accessControl;
capabilities.ExtendedServiceAccessControl = new long[] { await data.ReadInt64Async(0x150), await data.ReadInt64Async(0x158) };
capabilities.Reserved = await data.ReadArrayAsync(0x160, 0xF);
capabilities.ResourceLimitCategory = await data.ReadByteAsync(0x16F);
return(capabilities);
}
public async Task RunAsync()
{
// Complete all HTTP conversations before exiting application
Console.CancelKeyPress += HandleControlC;
// Retrieve all run configuration settings
_mixInfo = _options.GetMixInfo();
_mixInfo.Trace();
using (var uberCsvAggregator = new CsvAggregatingMetricsHandler())
{
for (int i = 0; i < _mixInfo.TestRuns.Count && !_terminate; i++)
{
var testRunInfo = _mixInfo.TestRuns[i];
var asyncRunners = new List <Task>();
uberCsvAggregator.SetRpsAndConnections(testRunInfo.TargetRPS, testRunInfo.SimultaneousConnections);
Tracer.TraceInfo("");
Tracer.TraceInfo($"Starting test run #{i} RPS: {testRunInfo.TargetRPS} Connections: {testRunInfo.SimultaneousConnections}");
// Handle ramp up if needed
await RampUpAsync(testRunInfo);
// Initiate separate asyncfor for each API in the mix
if (!_terminate)
{
foreach (var apiInfo in _mixInfo.ApiMix)
{
var myFor = new AsyncFor(testRunInfo.TargetRPS * apiInfo.Percentage, GetResourceDescription(apiInfo, _mixInfo), GetTestDescription(apiInfo), testRunInfo.MeasureServerSideTime);
if (_mixInfo.ApiMix.Count > 1)
{
myFor.PerSecondMetricsAvailable += new ConsoleAggregatingMetricsHandler(_mixInfo.ApiMix.Count, 60).MetricsAvailableHandler;
}
else
{
myFor.PerSecondMetricsAvailable += new ConsoleMetricsHandler().MetricsAvailableHandler;
myFor.PerSecondMetricsAvailable += new CsvFileMetricsHandler().MetricsAvailableHandler;
}
if (testRunInfo.TestTimeSeconds != int.MaxValue)
{
myFor.PerSecondMetricsAvailable += uberCsvAggregator.MetricsAvailableHandler;
}
_asyncForInstances.Add(myFor);
asyncRunners.Add(myFor.For(TimeSpan.FromSeconds(testRunInfo.TestTimeSeconds), testRunInfo.SimultaneousConnections, new MaaServiceApiCaller(apiInfo, _mixInfo.ProviderMix, testRunInfo.EnclaveInfoFile, testRunInfo.ForceReconnects).CallApi));
}
}
// Wait for all to be complete (happens when crtl-c is hit)
await Task.WhenAll(asyncRunners.ToArray());
Tracer.TraceInfo("");
Tracer.TraceInfo($"Completed test run #{i} RPS: {testRunInfo.TargetRPS} Connections: {testRunInfo.SimultaneousConnections}");
}
}
Tracer.TraceInfo($"Organized shutdown complete.");
}
public async Task RunAsync()
{
await Authentication.Authentication.AcquireAccessTokenAsync("microsoft.com", false);
AsyncFor myFor = new AsyncFor(_options.TargetRPS, "MAA SGX Attest");
myFor.PerSecondMetricsAvailable += new ConsoleMetricsHandler().MetricsAvailableHandler;
myFor.PerSecondMetricsAvailable += new CsvFileMetricsHandler().MetricsAvailableHandler;
await myFor.For(TimeSpan.MaxValue, _options.SimultaneousConnections, CallAttestSgx);
}
public async Task RunsForEveryNumberWithSynchronousDelegate_StaticMethod()
{
var sum = 0;
var lockObject = new object();
await AsyncFor.For(0, 10, i =>
{
lock (lockObject)
{
sum += i;
}
});
Assert.Equal(55, sum);
}
public static async Task <Arm11KernelCapabilities> Load(IReadOnlyBinaryDataAccessor data)
{
var capabilities = new Arm11KernelCapabilities();
var descriptors = new int[28];
await AsyncFor.For(0, 28 - 1, async i =>
{
descriptors[i] = await data.ReadInt32Async(i * 4);
});
capabilities.Descriptors = descriptors;
capabilities.Reserved = await data.ReadArrayAsync(0x70, 0x10);
return(capabilities);
}
public async Task UsesStepCount()
{
var sum = 0;
var lockObject = new object();
await AsyncFor.For(0, 10, i =>
{
lock (lockObject)
{
sum += i;
}
}, stepCount : 2);
Assert.Equal(30, sum);
}
public async Task RunsBackwardsWithNegativeStepCount()
{
var sum = 0;
var lockObject = new object();
await AsyncFor.For(10, 0, i =>
{
lock (lockObject)
{
sum += i;
}
}, stepCount : -2);
Assert.Equal(30, sum);
}
public async Task DoesNothingWhenEndComesBeforeStart()
{
var sum = 0;
var lockObject = new object();
await AsyncFor.For(0, -10, i =>
{
lock (lockObject)
{
sum += i;
}
});
Assert.Equal(0, sum);
}
public async Task ReportsProgressThroughToken()
{
var progressToken = new ProgressReportToken();
await AsyncFor.For(1, 10, i =>
{
Assert.False(progressToken.IsCompleted);
Assert.False(progressToken.IsIndeterminate);
Assert.True(progressToken.Progress < 1);
}, progressReportToken : progressToken, batchSize : 2);
Assert.True(progressToken.IsCompleted);
Assert.False(progressToken.IsIndeterminate);
Assert.Equal(1, progressToken.Progress, precision: 1);
}
public async Task ThrowsOnZeroStepCount()
{
var sum = 0;
var lockObject = new object();
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() =>
{
await AsyncFor.For(0, 10, i =>
{
lock (lockObject)
{
sum += i;
}
}, stepCount: 0);
});
}
public async Task UnwrapsSingleExceptionAggregateExceptions()
{
var ex = await Assert.ThrowsAsync <AggregateException>(async() =>
{
await AsyncFor.For(0, 6, i =>
{
if (i % 2 == 1)
{
throw new TestException();
}
});
});
Assert.Equal(3, ex.InnerExceptions.Count);
Assert.All(ex.InnerExceptions, e => Assert.IsType <TestException>(e));
}
public async Task NoConcurrencyWithSynchronousOption()
{
var taskAlreadyRunning = false;
await AsyncFor.For(0, 6, async i =>
{
if (taskAlreadyRunning)
{
throw new Exception("Task is already running, so the 'RunSynchronously' option was ignored.");
}
taskAlreadyRunning = true;
// Delay to increase chances of concurrency
await Task.Delay(100);
taskAlreadyRunning = false;
}, runSynchronously : true);
}
private async Task temp()
{
var progressToken = new ProgressReportToken();
progressToken.ProgressChanged += (object sender, ProgressReportedEventArgs e) =>
{
Console.WriteLine($"Progress: {e.Progress * 100} %");
};
progressToken.Completed += (object sender, EventArgs e) =>
{
Console.WriteLine("Completed!");
};
await AsyncFor.For(0, 10, i =>
{
Console.WriteLine(i);
}, progressReportToken : progressToken);
}
public async Task RunsConcurrently()
{
var taskAlreadyRunning = false;
var anyConcurrency = false;
await AsyncFor.For(0, 6, async i =>
{
if (taskAlreadyRunning)
{
anyConcurrency = true;
}
taskAlreadyRunning = true;
// Delay to increase chances of concurrency
await Task.Delay(100);
taskAlreadyRunning = false;
}, runSynchronously : false);
Assert.True(anyConcurrency);
}
public async Task CapturesAllExceptions()
{
var ex = await Assert.ThrowsAsync <AggregateException>(async() =>
{
await AsyncFor.For(0, 6, i =>
{
if (i % 2 == 1)
{
throw new AggregateException(new TestException(), new TestException());
}
});
});
Assert.Equal(3, ex.InnerExceptions.Count);
Assert.All(ex.InnerExceptions, e =>
{
Assert.IsType <AggregateException>(e);
Assert.All((e as AggregateException).InnerExceptions, inner => Assert.IsType <TestException>(inner));
});
}
public async Task BatchSizeLimitsConcurrency()
{
var runningTasks = 0;
var batchSize = 5;
await AsyncFor.For(0, 20, async i =>
{
if (runningTasks > batchSize)
{
throw new Exception("Maximum task count exceeded.");
}
Interlocked.Increment(ref runningTasks);
// Delay to increase chances of concurrency problems
await Task.Delay(100);
Interlocked.Decrement(ref runningTasks);
}, batchSize : batchSize);
}
public static async Task <NcchExtendedHeader> Load(IReadOnlyBinaryDataAccessor data)
{
var header = new NcchExtendedHeader
{
ApplicationTitle = await data.ReadStringAsync(0, 8, Encoding.ASCII),
Reserved1 = await data.ReadArrayAsync(8, 5),
Flag = await data.ReadByteAsync(0xD),
RemasterVersion = await data.ReadInt16Async(0xE),
TextCodeSetInfo = await CodeSetInfo.Load(data.Slice(0x10, 0xC)),
StackSize = await data.ReadInt32Async(0x1C),
ReadOnlyCodeSetInfo = await CodeSetInfo.Load(data.Slice(0x20, 0xC)),
Reserved2 = await data.ReadInt32Async(0x2C),
DataCodeSetInfo = await CodeSetInfo.Load(data.Slice(0x30, 0xC)),
BssSize = await data.ReadInt32Async(0x3C)
};
var moduleIds = new long[48];
await AsyncFor.For(0, 48 - 1, async i =>
{
moduleIds[i] = await data.ReadInt64Async(0x40 + i * 8);
});
header.DependencyModuleIds = moduleIds;
header.SystemInformation = await SystemInfo.Load(data.Slice(0x1C0, 0x40));
header.LocalSystemCapabilities = await Arm11LocalSystemCapabilities.Load(data.Slice(0x200, 0x170));
header.KernelCapabilities = await Arm11KernelCapabilities.Load(data.Slice(0x370, 0x80));
header.AccessControl = await Arm9AccessControl.Load(data.Slice(0x3F0, 0x10));
header.AccessDescSignature = await data.ReadArrayAsync(0x400, 0x100);
header.NcchHdrPublicKey = await data.ReadArrayAsync(0x500, 0x100);
header.Aci = await data.ReadArrayAsync(0x600, 0x200);
return(header);
}