public void ForLoopRenameIgnoreDeclaredVariables() { var c1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementForLoop(c1, new ValSimple("5", typeof(int))); var a1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var v1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); s1.Add(new StatementAssign(a1, new ValSimple("10", typeof(int)))); s1.Add(new StatementAssign(a1, new ValSimple($"{a1.RawValue}+{v1.RawValue}", typeof(int), new IDeclaredParameter[] { a1, v1 }))); s1.Add(v1); var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s2 = new StatementForLoop(c2, new ValSimple("5", typeof(int))); var a2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var v2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); s2.Add(new StatementAssign(a2, new ValSimple("10", typeof(int)))); s2.Add(new StatementAssign(a2, new ValSimple($"{a2.RawValue}+{v2.RawValue}", typeof(int), new IDeclaredParameter[] { a2, v2 }))); s2.Add(v2); var r = s1.RequiredForEquivalence(s2); // Since only loop variable matters here, we don't care, and we can do the rename. Assert.IsTrue(r.Item1, "Should be equivalent"); var renames = r.Item2.ToArray(); Assert.AreEqual(1, renames.Length, "# of renames"); }
public void TestCombineNestedForLoopOnOneSide() { var base1 = new StatementInlineBlock(); var limit = new LINQToTTreeLib.Variables.ValSimple("5", typeof(int)); var loopP1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop1 = new StatementForLoop(loopP1, limit); base1.Add(loop1); var base2 = new StatementInlineBlock(); var limit2 = new LINQToTTreeLib.Variables.ValSimple("5", typeof(int)); var loopP12 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop12 = new StatementForLoop(loopP12, limit); base2.Add(loop12); var loopP22 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop22 = new StatementForLoop(loopP22, limit); loop12.Add(loop22); var r = base1.TryCombineStatement(base2, new dummyOpt()); Assert.IsTrue(r, "combination should work"); Assert.AreEqual(base1, loop1.Parent, "loop 1 parent"); Assert.AreEqual(loop1, loop22.Parent, "Loop 2 parent"); }
public void ZeroDependentVariables() { var counter = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s = new StatementForLoop(counter, new ValSimple("5", typeof(int))); Assert.AreEqual(0, s.DependentVariables.Count(), "# of dependent variables"); Assert.AreEqual(0, s.ResultVariables.Count(), "# of result variables"); }
public void TestCombineDifInitial(IDeclaredParameter loopVarName, IValue ivalSize, IValue initialValue1, IValue initialValue2) { var p1 = new StatementForLoop(loopVarName, ivalSize, initialValue1); var p2 = new StatementForLoop(loopVarName, ivalSize, initialValue2); var r = p1.TryCombineStatement(p2, new dummyOpt()); Assert.IsFalse(r, "Should always be equal"); }
public void ForLoopLimitDependencies() { var limit = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s = new StatementForLoop(loop, limit); Assert.AreEqual(1, s.DependentVariables.Count()); Assert.AreEqual(limit.RawValue, s.DependentVariables.First()); }
public StatementForLoop TestCTor(IDeclaredParameter loopVarName, IValue ivalSize, IValue initialValue) { var p = new StatementForLoop(loopVarName, ivalSize, initialValue); Assert.AreEqual(typeof(int), ivalSize.Type, "size value"); if (initialValue != null) Assert.AreEqual(typeof(int), initialValue.Type, "inital value type"); Assert.AreEqual(p.ArrayLength.RawValue, ivalSize.RawValue, "Initial value must be set"); return p; }
public void TestLiftSimpleStatement() { var v = new GeneratedCode(); var loopP = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = new StatementForLoop(loopP, new LINQToTTreeLib.Variables.ValSimple("10", typeof(int))); v.Add(loop); v.Add(new StatementWithNoSideEffects()); StatementLifter.Optimize(v); var firstStatement = v.CodeBody.Statements.First(); Assert.IsInstanceOfType(firstStatement, typeof(StatementWithNoSideEffects), "first statement"); }
public void ForLoopEmptyDifferentLimit() { var c1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementForLoop(c1, new ValSimple("5", typeof(int))); var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s2 = new StatementForLoop(c1, new ValSimple("6", typeof(int))); var r = s1.RequiredForEquivalence(s2); // Since only loop variable matters here, we don't care, and we can do the rename. Assert.IsFalse(r.Item1, "Can't be equivalent"); }
public StatementForLoop TestCTor(IDeclaredParameter loopVarName, IValue ivalSize, IValue initialValue) { var p = new StatementForLoop(loopVarName, ivalSize, initialValue); Assert.AreEqual(typeof(int), ivalSize.Type, "size value"); if (initialValue != null) { Assert.AreEqual(typeof(int), initialValue.Type, "inital value type"); } Assert.AreEqual(p.ArrayLength.RawValue, ivalSize.RawValue, "Initial value must be set"); return(p); }
public void ForLoopEmptySameLimit() { var c1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementForLoop(c1, new ValSimple("5", typeof(int))); var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s2 = new StatementForLoop(c1, new ValSimple("5", typeof(int))); var r = s1.RequiredForEquivalence(s2); // Since only loop variable matters here, we don't care, and we can do the rename. Assert.IsTrue(r.Item1, "Are Equivalent"); Assert.AreEqual(0, r.Item2.Count(), "# of renames"); }
public void DeclaredVariablesLocalOnly() { var outter = new StatementInlineBlock(); outter.Add(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int))); var s = new StatementForLoop(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)), new ValSimple("5", typeof(int))); s.Add(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int))); outter.Add(s); Assert.AreEqual(2, s.DeclaredVariables.Count()); Assert.AreEqual(3, s.AllDeclaredVariables.Count()); }
public void TestCombineDifferentInitialValues() { IValue initial1 = new ValSimple("0", typeof(int)); IValue initial2 = new ValSimple("1", typeof(int)); IValue size = new ValSimple("10", typeof(int)); var lv1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var lv2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var p1 = new StatementForLoop(lv1, size, initial1); var p2 = new StatementForLoop(lv2, size, initial2); var r = p1.TryCombineStatement(p2, new dummyOpt()); Assert.IsFalse(r, "different initial conditions, should be null"); }
public void DependentAndResultVariablesWithDecl() { var counter = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s = new StatementForLoop(counter, new ValSimple("5", typeof(int))); var result = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); s.Add(result); var assign = new StatementAssign(result, new ValSimple($"{result.RawValue}+{counter.RawValue}", typeof(int), new IDeclaredParameter[] { counter, result })); s.Add(assign); Assert.AreEqual(0, s.DependentVariables.Count(), "# of dependent variables"); Assert.AreEqual(0, s.ResultVariables.Count(), "# of result variables"); }
public void TestTryCombine([PexAssumeUnderTest] StatementForLoop target, IStatement s) { /// We should never be able to combine any filter statements currently! var val = new Variables.ValSimple("true", typeof(bool)); var result = target.TryCombineStatement(s, null); if (s.GetType() != typeof(StatementForLoop)) { Assert.IsFalse(result, "Types not right"); } else { var other = s as StatementForLoop; Assert.AreEqual(other.ArrayLength == target.ArrayLength, result, "for loops not conssitent"); } }
public void ForLoopGivenRenameInLoopLimit() { var c1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var l1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementForLoop(c1, l1); var a1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var l2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s2 = new StatementForLoop(c2, l2); var r = s1.RequiredForEquivalence(s2, new Tuple <string, string>[] { new Tuple <string, string>(l2.RawValue, l1.RawValue) }); // Since only loop variable matters here, we don't care, and we can do the rename. Assert.IsTrue(r.Item1, "Should be equivalent"); var renames = r.Item2.ToArray(); Assert.AreEqual(0, renames.Length, "# of renames"); }
public void TestLiftSimpleStatementInFunction() { var v = new StatementInlineBlock(); var loopP = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = new StatementForLoop(loopP, new LINQToTTreeLib.Variables.ValSimple("10", typeof(int))); v.Add(loop); loop.Add(new StatementWithNoSideEffects()); var f = QMFunctions.QMFuncUtils.GenerateFunction(); f.SetCodeBody(v); var gc = new GeneratedCode(); gc.Add(new StatementSimpleStatement("int i = 10;")); gc.Add(f); StatementLifter.Optimize(gc); Assert.AreEqual(1, gc.Functions.Count(), "# of functions after lifting"); var firstStatement = gc.Functions.First().StatementBlock.Statements.First(); Assert.IsInstanceOfType(firstStatement, typeof(StatementWithNoSideEffects), "first statement"); }
public IStatement TestRename([PexAssumeUnderTest] StatementForLoop statement, [PexAssumeNotNull] string oldname, [PexAssumeNotNull] string newname) { var origianllines = statement.CodeItUp().ToArray(); statement.RenameVariable(oldname, newname); var finallines = statement.CodeItUp().ToArray(); Assert.AreEqual(origianllines.Length, finallines.Length, "# of lines change during variable rename"); var varReplacer = new Regex(string.Format(@"\b{0}\b", oldname)); var sharedlines = origianllines.Zip(finallines, (o, n) => Tuple.Create(o, n)); foreach (var pair in sharedlines) { var orig = pair.Item1; var origReplafce = varReplacer.Replace(orig, newname); Assert.AreEqual(origReplafce, pair.Item2, "expected the renaming to be pretty simple."); } return(statement); }
public void ForLoopGivenRenameRequestStatements() { var c1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementForLoop(c1, new ValSimple("5", typeof(int))); var a1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); s1.Add(new StatementAssign(a1, new ValSimple("10", typeof(int)))); var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s2 = new StatementForLoop(c2, new ValSimple("5", typeof(int))); var a2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); s2.Add(new StatementAssign(a2, new ValSimple("10", typeof(int)))); var r = s1.RequiredForEquivalence(s2, new Tuple <string, string>[] { new Tuple <string, string>(a2.RawValue, a1.RawValue) }); // Since only loop variable matters here, we don't care, and we can do the rename. Assert.IsTrue(r.Item1, "Should be equivalent"); var renames = r.Item2.ToArray(); Assert.AreEqual(0, renames.Length, "# of renames"); }
public void ForLoopRenameTwiceAsSource() { var c1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementForLoop(c1, new ValSimple("5", typeof(int))); var a1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var v1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); s1.Add(new StatementAssign(a1, new ValSimple("10", typeof(int)))); s1.Add(new StatementAssign(a1, new ValSimple($"{a1.RawValue}+{a1.RawValue}", typeof(int), new IDeclaredParameter[] { a1 }))); var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s2 = new StatementForLoop(c1, new ValSimple("6", typeof(int))); var a2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var v2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); s2.Add(new StatementAssign(a2, new ValSimple("10", typeof(int)))); s2.Add(new StatementAssign(a2, new ValSimple($"{a2.RawValue}+{v2.RawValue}", typeof(int), new IDeclaredParameter[] { a2, v2 }))); var r = s1.RequiredForEquivalence(s2); // Since only loop variable matters here, we don't care, and we can do the rename. Assert.IsFalse(r.Item1, "Should be equivalent"); }
public void ForLoopGivenRenameInLoopLimit() { var c1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var l1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementForLoop(c1, l1); var a1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var l2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s2 = new StatementForLoop(c2, l2); var r = s1.RequiredForEquivalence(s2, new Tuple<string, string>[] { new Tuple<string, string>(l2.RawValue, l1.RawValue) }); // Since only loop variable matters here, we don't care, and we can do the rename. Assert.IsTrue(r.Item1, "Should be equivalent"); var renames = r.Item2.ToArray(); Assert.AreEqual(0, renames.Length, "# of renames"); }
public void ForLoopGivenRenameRequestStatements() { var c1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementForLoop(c1, new ValSimple("5", typeof(int))); var a1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); s1.Add(new StatementAssign(a1, new ValSimple("10", typeof(int)))); var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s2 = new StatementForLoop(c2, new ValSimple("5", typeof(int))); var a2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); s2.Add(new StatementAssign(a2, new ValSimple("10", typeof(int)))); var r = s1.RequiredForEquivalence(s2, new Tuple<string, string>[] { new Tuple<string, string>(a2.RawValue, a1.RawValue) }); // Since only loop variable matters here, we don't care, and we can do the rename. Assert.IsTrue(r.Item1, "Should be equivalent"); var renames = r.Item2.ToArray(); Assert.AreEqual(0, renames.Length, "# of renames"); }
public void ForLoopDifferentNumberOfStatements() { var c1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementForLoop(c1, new ValSimple("5", typeof(int))); var a1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); s1.Add(new StatementAssign(a1, new ValSimple("10", typeof(int)))); var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s2 = new StatementForLoop(c1, new ValSimple("6", typeof(int))); var r = s1.RequiredForEquivalence(s2); // Since only loop variable matters here, we don't care, and we can do the rename. Assert.IsFalse(r.Item1, "Can't be equivalent"); }
public void LiftLoopInvarient() { var v = new GeneratedCode(); var limit = new LINQToTTreeLib.Variables.ValSimple("5", typeof(int)); var loopP1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop1 = new StatementForLoop(loopP1, limit); v.Add(loop1); var p2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var assign1 = new StatementAssign(p2, new ValSimple("f", typeof(int))); loop1.Add(p2); loop1.Add(assign1); Console.WriteLine("Unoptimized:"); v.DumpCodeToConsole(); StatementLifter.Optimize(v); Console.WriteLine(""); Console.WriteLine("Optimized:"); v.DumpCodeToConsole(); Assert.AreEqual(0, loop1.Statements.Count()); }
public void DontLiftThroughTwoForStatements() { var gc = new GeneratedCode(); var counter = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); counter.InitialValue = new ValSimple("0", typeof(int)); gc.Add(counter); // The two for loops var fc1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var for1 = new StatementForLoop(fc1, new ValSimple("5", typeof(int))); gc.Add(for1); var innerCounter = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); innerCounter.InitialValue = new ValSimple("0", typeof(int)); gc.Add(innerCounter); var fc2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var for2 = new StatementForLoop(fc2, new ValSimple("5", typeof(int))); gc.Add(for2); // Now, calculation based only on fc1 var a1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var ass1 = new StatementAssign(a1, new ValSimple($"{fc1}*2", typeof(int), new IDeclaredParameter[] { fc1 })); gc.Add(ass1); var agg1 = new StatementAggregate(innerCounter, new ValSimple($"{innerCounter.RawValue}+{a1.RawValue}", typeof(int), new IDeclaredParameter[] { innerCounter, a1 })); gc.Add(agg1); // and the outer sum. gc.Pop(); var agg2 = new StatementAggregate(counter, new ValSimple($"{counter.RawValue}+{innerCounter.RawValue}", typeof(int), new IDeclaredParameter[] { counter, innerCounter })); gc.Add(agg2); // Great! Console.WriteLine("Unoptimized"); gc.DumpCodeToConsole(); Console.WriteLine(""); Console.WriteLine(""); Console.WriteLine(""); StatementLifter.Optimize(gc); Console.WriteLine("Optimized"); Console.WriteLine(""); gc.DumpCodeToConsole(); // Make sure the inner aggregate got lifted out properly. Assert.AreEqual(1, for2.Statements.Count(), "# of statements in the inner for loop"); }
public void LiftNoSideEffectFromNestedIdenticalLoops() { var v = new GeneratedCode(); var limit = new LINQToTTreeLib.Variables.ValSimple("10", typeof(int)); var loopP1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop1 = new StatementForLoop(loopP1, limit); v.Add(loop1); var loopP2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop2 = new StatementForLoop(loopP2, limit); v.Add(loop2); v.Add(new StatementWithNoSideEffects()); Console.WriteLine("Unoptimized:"); v.DumpCodeToConsole(); StatementLifter.Optimize(v); Console.WriteLine(""); Console.WriteLine("Optimized:"); v.DumpCodeToConsole(); // Check to see if it got lifted. Assert.AreEqual(1, v.CodeBody.Statements.WhereCast<IStatement, StatementWithNoSideEffects>().Count(), "#of no side effect statements"); }
/// <summary> /// Add a simple loop to the current scope. It will have one statement in it, declared at the outer level. /// </summary> /// <param name="gc"></param> public static IDeclaredParameter AddLoop(GeneratedCode gc, bool addDependentStatement = false, IDeclaredParameter useCounter = null, MainStatementType mainStatementType = MainStatementType.IsCounter, bool defineCounterInsideBlock = false) { if (mainStatementType != MainStatementType.IsCounter && useCounter != null) { throw new ArgumentException("Can't do a counter when main statement type doesn't use a counter"); } // Add a counter that gets... counted. var counter = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); if (!defineCounterInsideBlock) { gc.Add(counter); } // And an extra variable that is defined outside the loop var counterExtra = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); if (addDependentStatement) { gc.Add(counterExtra); } // Now do the loop. var loopVar = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = new StatementForLoop(loopVar, new ValSimple("5", typeof(int))); gc.Add(loop); if (defineCounterInsideBlock) { gc.Add(counter); } // Now add statements to the loop if (mainStatementType == MainStatementType.IsCounter) { if (useCounter == null) { gc.Add(new StatementAssign(counter, new ValSimple($"{counter.RawValue} + 1", typeof(int), new IDeclaredParameter[] { counter }))); } else { gc.Add(new StatementAssign(counter, new ValSimple($"{counter.RawValue}+{useCounter.RawValue}", typeof(int), new IDeclaredParameter[] { counter, useCounter }))); } } else { gc.Add(new StatementAssign(counter, new ValSimple("1", typeof(int)))); } if (addDependentStatement) { gc.Add(new StatementAssign(counterExtra, new ValSimple($"{counterExtra.RawValue}+{counter.RawValue}", typeof(int), new IDeclaredParameter[] { counterExtra, counter }))); } return counter; }
public void TestLoopBelowSortedLoopBlockSideEffectsNotImportant() { var v = new GeneratedCode(); v.Add(new StatementNonOptimizing()); var dict = DeclarableParameter.CreateDeclarableParameterMapExpression(typeof(int), typeof(int[])); v.Add(new StatementLoopOverSortedPairValue(dict, true)); var loopP = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = new StatementForLoop(loopP, new LINQToTTreeLib.Variables.ValSimple("10", typeof(int))); v.Add(loop); var lnp = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); v.Add(new StatementWithSideEffects(lnp)); StatementLifter.Optimize(v); var firstStatement = v.CodeBody.Statements.First(); Assert.IsInstanceOfType(firstStatement, typeof(StatementNonOptimizing), "first statement"); var secondStatement = v.CodeBody.Statements.Skip(1).First(); Assert.IsInstanceOfType(secondStatement, typeof(StatementLoopOverSortedPairValue), "Second statement"); }
public IEnumerable <string> CodeItUp([PexAssumeUnderTest] StatementForLoop target) { IEnumerable <string> result = target.CodeItUp(); return(result); }
public void IdenticalFiltersWithNestedIfAndElsesNested() { var gc = new GeneratedCode(); var test = DeclarableParameter.CreateDeclarableParameterExpression("mt", typeof(bool)); AddConditionalExpr(gc, doElseClause: false, ifStatementTest: test); AddLocalInteriorIfAndElse(gc, gc.CodeBody.Statements.Take(1).Cast<StatementFilter>().First()); var loopP = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = new StatementForLoop(loopP, new LINQToTTreeLib.Variables.ValSimple("10", typeof(int))); gc.Add(loop); //var test2 = DeclarableParameter.CreateDeclarableParameterExpression("test2", typeof(bool)); //var hiderif = new StatementFilter(test2); //gc.Add(hiderif); AddConditionalExpr(gc, doElseClause: false, ifStatementTest: test); AddLocalInteriorIfAndElse(gc, loop.Statements.Take(1).Cast<StatementFilter>().First()); DoOptimizeTest(gc); Assert.AreEqual(2, gc.CodeBody.DeclaredVariables.Count()); Assert.AreEqual(2, gc.CodeBody.Statements.Count()); Assert.AreEqual(0, loop.Statements.Count()); }
public void TestLoopBelowNonLoopBlockNoSideEffects() { var v = new GeneratedCode(); v.Add(new StatementNonOptimizing()); v.Add(new StatementInlineBlock()); var loopP = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = new StatementForLoop(loopP, new LINQToTTreeLib.Variables.ValSimple("10", typeof(int))); v.Add(loop); v.Add(new StatementWithNoSideEffects()); DoOptimizeTest(v); var firstStatement = v.CodeBody.Statements.First(); Assert.IsInstanceOfType(firstStatement, typeof(StatementNonOptimizing), "first statement"); var secondStatement = v.CodeBody.Statements.Skip(1).First(); Assert.IsInstanceOfType(secondStatement, typeof(StatementWithNoSideEffects), "Second statement"); }
public void TestLiftTwoStatements() { var v = new GeneratedCode(); var loopP = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = new StatementForLoop(loopP, new LINQToTTreeLib.Variables.ValSimple("10", typeof(int))); v.Add(loop); v.Add(new StatementWithSideEffects(loopP)); v.Add(new StatementWithNoSideEffects()); v.Add(new StatementWithNoSideEffects()); Console.WriteLine("Before optimization"); v.DumpCodeToConsole(); StatementLifter.Optimize(v); Console.WriteLine("After optimization"); v.DumpCodeToConsole(); var firstStatement = v.CodeBody.Statements.First(); Assert.IsInstanceOfType(firstStatement, typeof(StatementWithNoSideEffects), "first statement"); var thirdstatement = v.CodeBody.Statements.Skip(1).First(); Assert.IsInstanceOfType(thirdstatement, typeof(StatementForLoop), "third statement"); }
public void TestCombineNestedForLoop() { var limit = new LINQToTTreeLib.Variables.ValSimple("5", typeof(int)); var loopP1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop1 = new StatementForLoop(loopP1, limit); var loopP2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop2 = new StatementForLoop(loopP2, limit); loop1.Add(loop2); var limit2 = new LINQToTTreeLib.Variables.ValSimple("5", typeof(int)); var loopP12 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop12 = new StatementForLoop(loopP12, limit); var loopP22 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop22 = new StatementForLoop(loopP22, limit); loop12.Add(loop22); var r = loop1.TryCombineStatement(loop12, new dummyOpt()); Assert.IsTrue(r, "combination should work"); Assert.IsNull(loop1.Parent, "loop 1 parent"); Assert.AreEqual(loop1, loop2.Parent, "Loop 2 parent"); }
public void TestLiftTwoDependentStatements() { var v = new GeneratedCode(); var loopP = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = new StatementForLoop(loopP, new LINQToTTreeLib.Variables.ValSimple("10", typeof(int))); v.Add(loop); var var1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var var2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); v.Add(new StatementWithSideEffects(var1, var2)); v.Add(new StatementWithSideEffects(var2)); StatementLifter.Optimize(v); var firstStatement = v.CodeBody.Statements.First(); Assert.IsInstanceOfType(firstStatement, typeof(StatementWithSideEffects), "first statement"); var secondStatement = v.CodeBody.Statements.Skip(1).First(); Assert.IsInstanceOfType(firstStatement, typeof(StatementWithSideEffects), "second statement"); var thirdstatement = v.CodeBody.Statements.Skip(2).First(); Assert.IsInstanceOfType(thirdstatement, typeof(StatementForLoop), "third statement"); }