private void GenerateConstructors(GeneratedData toGenerate, CodeGenerationStore store)
{
foreach (var cls in toGenerate.Classes)
{
var type = cls.Key;
var node = cls.Value;
var fields = store.Fields[type].Select(x => (x, x.Name))
.ToDictionary(x => x.Name, x => x.x);
foreach (IConstructorBuilder constructor in store.Constructors[type])
{
var generator = constructor.GetILGenerator();
var parameters = toGenerate.Constructors[constructor].Parameters
.Select((p, i) => (i, store.Types[p.Type], p.Name))
.ToDictionary(x => x.Name, x => ((short)x.i, x.Item2));
var methodInfo = new CurrentMethodInfo(type, typeChecker !.VoidType, false,
parameters, fields);
var generation = new ILGeneration(generator, store, methodInfo, delegateConstructorTypes !, baseConstructorInfo !, typeChecker !);
GenerateMethod(generation, toGenerate.Constructors[constructor].Statements);
}
}
}
private void GenerateMethods(GeneratedData toGenerate, CodeGenerationStore store)
{
foreach (var cls in toGenerate.Classes)
{
var type = cls.Key;
var node = cls.Value;
var fields = store.Fields[type].Select(x => (x, x.Name))
.ToDictionary(x => x.Name, x => x.x);
foreach (IMethodBuilder method in store.Methods[type])
{
var generator = method.GetILGenerator();
int offset = method.IsStatic ? 0 : 1;
var parameters = toGenerate.Methods[method].Parameters
.Select((p, i) => (i + offset, store.Types[p.Type], p.Name))
.ToDictionary(x => x.Name, x => ((short)x.Item1, x.Item2));
var methodInfo = new CurrentMethodInfo(type, method.ReturnType, method.IsStatic,
parameters, fields);
var generation = new ILGeneration(generator, store, methodInfo, delegateConstructorTypes !, baseConstructorInfo !, typeChecker !);
GenerateMethod(generation, toGenerate.Methods[method].Statements);
}
}
}
private static int Calculate(List <int> numbers, int count)
{
var memory = numbers
.Select((character, index) => (character, index))
.ToDictionary(x => x.character, x => (-1, x.index));
var lastNumber = memory.Last().Key;
for (var i = numbers.Count; i < count; i++)
{
if (memory.TryGetValue(lastNumber, out var lastIndex))
{
if (lastIndex.Item1 == -1)
{
lastNumber = 0;
}
else
{
lastNumber = lastIndex.index - lastIndex.Item1;
}
}
if (memory.ContainsKey(lastNumber))
{
memory[lastNumber] = (memory[lastNumber].index, i);
}
else
{
memory[lastNumber] = (-1, i);
}
}
return(lastNumber);
}
private int Run(int limit)
{
var numbers = lines[0].Split(",")
.Select((number, index) => (index: index + 1, number: int.Parse(number)))
.ToDictionary(number => number.number, number => (number.index, previousIndex: 0));
var lastNumber = numbers.Keys.Last();
for (var i = numbers.Count + 1; i <= limit; i++)
{
if (numbers.TryGetValue(lastNumber, out var value) && value.previousIndex > 0)
{
AddNumber(value.index - value.previousIndex, i);
}
else
{
AddNumber(0, i);
}
}
void AddNumber(int number, int index)
{
if (numbers.TryGetValue(number, out var value))
{
numbers[number] = (index, value.Item1);
}
else
{
numbers[number] = (index, 0);
}
lastNumber = number;
}
return(lastNumber);
}
public async Task <int> RunAsync()
{
if (!base.DoCommonSetup())
{
return(-1);
}
var artifacts = OptionDefinition.PrintPullRequestSizeChanges.NamedArtifactPaths.ValueFrom(this.baseCommand)
.Split(';')
.Select(artifactToken => new ArtifactEntryInfo(artifactToken))
.ToList();
var referenceBuilds = await this.GetReferenceBuildsByCommitId();
var referenceBuildsWithSize = referenceBuilds
.Select(buildByCommit => (
Commit: buildByCommit.Key,
Build: buildByCommit.Value,
Size: (Dictionary <string, int>)null))
.ToDictionary(
group => group.Commit,
group => (group.Build, group.Size));
var pullRequestsWithBuilds = await this.GetPullRequestsWithBuildsAsync();
foreach (var prBuildEntry in pullRequestsWithBuilds)
{
await this.CheckPullRequestBuildAsync(prBuildEntry, referenceBuildsWithSize, artifacts);
}
return(0);
}
private static int FindNumberAtTurn(IList <int> numbers, int turn)
{
IDictionary <int, (int, int)> numberToTurns = numbers
.Select((numbers, idx) => (numbers, idx))
.ToDictionary(t => t.Item1, t => (-1, t.Item2));
foreach (int currentTurn in Enumerable.Range(numbers.Count, turn - numbers.Count))
{
int lastNumber = numbers.Last();
(int secondLastTurn, int lastTurn) = numberToTurns[lastNumber];
int number = secondLastTurn != -1 ? lastTurn - secondLastTurn : 0;
if (!numberToTurns.ContainsKey(number))
{
numberToTurns[number] = (-1, currentTurn);
}
else
{
numberToTurns[number] = (numberToTurns[number].Item2, currentTurn);
}
numbers.Add(number);
}
return(numbers.Last());
}
private async Task OkAsync()
{
var daysDictionary = Days !.ToDictionary(x => x.DayOfWeek, x => (x.SpecificRecipe?.ID ?? x.Recipe?.ID, x.Garnish?.ID));
await dayService.CreateWeekAsync(WeekStart, daysDictionary);
regionManager.NavigateMain(view: nameof(WeekView),
parameters: (Consts.ReloadWeekParameter, true));
}
public override async Task Execute(IConfiguration config, ILogger logger, bool useTestData)
{
var input = await GetInputLines(useTestData);
// Parse the input, get a collection of bags and the bags that they contain
var bags = input
.Select(line => line.Trim('.').Split(" bags contain "))
.Select(splits => (splits[0], splits[1].Replace(" bags", "").Replace(" bag", "")))
.ToDictionary(m =>
m.Item1,
m => m.Item2.StartsWith("no other")
? new (int, string)[] {}
public static Summary[] Run(BenchmarkRunInfo[] benchmarkRunInfos, IConfig commonSettingsConfig, bool summaryPerType)
{
var resolver = DefaultResolver;
var artifactsToCleanup = new List <string>();
var title = GetTitle(benchmarkRunInfos);
var rootArtifactsFolderPath = (commonSettingsConfig?.ArtifactsPath ?? DefaultConfig.Instance.ArtifactsPath).CreateIfNotExists();
using (var logStreamWriter = Portability.StreamWriter.FromPath(Path.Combine(rootArtifactsFolderPath, title + ".log")))
{
var logger = new CompositeLogger(commonSettingsConfig.GetCompositeLogger(), new StreamLogger(logStreamWriter));
var supportedBenchmarks = GetSupportedBenchmarks(benchmarkRunInfos, logger, resolver);
var validationErrors = Validate(supportedBenchmarks, logger);
if (validationErrors.Any(validationError => validationError.IsCritical))
{
return new [] { Summary.CreateFailed(
supportedBenchmarks.SelectMany(b => b.Benchmarks).ToArray(),
title, HostEnvironmentInfo.GetCurrent(), commonSettingsConfig, GetResultsFolderPath(rootArtifactsFolderPath), validationErrors) }
}
;
var buildPartitions = BenchmarkPartitioner.CreateForBuild(supportedBenchmarks, resolver);
logger.WriteLineHeader("// ***** BenchmarkRunner: Start *****");
var globalChronometer = Chronometer.Start();
var buildResults = BuildInParallel(logger, rootArtifactsFolderPath, buildPartitions, ref globalChronometer);
try
{
var results = new List <Summary>();
var benchmarkToBuildResult = buildResults
.SelectMany(buildResult => buildResult.Key.Benchmarks.Select(buildInfo => (buildInfo.Benchmark, buildInfo.Id, buildResult.Value)))
.ToDictionary(info => info.Benchmark, info => (info.Id, info.Value));
foreach (var benchmarkRunInfo in supportedBenchmarks) // we run them in the old order now using the new build artifacts
{
results.Add(Run(benchmarkRunInfo, benchmarkToBuildResult, resolver, logger, artifactsToCleanup, rootArtifactsFolderPath, ref globalChronometer));
}
return(results.ToArray());
}
finally
{
logger.WriteLineHeader("// * Artifacts cleanup *");
Cleanup(new HashSet <string>(artifactsToCleanup.Distinct()));
}
}
}
static void Main(string[] args)
{
var input = args.DefaultIfEmpty("14,3,1,0,9,5")
.First()
.Split(',')
.Select(int.Parse)
.ToArray();
var history = input.Select((n, i) => (num: n, turn: i + 1))
.ToDictionary(x => x.num, x => (last: x.turn, prev: default(int?)));
var currentTurn = input.Length + 1;
var lastNumber = input.Last();
while (currentTurn <= 30000000)
{
int nextNumber;
var(lastTurnNumber, previousTurnNumber) = history[lastNumber];
if (previousTurnNumber.HasValue)
{
nextNumber = lastTurnNumber - previousTurnNumber.Value;
}
else
{
nextNumber = 0;
}
if (history.TryGetValue(nextNumber, out var nextHumberHistory))
{
history[nextNumber] = (currentTurn, nextHumberHistory.last);
}
else
{
history[nextNumber] = (currentTurn, null);
}
if (currentTurn == 2020)
{
Console.WriteLine($"Part 1 Result = {nextNumber}");
}
lastNumber = nextNumber;
++currentTurn;
}
Console.WriteLine($"Part 2 Result = {lastNumber}");
}
protected TransportOutputChannel(ChannelManagerBase channelManager, EndpointAddress to, Uri via, bool manualAddressing, MessageVersion messageVersion)
: base(channelManager)
{
this.manualAddressing = manualAddressing;
this.messageVersion = messageVersion;
this.to = to;
this.via = via;
if (!manualAddressing && to != null)
{
Uri toUri;
if (to.IsAnonymous)
{
toUri = this.messageVersion.Addressing.AnonymousUri;
}
else if (to.IsNone)
{
toUri = this.messageVersion.Addressing.NoneUri;
}
else
{
toUri = to.Uri;
}
if (toUri != null)
{
XmlDictionaryString dictionaryTo = new ToDictionary(toUri.AbsoluteUri).To;
toHeader = ToHeader.Create(toUri, dictionaryTo, messageVersion.Addressing);
}
anyHeadersToAdd = to.Headers.Count > 0;
}
}
public void Test_5()
{
ToDictionary.eingabe("");
string ergebnis = ToDictionary.auslesen("");
Assert.AreEqual("", ergebnis);
}
protected TransportOutputChannel(IDefaultCommunicationTimeouts timeouts, EndpointAddress to, Uri via, bool manualAddressing, MessageVersion messageVersion)
: base(timeouts)
{
ManualAddressing = manualAddressing;
MessageVersion = messageVersion;
_to = to;
_via = via;
if (!manualAddressing && _to != null)
{
Uri toUri;
if (_to.IsAnonymous)
{
toUri = MessageVersion.Addressing.AnonymousUri;
}
else if (_to.IsNone)
{
toUri = MessageVersion.Addressing.NoneUri;
}
else
{
toUri = _to.Uri;
}
if (toUri != null)
{
XmlDictionaryString dictionaryTo = new ToDictionary(toUri.AbsoluteUri).To;
_toHeader = ToHeader.Create(toUri, dictionaryTo, messageVersion.Addressing);
}
_anyHeadersToAdd = _to.Headers.Count > 0;
}
}
public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey>(this TSource[] source, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparer = null)
{
var aggregate = new ToDictionary <TSource, TKey>(keySelector, comparer);
ArrayNode.ProcessArray(source, ref aggregate);
return(aggregate.GetResult());
}
public static Dictionary <TKey, TValue> ToDictionary <TSource, TKey, TValue>(this ReadOnlyMemory <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TValue> elementSelector, IEqualityComparer <TKey> comparer = null)
{
var aggregate = new ToDictionary <TSource, TKey, TValue>(keySelector, elementSelector, comparer);
MemoryNode.ProcessMemory(source, ref aggregate);
return(aggregate.GetResult());
}
protected TransportOutputChannel(ChannelManagerBase channelManager, EndpointAddress to, Uri via, bool manualAddressing, System.ServiceModel.Channels.MessageVersion messageVersion) : base(channelManager)
{
this.manualAddressing = manualAddressing;
this.messageVersion = messageVersion;
this.to = to;
this.via = via;
if (!manualAddressing && (to != null))
{
Uri anonymousUri;
if (to.IsAnonymous)
{
anonymousUri = this.messageVersion.Addressing.AnonymousUri;
}
else if (to.IsNone)
{
anonymousUri = this.messageVersion.Addressing.NoneUri;
}
else
{
anonymousUri = to.Uri;
}
XmlDictionaryString dictionaryTo = new ToDictionary(anonymousUri.AbsoluteUri).To;
this.toHeader = ToHeader.Create(anonymousUri, dictionaryTo, messageVersion.Addressing);
this.anyHeadersToAdd = to.Headers.Count > 0;
}
}
public void Test_6()
{
ToDictionary.eingabe("eggg==23");
string ergebnis = ToDictionary.auslesen("eggg");
Assert.AreEqual("=23", ergebnis);
}
private static long Play(IReadOnlyCollection <int> numbers, int iterations)
{
var dict = numbers
.Select((x, i) => (key: x, value: i + 1))
.ToDictionary(x => x.key, x => (lastIndex: x.value, lastBeforeIndex: (int?)null));
var lastNumberSpoken = numbers.Last();
for (var i = numbers.Count + 1; i <= iterations; i++)
{
var(lastIndex, lastBeforeIndex) = dict[lastNumberSpoken];
var newNumberSpoken = lastBeforeIndex == null ? 0 : lastIndex - lastBeforeIndex ?? 0;
dict[newNumberSpoken] = dict.ContainsKey(newNumberSpoken)
? dict[newNumberSpoken] = (i, dict[newNumberSpoken].lastIndex)
public void Test_7()
{
ToDictionary.eingabe("g=8;;h=2");
string ergebnis = ToDictionary.auslesen("h");
Assert.AreEqual("2", ergebnis);
}
private int SolveGame(int target)
{
Dictionary <int, (int num, int index)> spoken = _parsedInput.Select((number, index) => (number, index))
.ToDictionary(x => x.number, x => (-1, x.index));
var last = spoken.Last().Key;
for (var i = _parsedInput.Length; i < target; i++)
{
if (spoken.TryGetValue(last, out var lastIndex))
{
last = lastIndex.num != -1 ? lastIndex.index - lastIndex.num : 0;
}
spoken[last] = spoken.ContainsKey(last) ? (spoken[last].index, i) : (-1, i);
}
return(last);
}
static void Main(string[] args)
{
ToDictionary.eingabe("g=2;h=2");
string ergebnis = ToDictionary.auslesen("b");
Console.WriteLine(ergebnis);
Console.ReadLine();
}
#pragma warning disable S1144 // Dynamically activate type per generic type
public ReadOnlyCollectionConverter()
{
_properties = typeof(T)
.GetProperties()
.Select(x => new
{
Property = x,
CollectionInterface = x.CanWrite ? null : GetReadOnlyCollectionInterface(x.PropertyType)
})
.Where(x => x.Property.CanWrite || !(x.CollectionInterface is null))
.Select(x =>
{
var typeParameter = Expression.Parameter(typeof(T));
var valueParameter = Expression.Parameter(typeof(object));
Action <T, object> handler;
if (x.Property.CanWrite)
{
var assign = Expression.Assign(
Expression.Property(typeParameter, x.Property),
Expression.Convert(valueParameter, x.Property.PropertyType));
handler = Expression.Lambda <Action <T, object> >(assign, typeParameter, valueParameter).Compile();
}
else
{
var add = Expression.Call(
Expression.Property(typeParameter, x.Property),
x.CollectionInterface !.GetMethod(nameof(ICollection <T> .Add)),
Expression.Convert(valueParameter, x.CollectionInterface.GetGenericArguments().First()));
handler = Expression.Lambda <Action <T, object> >(add, typeParameter, valueParameter).Compile();
}
return(new
{
PropertyName = x.Property.Name,
x.Property.PropertyType,
CollectionElementType = x.CollectionInterface?.GetGenericArguments()?.First(),
Handler = handler
});
})
.ToDictionary(x => x.PropertyName, x => (x.PropertyType, x.CollectionElementType, x.Handler));
}
public string GetSolution()
{
var gameData = _inputService
.GetInput(resourceLocation)[0]
.Split(',')
.Select((value, index) => (long.Parse(value), index + 1))
.ToDictionary(x => x.Item1, x => (x.Item2, -1));
var lastNumber = gameData.Last().Key;
for (var turn = gameData.Count + 1; turn <= 30000000; turn++)
{
if (gameData.ContainsKey(lastNumber))
{
lastNumber = GetLastNumber(gameData, lastNumber);
if (gameData.ContainsKey(lastNumber))
{
gameData[lastNumber] = (turn, gameData[lastNumber].Item1);
public void TestRightJoin()
{
//--Arrange
var left = Enumerable.Range(5, 10).Select(x => (x, nameL: x.ToString())).ToList();
var right = Enumerable.Range(0, 10).Select(x => (x, nameR: x.ToString())).ToList();
//--Act
var joined = left.RightJoin(right, l => l.x, r => r.x, (l, r) => (r.x, l.nameL, r.nameR))
.ToDictionary(lr => lr.x, lr => (lr.nameL, lr.nameR));
//--Assert
Assert.AreEqual(10, joined.Count);
foreach (var key in Enumerable.Range(0, 10))
{
Assert.IsTrue(joined.TryGetValue(key, out var lr));
Assert.AreEqual(key.ToString(), lr.nameR);
Assert.AreEqual(key < 5 ? null : key.ToString(), lr.nameL);
}
}
/// <summary>
/// Compile a function to build an object from an object graph
/// </summary>
public static Func <ObjectGraph, IPropMapValueCache, ILogger, T> CompileObjectBuilder <T>()
{
var type = typeof(T);
// compile setter for each property
var propSetters = type
.GetFieldsAndProperties()
.Where(p => !p.readOnly)
.Select(p => (p.name, PropertySetters.GetPropertySetter <T>(p.type, p.name), p.type))
.ToDictionary(x => x.Item1, x => (setter: x.Item2, type: x.Item3));
// compile getters for each constructor type
var cArgGetters = type
.GetConstructors()
.Select(c => c.GetParameters().Select(p => p.ParameterType).ToArray())
.ToDictionary(x => x, x => x.Select(BuildValueGetter).ToArray(), ArrayComparer <Type> .Instance);
T build(ObjectGraph vals, IPropMapValueCache propMapValueCache, ILogger logger) => BuildObjectWithExceptionHandling(cArgGetters, propSetters, vals, propMapValueCache, logger);
return(build);
}
private static int Play(IReadOnlyCollection <int> startNumbers, int stop)
{
var spoken = startNumbers
.Select((n, i) => (Number: n, Index: i))
.ToDictionary(
t => t.Number,
t => (Current: t.Index, Previous: t.Index));
var previous = startNumbers.Last();
for (var i = startNumbers.Count; i < stop; i++)
{
var(cur, prev) = spoken[previous];
var next = cur - prev;
if (!spoken.ContainsKey(next))
{
spoken[next] = (i, i);
}
else
{
spoken[next] = (i, spoken[next].Current);
public string Solve2()
{
var input = File.ReadAllText(@"Day15\input.txt").Split(',').Select(int.Parse).ToArray();
var step = input.Length + 1;
var dict = input.Select((c, i) => (c, i)).ToDictionary(o => o.c, o => (-1, o.i + 1));
var lastNumber = input.Last();
while (step <= 30000000)
{
if (dict[lastNumber].Item1 == -1)
{
lastNumber = 0;
Speak(dict, lastNumber, step);
}
else
{
lastNumber = dict[lastNumber].Item2 - dict[lastNumber].Item1;
Speak(dict, lastNumber, step);
}
step++;
}
return(lastNumber.ToString());
}
protected TransportOutputChannel(ChannelManagerBase channelManager, EndpointAddress to, Uri via, bool manualAddressing, MessageVersion messageVersion)
: base(channelManager)
{
_manualAddressing = manualAddressing;
_messageVersion = messageVersion;
_to = to;
_via = via;
if (!manualAddressing && to != null)
{
Uri toUri;
if (to.IsAnonymous)
{
toUri = _messageVersion.Addressing.AnonymousUri;
}
else if (to.IsNone)
{
toUri = _messageVersion.Addressing.NoneUri;
}
else
{
toUri = to.Uri;
}
if (toUri != null)
{
XmlDictionaryString dictionaryTo = new ToDictionary(toUri.AbsoluteUri).To;
_toHeader = ToHeader.Create(toUri, dictionaryTo, messageVersion.Addressing);
}
_anyHeadersToAdd = to.Headers.Count > 0;
}
if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
{
_channelEventTraceActivity = EventTraceActivity.GetFromThreadOrCreate();
}
}
protected TransportOutputChannel(ChannelManagerBase channelManager, EndpointAddress to, Uri via, bool manualAddressing, MessageVersion messageVersion)
: base(channelManager)
{
_manualAddressing = manualAddressing;
_messageVersion = messageVersion;
_to = to;
_via = via;
if (!manualAddressing && to != null)
{
Uri toUri;
if (to.IsAnonymous)
{
toUri = _messageVersion.Addressing.AnonymousUri;
}
else if (to.IsNone)
{
toUri = _messageVersion.Addressing.NoneUri;
}
else
{
toUri = to.Uri;
}
if (toUri != null)
{
XmlDictionaryString dictionaryTo = new ToDictionary(toUri.AbsoluteUri).To;
_toHeader = ToHeader.Create(toUri, dictionaryTo, messageVersion.Addressing);
}
_anyHeadersToAdd = to.Headers.Count > 0;
}
if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
{
_channelEventTraceActivity = EventTraceActivity.GetFromThreadOrCreate();
}
}
internal static Summary[] Run(BenchmarkRunInfo[] benchmarkRunInfos)
{
var resolver = DefaultResolver;
var artifactsToCleanup = new List <string>();
var title = GetTitle(benchmarkRunInfos);
var rootArtifactsFolderPath = GetRootArtifactsFolderPath(benchmarkRunInfos);
var resultsFolderPath = GetResultsFolderPath(rootArtifactsFolderPath, benchmarkRunInfos);
var logFilePath = Path.Combine(rootArtifactsFolderPath, title + ".log");
using (var streamLogger = new StreamLogger(new StreamWriter(logFilePath, append: false)))
{
var compositeLogger = CreateCompositeLogger(benchmarkRunInfos, streamLogger);
var supportedBenchmarks = GetSupportedBenchmarks(benchmarkRunInfos, compositeLogger, resolver);
if (!supportedBenchmarks.Any(benchmarks => benchmarks.BenchmarksCases.Any()))
{
return new [] { Summary.NothingToRun(title, resultsFolderPath, logFilePath) }
}
;
var validationErrors = Validate(supportedBenchmarks, compositeLogger);
if (validationErrors.Any(validationError => validationError.IsCritical))
{
return new [] { Summary.ValidationFailed(title, resultsFolderPath, logFilePath, validationErrors) }
}
;
var benchmarksToRunCount = supportedBenchmarks.Sum(benchmarkInfo => benchmarkInfo.BenchmarksCases.Length);
compositeLogger.WriteLineHeader("// ***** BenchmarkRunner: Start *****");
compositeLogger.WriteLineHeader($"// ***** Found {benchmarksToRunCount} benchmark(s) in total *****");
var globalChronometer = Chronometer.Start();
var buildPartitions = BenchmarkPartitioner.CreateForBuild(supportedBenchmarks, resolver);
var buildResults = BuildInParallel(compositeLogger, rootArtifactsFolderPath, buildPartitions, ref globalChronometer);
try
{
var results = new List <Summary>();
var benchmarkToBuildResult = buildResults
.SelectMany(buildResult => buildResult.Key.Benchmarks.Select(buildInfo => (buildInfo.BenchmarkCase, buildInfo.Id, buildResult.Value)))
.ToDictionary(info => info.BenchmarkCase, info => (info.Id, info.Value));
foreach (var benchmarkRunInfo in supportedBenchmarks) // we run them in the old order now using the new build artifacts
{
var runChronometer = Chronometer.Start();
var summary = Run(benchmarkRunInfo, benchmarkToBuildResult, resolver, compositeLogger, artifactsToCleanup, resultsFolderPath, logFilePath, ref runChronometer);
if (!benchmarkRunInfo.Config.Options.IsSet(ConfigOptions.JoinSummary))
{
PrintSummary(compositeLogger, benchmarkRunInfo.Config, summary);
}
benchmarksToRunCount -= benchmarkRunInfo.BenchmarksCases.Length;
compositeLogger.WriteLineHeader($"// ** Remained {benchmarksToRunCount} benchmark(s) to run **");
LogTotalTime(compositeLogger, runChronometer.GetElapsed().GetTimeSpan(), summary.GetNumberOfExecutedBenchmarks(), message: "Run time");
compositeLogger.WriteLine();
results.Add(summary);
if (benchmarkRunInfo.Config.Options.IsSet(ConfigOptions.StopOnFirstError) && summary.Reports.Any(report => !report.Success))
{
break;
}
}
if (supportedBenchmarks.Any(b => b.Config.Options.IsSet(ConfigOptions.JoinSummary)))
{
var joinedSummary = Summary.Join(results, globalChronometer.GetElapsed());
PrintSummary(compositeLogger, supportedBenchmarks.First(b => b.Config.Options.IsSet(ConfigOptions.JoinSummary)).Config, joinedSummary);
results.Clear();
results.Add(joinedSummary);
}
var totalTime = globalChronometer.GetElapsed().GetTimeSpan();
int totalNumberOfExecutedBenchmarks = results.Sum(summary => summary.GetNumberOfExecutedBenchmarks());
LogTotalTime(compositeLogger, totalTime, totalNumberOfExecutedBenchmarks, "Global total time");
return(results.ToArray());
}
finally
{
compositeLogger.WriteLineHeader("// * Artifacts cleanup *");
Cleanup(new HashSet <string>(artifactsToCleanup.Distinct()));
compositeLogger.Flush();
}
}
}
/// <summary>
/// Builds a <see cref="BinaryDeserializer{T}" /> for a <see cref="RecordSchema" />.
/// </summary>
/// <returns>
/// A successful <see cref="BinaryDeserializerBuilderCaseResult" /> if <paramref name="type" />
/// is not an array or primitive type and <paramref name="schema" /> is a <see cref="RecordSchema" />;
/// an unsuccessful <see cref="BinaryDeserializerBuilderCaseResult" /> otherwise.
/// </returns>
/// <inheritdoc />
public virtual BinaryDeserializerBuilderCaseResult BuildExpression(Type type, Schema schema, BinaryDeserializerBuilderContext context)
{
if (schema is RecordSchema recordSchema)
{
var underlying = Nullable.GetUnderlyingType(type) ?? type;
if (!underlying.IsArray && !underlying.IsPrimitive)
{
// since record deserialization is potentially recursive, create a top-level
// reference:
var parameter = Expression.Parameter(
Expression.GetDelegateType(context.Reader.Type.MakeByRefType(), underlying));
if (!context.References.TryGetValue((recordSchema, type), out var reference))
{
context.References.Add((recordSchema, type), reference = parameter);
}
// then build/set the delegate if it hasn’t been built yet:
if (parameter == reference)
{
Expression expression;
if (GetRecordConstructor(underlying, recordSchema) is ConstructorInfo constructor)
{
var parameters = constructor.GetParameters();
// map constructor parameters to fields:
var mapping = recordSchema.Fields
.Select(field =>
{
// there will be a match or we wouldn’t have made it this far:
var match = parameters.Single(parameter => IsMatch(field, parameter.Name));
var parameter = Expression.Parameter(match.ParameterType);
return(
Match: match,
Parameter: parameter,
Assignment: (Expression)Expression.Assign(
parameter,
DeserializerBuilder.BuildExpression(match.ParameterType, field.Type, context)));
})
.ToDictionary(r => r.Match, r => (r.Parameter, r.Assignment));
expression = Expression.Block(
mapping
.Select(d => d.Value.Parameter),
mapping
.Select(d => d.Value.Assignment)
.Concat(new[]
{
Expression.New(
constructor,
parameters
.Select(parameter => mapping.ContainsKey(parameter)
? (Expression)mapping[parameter].Parameter
: Expression.Constant(parameter.DefaultValue))),
}));
}
else
{
var members = underlying.GetMembers(MemberVisibility);
// support dynamic deserialization:
var value = Expression.Parameter(
underlying.IsAssignableFrom(typeof(ExpandoObject))
? typeof(ExpandoObject)
: underlying);
expression = Expression.Block(
new[] { value },
new[] { (Expression)Expression.Assign(value, Expression.New(value.Type)) }
.Concat(recordSchema.Fields.Select(field =>
{
var match = members.SingleOrDefault(member => IsMatch(field, member));
Expression expression;
if (match == null)
{
// always deserialize fields to advance the reader:
expression = DeserializerBuilder.BuildExpression(typeof(object), field.Type, context);
// fall back to a dynamic setter if the value supports it:
if (typeof(IDynamicMetaObjectProvider).IsAssignableFrom(value.Type))
{
var flags = CSharpBinderFlags.None;
var infos = new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) };
var binder = Binder.SetMember(flags, field.Name, value.Type, infos);
expression = Expression.Dynamic(binder, typeof(void), value, expression);
}
}
else
{
Expression inner;
try
{
inner = DeserializerBuilder.BuildExpression(
match switch
{
FieldInfo fieldMatch => fieldMatch.FieldType,
PropertyInfo propertyMatch => propertyMatch.PropertyType,
MemberInfo unknown => throw new InvalidOperationException($"Record fields can only be mapped to fields and properties."),
},
field.Type,
context);
}
catch (Exception exception)
{
throw new UnsupportedTypeException(type, $"The {match.Name} member on {type} could not be mapped to the {field.Name} field on {recordSchema.FullName}.", exception);
}
expression = Expression.Assign(
Expression.PropertyOrField(value, match.Name),
inner);
}
return(expression);
}))
[PublicAPI] public static Summary[] Run(BenchmarkRunInfo[] benchmarkRunInfos, [CanBeNull] IConfig commonSettingsConfig)
{
if (commonSettingsConfig == null)
{
commonSettingsConfig = DefaultConfig.Instance;
}
var resolver = DefaultResolver;
var artifactsToCleanup = new List <string>();
string title = GetTitle(benchmarkRunInfos);
string rootArtifactsFolderPath = (commonSettingsConfig?.ArtifactsPath ?? DefaultConfig.Instance.ArtifactsPath).CreateIfNotExists();
using (var logStreamWriter = StreamWriter.FromPath(Path.Combine(rootArtifactsFolderPath, title + ".log")))
{
var logger = new CompositeLogger(commonSettingsConfig.GetCompositeLogger(), new StreamLogger(logStreamWriter));
var supportedBenchmarks = GetSupportedBenchmarks(benchmarkRunInfos, logger, resolver);
if (!supportedBenchmarks.Any(benchmarks => benchmarks.BenchmarksCases.Any()))
{
return new [] { Summary.CreateFailed(
supportedBenchmarks.SelectMany(b => b.BenchmarksCases).ToArray(),
title, HostEnvironmentInfo.GetCurrent(), commonSettingsConfig, GetResultsFolderPath(rootArtifactsFolderPath), Array.Empty <ValidationError>()) }
}
;
var validationErrors = Validate(supportedBenchmarks, logger);
if (validationErrors.Any(validationError => validationError.IsCritical))
{
return new [] { Summary.CreateFailed(
supportedBenchmarks.SelectMany(b => b.BenchmarksCases).ToArray(),
title, HostEnvironmentInfo.GetCurrent(), commonSettingsConfig, GetResultsFolderPath(rootArtifactsFolderPath), validationErrors) }
}
;
var buildPartitions = BenchmarkPartitioner.CreateForBuild(supportedBenchmarks, resolver);
logger.WriteLineHeader("// ***** BenchmarkRunner: Start *****");
var globalChronometer = Chronometer.Start();
var buildResults = BuildInParallel(logger, rootArtifactsFolderPath, buildPartitions, ref globalChronometer);
try
{
var results = new List <Summary>();
var benchmarkToBuildResult = buildResults
.SelectMany(buildResult => buildResult.Key.Benchmarks.Select(buildInfo => (buildInfo.BenchmarkCase, buildInfo.Id, buildResult.Value)))
.ToDictionary(info => info.BenchmarkCase, info => (info.Id, info.Value));
foreach (var benchmarkRunInfo in supportedBenchmarks) // we run them in the old order now using the new build artifacts
{
var runChronometer = Chronometer.Start();
var summary = Run(benchmarkRunInfo, benchmarkToBuildResult, resolver, logger, artifactsToCleanup, rootArtifactsFolderPath, ref runChronometer);
if (commonSettingsConfig == null || commonSettingsConfig.SummaryPerType)
{
PrintSummary(logger, benchmarkRunInfo.Config, summary);
}
LogTotalTime(logger, runChronometer.GetElapsed().GetTimeSpan(), summary.GetNumberOfExecutedBenchmarks(), message: "Run time");
logger.WriteLine();
results.Add(summary);
}
if (commonSettingsConfig != null && !commonSettingsConfig.SummaryPerType)
{
var joinedSummary = Summary.Join(results, commonSettingsConfig, globalChronometer.GetElapsed());
PrintSummary(logger, commonSettingsConfig, joinedSummary);
results.Clear();
results.Add(joinedSummary);
}
return(results.ToArray());
}
finally
{
logger.WriteLineHeader("// * Artifacts cleanup *");
Cleanup(new HashSet <string>(artifactsToCleanup.Distinct()));
}
}
}
