private static PipelineTransactionResult CommitTransaction(IEnumerable <DeferredTransactionPart> res)
{
var stagesToInvalidate = res.OrderBy(p => p.Timestamp).Where(p => p.Action()).Select(p => p.Stage).ToList();
PipelineCore.Invalidate(stagesToInvalidate);
return(PipelineTransactionResult.Success);
}
/// <summary>
/// Complete the update, invalidating all updated stages as an atomic operation.
/// </summary>
/// <returns><see cref="PipelineTransactionResult.Success"/></returns>
public PipelineTransactionResult Commit()
{
var stagesToInvalidate = PendingStages.Values.OrderBy(part => part.Timestamp).Where(part => part.Action()).Select(part => part.Stage).ToList();
PipelineCore.Invalidate(stagesToInvalidate);
PendingStages.Clear();
return(PipelineTransactionResult.Success);
}
public void InvalidationsArePropagated()
{
var sut = new ThreadSafePipelineStage <int>(1.AsPipelineConstant());
var test = sut.AttachTestStage();
PipelineCore.Invalidate(sut);
test.AssertInvalidations(1);
}
public void AllDependenciesAreInvalidatedAtInformationExtractionTime()
{
var a = 1.AsPipelineConstant().AttachTestStage();
var b = 2.AsPipelineConstant().AttachTestStage();
var sut = new PipelinePropagationInformationStage <string>("", inv => "Hello, World!", "", a, b);
var test = sut.AttachTestStage();
PipelineCore.Invalidate(a, b);
test.AssertStageInvalidated(a);
test.AssertStageInvalidated(b);
}
public void StageIsNotInvalidatedWhenAtLeastOneMutuallyExclusiveStageIsInvalidated(int totalExclusiveStages, int invalidations)
{
var previous = 10.AsPipelineConstant();
var exclusive = Enumerable.Range(0, totalExclusiveStages).Select(i => i.AsPipelineConstant()).ToArray();
var sut = new MutuallyExclusivePipelineStage <int>(previous, exclusive);
var test = sut.AttachTestStage();
PipelineCore.Invalidate(new[] { previous }.Concat(exclusive.Take(invalidations)));
test.AssertInvalidations(0);
PipelineCore.Invalidate(new[] { sut }.Concat(exclusive.Take(invalidations)));
test.AssertInvalidations(0);
}
public void NewValueAndChangedStageAtTheSameTimeHasTheIntendedReaction(PipelineSuspensionState initial, PipelineSuspensionState state, int invalidations)
{
var stateStage = Suspender(initial);
var value = new AssignablePipelineStage <int>("", 1);
var sut = new SuspendingPipelineStage <int>(value, stateStage);
var test = sut.AttachTestStage();
value.SetValueWithoutInvalidating(2);
stateStage.SetValueWithoutInvalidating(state);
PipelineCore.Invalidate(stateStage, value);
test.AssertInvalidations(invalidations);
PipelineAssert.Value(sut, 2);
}
public void SmallPipelineTest1()
{
var value1 = Assignable(1);
var value2 = Assignable(2);
var multiply = PipelineOperations.Create("", (a, b) => a * b, value1, value2).AttachTestStage();
var cache = multiply.WithCache().AttachTestStage();
var equality = cache.WithEqualityCheck().AttachTestStage();
multiply.AssertNotInvalidatedNorRetrieved();
cache.AssertNotInvalidatedNorRetrieved();
equality.AssertNotInvalidatedNorRetrieved();
var value = equality.GetValue();
multiply.AssertInvalidationsAndRetrievals(0, 1);
cache.AssertInvalidationsAndRetrievals(0, 1);
equality.AssertInvalidationsAndRetrievals(0, 1);
PipelineAssert.Value(multiply, 2);
PipelineAssert.Value(cache, 2);
PipelineAssert.Value(equality, 2);
multiply.AssertInvalidationsAndRetrievals(0, 2);
cache.AssertInvalidationsAndRetrievals(0, 3);
equality.AssertInvalidationsAndRetrievals(0, 2);
value1.SetValue(3);
multiply.AssertInvalidationsAndRetrievals(1, 3);
cache.AssertInvalidationsAndRetrievals(1, 4);
equality.AssertInvalidationsAndRetrievals(1, 2);
PipelineAssert.Value(equality, 6);
value1.SetValueWithoutInvalidating(6);
value2.SetValueWithoutInvalidating(1);
PipelineCore.Invalidate(value1, value2);
multiply.AssertInvalidationsAndRetrievals(2, 4);
cache.AssertInvalidationsAndRetrievals(2, 6);
equality.AssertInvalidationsAndRetrievals(1, 3);
PipelineAssert.Value(equality, 6);
GC.KeepAlive(equality);
}
public void GraphContainsNoDuplicatesWhenMultipleStagesAreSpecifiedAsContained()
{
var a = 1.AsPipelineConstant();
var b = 1.AsPipelineConstant();
var c = PipelineOperations.Create("", (x, y) => x + y, a, b);
var test = c.AttachTestStage();
var graph = PipelineCore.GetPipelineGraphIncludingStages(new[] { a, b });
Assert.AreEqual(4, graph.TopologySortedNodes.Count());
AssertNodeDependents(graph, a, c);
AssertNodeDependents(graph, b, c);
AssertNodeDependents(graph, c, test);
AssertNodeDependents(graph, test);
}
public void OnlyMinimalGraphIsRetrieved()
{
var a = 1.AsPipelineConstant();
var b = 1.AsPipelineConstant();
var c = PipelineOperations.Create("", (x, y) => x + y, a, b);
var test = c.AttachTestStage();
var graph = PipelineCore.GetPipelineGraphIncludingStages(new[] { b });
Assert.AreEqual(3, graph.TopologySortedNodes.Count());
AssertTopologyPosition(graph, 0, b);
AssertTopologyPosition(graph, 1, c);
AssertTopologyPosition(graph, 2, test);
AssertNodeDependents(graph, b, c);
AssertNodeDependents(graph, c, test);
}
