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 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 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 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 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 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 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 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 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 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 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 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 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 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 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");
}
