public void ForReverse()
{
var blocks = GenBlocks(@"
var a, b, x, c, d;
for x = 1, 2
{
a = b;
b = c;
c = d;
d = 5;
}
");
var cfg = new ControlFlowGraph(blocks);
var InOut = new ConstantPropagation().ExecuteNonGeneric(cfg);
var actual = InOut.OUT[blocks.Last()];
Assert.AreEqual(LatticeTypeData.CONST, actual["a"].Type);
Assert.AreEqual(LatticeTypeData.CONST, actual["b"].Type);
Assert.AreEqual(LatticeTypeData.CONST, actual["c"].Type);
Assert.AreEqual(LatticeTypeData.CONST, actual["d"].Type);
Assert.AreEqual("5", actual["a"].ConstValue);
Assert.AreEqual("5", actual["b"].ConstValue);
Assert.AreEqual("5", actual["c"].ConstValue);
Assert.AreEqual("5", actual["d"].ConstValue);
}
public void TransfNotDistr()
{
var blocks = GenBlocks(@"
var a, b, c;
if c > 5
{
a = 2;
b = 3;
}
else
{
a = 3;
b = 2;
}
c = a + b;
");
Assert.AreEqual(4, blocks.Count);
var cfg = new ControlFlowGraph(blocks);
var InOut = new ConstantPropagation().ExecuteNonGeneric(cfg);
var actual = InOut.OUT[blocks.Last()];
Assert.AreEqual(LatticeTypeData.NAC, actual["a"].Type);
Assert.AreEqual(LatticeTypeData.NAC, actual["b"].Type);
Assert.AreEqual(LatticeTypeData.NAC, actual["c"].Type);
}
public void InputAssignsNAC()
{
var blocks = GenBlocks(@"
var a, x, c;
input(c);
");
var cfg = new ControlFlowGraph(blocks);
var InOut = new ConstantPropagation().ExecuteNonGeneric(cfg);
Assert.AreEqual(LatticeTypeData.NAC, InOut.OUT[blocks.Last()]["c"].Type);
}
public void OneAssign()
{
var blocks = GenBlocks(@"
var a,b,c;
a = 5;
");
var cfg = new ControlFlowGraph(blocks);
var InOut = new ConstantPropagation().ExecuteNonGeneric(cfg);
var actual = InOut.OUT[blocks.Last()];
Assert.AreEqual(LatticeTypeData.CONST, actual["a"].Type);
Assert.AreEqual("5", actual["a"].ConstValue);
}
public void NoBlocks()
{
var blocks = GenBlocks(@"
var a, b, c;
");
Assert.AreEqual(0, blocks.Count);
var cfg = new ControlFlowGraph(blocks);
var InOut = new ConstantPropagation().ExecuteNonGeneric(cfg);
Assert.AreEqual(2, InOut.IN.Count);
Assert.AreEqual(2, InOut.OUT.Count);
}
public void ConstantPropagationTest()
{
var root = Parser.ParseString(Samples.SampleProgramText.constantPropagationSample);
var code = ProgramTreeToLinear.Build(root);
var blocks = LinearToBaseBlock.Build(code);
ConstantPropagation constProp = new ConstantPropagation();
Console.WriteLine(blocks[0]);
var resBlock = constProp.OptimizeBlock(blocks[0] as BaseBlock);
string res = resBlock.ToString();
Console.WriteLine(res);
}
public void VariableAndConst()
{
var blocks = GenBlocks(@"
var u, p, v;
u = 3;
p = u + 2;
");
var cfg = new ControlFlowGraph(blocks);
var InOut = new ConstantPropagation().ExecuteNonGeneric(cfg);
var actual = InOut.OUT[blocks.Last()];
Assert.AreEqual(LatticeTypeData.CONST, actual["u"].Type);
Assert.AreEqual(LatticeTypeData.CONST, actual["p"].Type);
Assert.AreEqual("3", actual["u"].ConstValue);
Assert.AreEqual("5", actual["p"].ConstValue);
}
public void ForProp()
{
var blocks = GenBlocks(@"
var a, b, x, c;
for x = 1, 10
{
a = 2;
b = 2;
}
c = a + b;
");
var cfg = new ControlFlowGraph(blocks);
var InOut = new ConstantPropagation().ExecuteNonGeneric(cfg);
var actual = InOut.OUT[blocks.Last()];
Assert.AreEqual(LatticeTypeData.CONST, actual["c"].Type);
Assert.AreEqual("4", actual["c"].ConstValue);
}
public void VariableAndConst3()
{
var blocks = GenBlocks(@"
var a, b, c;
b = 3;
goto 11;
c = b + 2;
11: a = 7;
");
var cfg = new ControlFlowGraph(blocks);
var InOut = new ConstantPropagation().ExecuteNonGeneric(cfg);
var actual = InOut.OUT[blocks.Last()];
Assert.AreEqual(LatticeTypeData.CONST, actual["b"].Type);
Assert.AreEqual(LatticeTypeData.CONST, actual["a"].Type);
Assert.AreEqual("3", actual["b"].ConstValue);
Assert.AreEqual("7", actual["a"].ConstValue);
}
private List <IOptimization> BlockOptimizationList()
{
var optimizations = new List <IOptimization>();
if (OptimizationList[Optimizations.Alg])
{
var algOptimization = new AlgebraicOptimization();
optimizations.Add(algOptimization);
}
if (OptimizationList[Optimizations.Decl])
{
var declOptimization = new DeclarationOptimization();
optimizations.Add(declOptimization);
}
if (OptimizationList[Optimizations.CopyProp])
{
var copyPropOptimization = new CopyPropagation();
optimizations.Add(copyPropOptimization);
}
if (OptimizationList[Optimizations.ConstFold])
{
var constFoldingOptimization = new ConstantFolding();
optimizations.Add(constFoldingOptimization);
}
if (OptimizationList[Optimizations.ConstProp])
{
var constPropOptimization = new ConstantPropagation();
optimizations.Add(constPropOptimization);
}
if (OptimizationList[Optimizations.Subexpr])
{
var subexpOptimization = new SubexpressionOptimization();
optimizations.Add(subexpOptimization);
}
return(optimizations);
}
public void ComplicatedEquation()
{
var blocks = GenBlocks(@"
var a, b, c;
a = 2;
b = 3;
c = a * b - 2;
");
var cfg = new ControlFlowGraph(blocks);
var InOut = new ConstantPropagation().ExecuteNonGeneric(cfg);
var actual = InOut.OUT[blocks.Last()];
Assert.AreEqual(LatticeTypeData.CONST, actual["a"].Type);
Assert.AreEqual(LatticeTypeData.CONST, actual["b"].Type);
Assert.AreEqual(LatticeTypeData.CONST, actual["c"].Type);
Assert.AreEqual("2", actual["a"].ConstValue);
Assert.AreEqual("3", actual["b"].ConstValue);
Assert.AreEqual("4", actual["c"].ConstValue);
}
public void PropagateTwoVariants2()
{
var blocks = GenBlocks(@"
var a, x, c;
x = 10;
a = 20;
goto 666;
666: c = a + x;
");
var cfg = new ControlFlowGraph(blocks);
var InOut = new ConstantPropagation().ExecuteNonGeneric(cfg);
var actual = InOut.OUT[blocks.Last()];
Assert.AreEqual(LatticeTypeData.CONST, actual["a"].Type);
Assert.AreEqual(LatticeTypeData.CONST, actual["x"].Type);
Assert.AreEqual(LatticeTypeData.CONST, actual["c"].Type);
Assert.AreEqual("20", actual["a"].ConstValue);
Assert.AreEqual("30", actual["c"].ConstValue);
Assert.AreEqual("10", actual["x"].ConstValue);
}
public void TwoConstValues()
{
var blocks = GenBlocks(@"
var a, x, c;
input(c);
if c > 5
x = 10;
else
input(c);
if c > 5
x = 20;
a = x;
");
var cfg = new ControlFlowGraph(blocks);
var InOut = new ConstantPropagation().ExecuteNonGeneric(cfg);
var actual = InOut.OUT[blocks.Last()];
Assert.AreEqual(LatticeTypeData.NAC, actual["a"].Type);
Assert.AreEqual(LatticeTypeData.NAC, actual["x"].Type);
Assert.AreEqual(LatticeTypeData.NAC, actual["c"].Type);
}
public void ConstPropagation()
{
var program = @"
var a, x, c;
input(c);
if c > 5
x = 10;
else
input(c);
if c > 5
x = 20;
a = x;
";
var graph = GenCFG(program);
var algorithm = new ConstantPropagation();
_ = algorithm.Execute(graph);
var iterationsFast = algorithm.Iterations;
_ = algorithm.Execute(graph, false);
var iterationsSlow = algorithm.Iterations;
Assert.LessOrEqual(iterationsFast, iterationsSlow);
}
public void ConstPropagationIterative()
{
var cfg = GenCFG(@"
var a, x, c;
if c > 5
x = 10;
else
input(c);
if c > 5
a = x;
");
var constProp = new ConstantPropagation();
var result = constProp.Execute(cfg);
var blocks = cfg.GetCurrentBasicBlocks();
var(_, Out) = result[blocks.Last()];
Assert.AreEqual(LatticeTypeData.NAC, Out["c"].Type);
Assert.AreEqual(LatticeTypeData.CONST, Out["x"].Type);
Assert.AreEqual(LatticeTypeData.CONST, Out["a"].Type);
Assert.AreEqual("10", Out["x"].ConstValue);
Assert.AreEqual("10", Out["a"].ConstValue);
}
