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);
}
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 async Task ThrowsOnSimultaneousInstanceUsage()
{
var sum = 0;
var lockObject = new object();
var f = new AsyncFor();
var first = f.RunFor(0, 10, async i =>
{
lock (lockObject)
{
sum += i;
}
await Task.Delay(100);
});
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await f.RunFor(0, 10, async i =>
{
lock (lockObject)
{
sum += i;
}
await Task.Delay(100);
});
});
}
public async Task ExtractFiles(string directoryName, IFileSystem fileSystem, ExtractionProgressedToken progressReportToken = null)
{
if (progressReportToken != null)
{
progressReportToken.TotalFileCount = Headers.Count(h => h != null && !string.IsNullOrEmpty(h.Filename));
}
if (!fileSystem.DirectoryExists(directoryName))
{
fileSystem.CreateDirectory(directoryName);
}
var a = new AsyncFor();
await a.RunForEach(Headers, async (header) =>
{
if (string.IsNullOrEmpty(header.Filename))
{
return;
}
fileSystem.WriteAllBytes(Path.Combine(directoryName, header.Filename), await ExeFsData.ReadArrayAsync(0x200 + header.Offset, header.FileSize));
if (progressReportToken != null)
{
progressReportToken.IncrementExtractedFileCount();
}
});
}
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 RunsForEveryItemInGenericEnumerableWithSynchronousDelegate_InstanceMethod()
{
var sampleData = Enumerable.Repeat(new TestClass(), 5);
var f = new AsyncFor();
await f.RunForEach(sampleData, data =>
{
data.Success = true;
});
Assert.All(sampleData, data => Assert.True(data.Success));
}
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 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 RunsForEveryNumberWithSynchronousDelegate_StaticMethod()
{
var sum = 0;
var lockObject = new object();
await AsyncFor.For(0, 10, i =>
{
lock (lockObject)
{
sum += i;
}
});
Assert.Equal(55, 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 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 ReportsProgressThroughInstanceProperties()
{
var f = new AsyncFor();
await f.RunFor(0, 6, i =>
{
Assert.False(f.IsCompleted);
Assert.False(f.IsIndeterminate);
Assert.True(f.Progress < 1);
});
Assert.True(f.IsCompleted);
Assert.False(f.IsIndeterminate);
Assert.Equal(1, f.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 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 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);
}
public async Task RunsForEveryNumberWithAsynchronousDelegate_InstanceMethod()
{
var sum = 0;
var lockObject = new object();
var f = new AsyncFor();
await f.RunFor(0, 10, async i =>
{
lock (lockObject)
{
sum += i;
}
await Task.CompletedTask;
});
Assert.Equal(55, sum);
}
private async Task RampUpAsync(TestRunInfo testRunInfo)
{
// Handle ramp up if defined
if (testRunInfo.RampUpTimeSeconds > 4 && !_cancellationTokenSource.IsCancellationRequested)
{
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 && !_cancellationTokenSource.IsCancellationRequested; 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);
try
{
await myRampUpFor.ForAsync(
intervalLength,
testRunInfo.SimultaneousConnections,
new MaaServiceApiCaller(apiInfo, _mixInfo.ProviderMix, testRunInfo.EnclaveInfoFile, testRunInfo.ForceReconnects).CallApi,
_cancellationTokenSource.Token);
}
catch (TaskCanceledException)
{
// Ignore task cancelled if we requested cancellation via ctrl-c
if (_cancellationTokenSource.IsCancellationRequested)
{
Tracer.TraceInfo(($"Organized shutdown in progress. All asyncfor instances have gracefully shutdown."));
}
else
{
throw;
}
}
}
Tracer.TraceInfo($"Ramping up complete.");
}
}
public async Task ReportsProgressThroughInstanceEvent()
{
var myCustomMessage = $"Loading... ({Guid.NewGuid()})";
var progressEventArgs = new ConcurrentBag <ProgressReportedEventArgs>();
var completedCount = 0;
void OnProgressChanged(object sender, ProgressReportedEventArgs e)
{
progressEventArgs.Add(e);
Assert.Equal(myCustomMessage, e.Message);
Assert.False(e.IsIndeterminate);
Assert.True(e.Progress <= 1);
}
void OnCompleted(object sender, EventArgs e)
{
Interlocked.Increment(ref completedCount);
}
var sampleData = Enumerable.Repeat(new TestClass(), 5).ToList();
var f = new AsyncFor();
f.Message = myCustomMessage;
f.ProgressChanged += OnProgressChanged;
f.Completed += OnCompleted;
f.BatchSize = 2;
await f.RunForEach(sampleData, data =>
{
data.Success = true;
});
f.ProgressChanged -= OnProgressChanged;
f.Completed -= OnCompleted;
Assert.Equal(sampleData.Count, progressEventArgs.Count);
Assert.Equal(1, completedCount);
var distinctProgressPercentages = progressEventArgs.Select(e => e.Progress).Distinct().ToList();
Assert.InRange(distinctProgressPercentages.Count, 2, 5);
Assert.All(distinctProgressPercentages, p => Assert.InRange(p, 0, 1));
Assert.Contains(distinctProgressPercentages, p => p != 0 && p != 1);
}
/// <summary>
/// Extracts all files to the given directory
/// </summary>
/// <param name="outputDirectory">Directory to which the files should be saved. This will be created if it does not exist.</param>
/// <param name="fileSystem">File system to which to save the files</param>
public async Task Extract(string outputDirectory, IFileSystem fileSystem, ProgressReportToken?progressReportToken = null)
{
if (!fileSystem.DirectoryExists(outputDirectory))
{
fileSystem.CreateDirectory(outputDirectory);
}
var filenames = GetFilenames();
await AsyncFor.ForEach(filenames, filename =>
{
var fileData = GetFile(filename);
if (fileData == null)
{
return;
}
fileSystem.WriteAllBytes(Path.Combine(outputDirectory, filename), fileData);
}, progressReportToken : progressReportToken).ConfigureAwait(false);
}
public async Task <IEnumerable <FileTypeDetectionResult> > DetectFileType(GenericFile file, PluginManager manager)
{
ConcurrentQueue <FileTypeDetectionResult> matches = new ConcurrentQueue <FileTypeDetectionResult>();
AsyncFor f = new AsyncFor();
f.RunSynchronously = !file.IsThreadSafe;
await f.RunForEach(manager.GetRegisteredObjects <IDetectableFileType>(), async (x) =>
{
if (await x.IsOfType(file))
{
matches.Enqueue(new FileTypeDetectionResult {
FileType = x.GetType().GetTypeInfo(), MatchChance = 0.5f
});
}
});
return(matches);
}
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 ThrowsOnSimultaneousInstanceUsage()
{
var sampleData = Enumerable.Repeat(new TestClass(), 5);
var f = new AsyncFor();
var firstTask = f.RunForEach(sampleData, async data =>
{
data.Success = true;
await Task.Delay(100);
});
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await f.RunForEach(sampleData, async data =>
{
data.Success = true;
await Task.Delay(100);
});
});
}
public async Task ReportsProgressThroughInstanceProperties()
{
var sampleData = Enumerable.Repeat(new TestClass(), 5);
var f = new AsyncFor();
await f.RunForEach(sampleData, data =>
{
Assert.False(f.IsCompleted);
Assert.False(f.IsIndeterminate);
Assert.True(f.Progress < 1);
data.Success = true;
});
Assert.True(f.IsCompleted);
Assert.False(f.IsIndeterminate);
Assert.Equal(1, f.Progress, precision: 1);
Assert.All(sampleData, data => Assert.True(data.Success));
}
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);
}
/// <summary>
/// Asynchronously copies a directory
/// </summary>
/// <param name="sourceDirectory">The directory to copy</param>
/// <param name="destinationDirectory">The new destination for the source directory</param>
public static async Task CopyDirectory(string sourceDirectory, string destinationDirectory, IFileSystem provider)
{
// Get the files/directories to copy
var files = provider.GetFiles(sourceDirectory, "*", false);
//Create all required directories
foreach (var item in files)
{
var dest = item.Replace(sourceDirectory, destinationDirectory);
if (!provider.DirectoryExists(Path.GetDirectoryName(dest)))
{
provider.CreateDirectory(Path.GetDirectoryName(dest));
}
}
AsyncFor f = new AsyncFor();
f.RunSynchronously = false;
await f.RunForEach(files, path =>
{
string dest = path.Replace(sourceDirectory, destinationDirectory);
provider.CopyFile(path, dest);
}).ConfigureAwait(false);
}
