C# (CSharp) ConstPropagation примеры использования

Пример #1

        public void ForReverse()
        {
            var program = @"
var a, b, x, c, d;
for x=1,2
{
    a = b;
    b = c;
    c = d;
    d = 5;
}
";
            var blocks  = GenBlocks(program);
            var cfg     = new ControlFlowGraph(blocks);
            var InOut   = new ConstPropagation().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);
        }

Пример #2

        public void TransfNotDistr()
        {
            var TAC    = GenTAC(@"
var a,b,c;
if c > 5
{
    a = 2;
    b = 3;
}
else
{
    a = 3;
    b = 2;
}
c = a + b;
");
            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);

            Assert.AreEqual(4, blocks.Count);
            var cfg   = new ControlFlowGraph(blocks);
            var InOut = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(InOut.OUT[blocks[3]]["a"].Type, LatticeTypeData.NAC);
            Assert.AreEqual(InOut.OUT[blocks[3]]["b"].Type, LatticeTypeData.NAC);
            Assert.AreEqual(InOut.OUT[blocks[3]]["c"].Type, LatticeTypeData.NAC);
        }

Пример #3

        public void ForReverse()
        {
            var TAC    = GenTAC(@"
var a, b, x, c, d;
for x=1,2
{
    a = b;
    b = c;
    c = d;
    d = 5;
}
");
            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);
            var cfg    = new ControlFlowGraph(blocks);
            var InOut  = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(LatticeTypeData.CONST, InOut.OUT[blocks[3]]["a"].Type);
            Assert.AreEqual(LatticeTypeData.CONST, InOut.OUT[blocks[3]]["b"].Type);
            Assert.AreEqual(LatticeTypeData.CONST, InOut.OUT[blocks[3]]["c"].Type);
            Assert.AreEqual(LatticeTypeData.CONST, InOut.OUT[blocks[3]]["d"].Type);

            Assert.AreEqual("5", InOut.OUT[blocks[3]]["a"].ConstValue);
            Assert.AreEqual("5", InOut.OUT[blocks[3]]["b"].ConstValue);
            Assert.AreEqual("5", InOut.OUT[blocks[3]]["c"].ConstValue);
            Assert.AreEqual("5", InOut.OUT[blocks[3]]["d"].ConstValue);
        }

Пример #4

        public void TransfNotDistr()
        {
            var program = @"
var a,b,c;
if c > 5
{
    a = 2;
    b = 3;
}
else
{
    a = 3;
    b = 2;
}
c = a + b;
";
            var blocks  = GenBlocks(program);

            Assert.AreEqual(4, blocks.Count);
            var cfg    = new ControlFlowGraph(blocks);
            var InOut  = new ConstPropagation().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);
        }

Пример #5

        public void InputAssignsNAC()
        {
            var program = @"
var a, x, c;
input(c);
";
            var blocks  = GenBlocks(program);
            var cfg     = new ControlFlowGraph(blocks);
            var InOut   = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(LatticeTypeData.NAC, InOut.OUT[blocks.Last()]["c"].Type);
        }

Пример #6

        public void InputAssignsNAC()
        {
            var TAC    = GenTAC(@"
var a, x, c;
input(c);
");
            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);
            var cfg    = new ControlFlowGraph(blocks);
            var InOut  = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(LatticeTypeData.NAC, InOut.OUT[blocks[0]]["c"].Type);
        }

Пример #7

        public void OneAssign()
        {
            var TAC    = GenTAC(@"
var a,b,c;
a = 5;
");
            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);
            var cfg    = new ControlFlowGraph(blocks);
            var InOut  = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(InOut.OUT[blocks[0]]["a"].Type, LatticeTypeData.CONST);
            Assert.AreEqual("5", InOut.OUT[blocks[0]]["a"].ConstValue);
        }

Пример #8

        public void TestNoBlocks()
        {
            var program = @"
var a,b,c;
";
            var blocks  = GenBlocks(program);

            Assert.AreEqual(0, blocks.Count);
            var cfg   = new ControlFlowGraph(blocks);
            var InOut = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(2, InOut.IN.Count);
            Assert.AreEqual(2, InOut.OUT.Count);
        }

Пример #9

        public void OneAssign()
        {
            var program = @"
var a,b,c;
a = 5;
";
            var blocks  = GenBlocks(program);
            var cfg     = new ControlFlowGraph(blocks);
            var InOut   = new ConstPropagation().ExecuteNonGeneric(cfg);
            var actual  = InOut.OUT[blocks.Last()];

            Assert.AreEqual(LatticeTypeData.CONST, actual["a"].Type);
            Assert.AreEqual("5", actual["a"].ConstValue);
        }

Пример #10

        public void TestNoBlocks()
        {
            var TAC    = GenTAC(@"
var a,b,c;
");
            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);

            Assert.AreEqual(0, blocks.Count);
            var cfg   = new ControlFlowGraph(blocks);
            var InOut = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(2, InOut.IN.Count);
            Assert.AreEqual(2, InOut.OUT.Count);
        }

Пример #11

        public void VariableAndConst()
        {
            var TAC    = GenTAC(@"
var u,p,v;
u = 3;
p = u + 2;
");
            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);
            var cfg    = new ControlFlowGraph(blocks);
            var InOut  = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(InOut.OUT[blocks[0]]["u"].Type, LatticeTypeData.CONST);
            Assert.AreEqual(InOut.OUT[blocks[0]]["p"].Type, LatticeTypeData.CONST);

            Assert.AreEqual("3", InOut.OUT[blocks[0]]["u"].ConstValue);
            Assert.AreEqual("5", InOut.OUT[blocks[0]]["p"].ConstValue);
        }

Пример #12

        public void PropagateTwoVariants2()
        {
            var TAC = GenTAC(@"
var a, x, c;
x = 10;
a = 20;
goto 666;
666: c = a + x;
");

            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);
            var cfg    = new ControlFlowGraph(blocks);
            var InOut  = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(InOut.OUT[blocks[1]]["c"].Type, LatticeTypeData.CONST);
            Assert.AreEqual(InOut.OUT[blocks[1]]["c"].ConstValue, "30");
        }

Пример #13

        public void VariableAndConst()
        {
            var program = @"
var u,p,v;
u = 3;
p = u + 2;
";
            var blocks  = GenBlocks(program);
            var cfg     = new ControlFlowGraph(blocks);
            var InOut   = new ConstPropagation().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);
        }

Пример #14

        public void WhileProp()
        {
            var TAC = GenTAC(@"
var a, b, x, c;
while x > 1
{
	a = 2;
	b = 5;
}
c = a + b;
");

            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);
            var cfg    = new ControlFlowGraph(blocks);
            var InOut  = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(InOut.OUT[blocks[3]]["c"].Type, LatticeTypeData.CONST);
            Assert.AreEqual(InOut.OUT[blocks[3]]["c"].ConstValue, "7");
        }

Пример #15

        public void ForProp()
        {
            var TAC = GenTAC(@"
var a, b, x, c;
for x=1,10
{
	a = 2;
	b = 2;
}
c = a + b;
");

            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);
            var cfg    = new ControlFlowGraph(blocks);
            var InOut  = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(LatticeTypeData.CONST, InOut.OUT[blocks[3]]["c"].Type);
            Assert.AreEqual("4", InOut.OUT[blocks[3]]["c"].ConstValue);
        }

Пример #16

        public void TwoConstValues()
        {
            var TAC    = GenTAC(@"
var a, x, c;
input(c);
if c > 5
    x = 10;
else
    input(c);
if c > 5
    x = 20;
a = x;
");
            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);
            var cfg    = new ControlFlowGraph(blocks);
            var InOut  = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(LatticeTypeData.NAC, InOut.OUT[blocks[5]]["a"].Type);
            Assert.AreEqual(LatticeTypeData.NAC, InOut.OUT[blocks[5]]["x"].Type);
        }

Пример #17

        public void VariableAndConst3()
        {
            var TAC    = GenTAC(@"
var a,b,c;
b = 3;
goto 11;
c = b + 2;
11: a = 7;
");
            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);
            var cfg    = new ControlFlowGraph(blocks);
            var InOut  = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(LatticeTypeData.CONST, InOut.OUT[blocks[2]]["b"].Type);
            Assert.AreEqual(LatticeTypeData.CONST, InOut.OUT[blocks[2]]["a"].Type);
            Assert.AreEqual(false, InOut.OUT[blocks[2]].ContainsKey("c"));

            Assert.AreEqual("3", InOut.OUT[blocks[2]]["b"].ConstValue);
            Assert.AreEqual("7", InOut.OUT[blocks[2]]["a"].ConstValue);
        }

Пример #18

        public void ComplicatedEquation()
        {
            var TAC    = GenTAC(@"
var a,b,c;
a = 2;
b = 3;
c = a * b - 2;
");
            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);
            var cfg    = new ControlFlowGraph(blocks);
            var InOut  = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(InOut.OUT[blocks[0]]["a"].Type, LatticeTypeData.CONST);
            Assert.AreEqual(InOut.OUT[blocks[0]]["b"].Type, LatticeTypeData.CONST);
            Assert.AreEqual(InOut.OUT[blocks[0]]["c"].Type, LatticeTypeData.CONST);

            Assert.AreEqual("2", InOut.OUT[blocks[0]]["a"].ConstValue);
            Assert.AreEqual("3", InOut.OUT[blocks[0]]["b"].ConstValue);
            Assert.AreEqual("4", InOut.OUT[blocks[0]]["c"].ConstValue);
        }

Пример #19

        public void VariableAndConst3()
        {
            var program = @"
var a,b,c;
b = 3;
goto 11;
c = b + 2;
11: a = 7;
";
            var blocks  = GenBlocks(program);
            var cfg     = new ControlFlowGraph(blocks);
            var InOut   = new ConstPropagation().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);
        }

Пример #20

        public void ForProp()
        {
            var program = @"
var a, b, x, c;
for x=1,10
{
	a = 2;
	b = 2;
}
c = a + b;
";

            var blocks = GenBlocks(program);
            var cfg    = new ControlFlowGraph(blocks);
            var InOut  = new ConstPropagation().ExecuteNonGeneric(cfg);
            var actual = InOut.OUT[blocks.Last()];

            Assert.AreEqual(LatticeTypeData.CONST, actual["c"].Type);
            Assert.AreEqual("4", actual["c"].ConstValue);
        }

Пример #21

        public void PropagateOneVariant()
        {
            var TAC    = GenTAC(@"
var a, x, c;
if c > 5
    x = 10;
else
    input(c);
if c > 5
    a = x;
");
            var blocks = BasicBlockLeader.DivideLeaderToLeader(TAC);

            Assert.AreEqual(6, blocks.Count);
            var cfg   = new ControlFlowGraph(blocks);
            var InOut = new ConstPropagation().ExecuteNonGeneric(cfg);

            Assert.AreEqual(LatticeTypeData.CONST, InOut.OUT[blocks[5]]["a"].Type);
            Assert.AreEqual("10", InOut.OUT[blocks[5]]["a"].ConstValue);
            Assert.AreEqual(LatticeTypeData.NAC, InOut.OUT[blocks[5]]["c"].Type);
        }

Пример #22

        public void ComplicatedEquation()
        {
            var program = @"
var a,b,c;
a = 2;
b = 3;
c = a * b - 2;
";
            var blocks  = GenBlocks(program);
            var cfg     = new ControlFlowGraph(blocks);
            var InOut   = new ConstPropagation().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);
        }

Пример #23

        public void PropagateTwoVariants2()
        {
            var program = @"
var a, x, c;
x = 10;
a = 20;
goto 666;
666: c = a + x;
";
            var blocks  = GenBlocks(program);
            var cfg     = new ControlFlowGraph(blocks);
            var InOut   = new ConstPropagation().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);
        }

Пример #24

        public void TwoConstValues()
        {
            var program = @"
var a, x, c;
input(c);
if c > 5
    x = 10;
else
    input(c);
if c > 5
    x = 20;
a = x;
";
            var blocks  = GenBlocks(program);
            var cfg     = new ControlFlowGraph(blocks);
            var InOut   = new ConstPropagation().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);
        }

Пример #25

        public void ConstPropagationTest()
        {
            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 ConstPropagation();

            algorithm.Execute(graph);
            var iterationsFast = algorithm.Iterations;

            algorithm.Execute(graph, false);
            var iterationsSlow = algorithm.Iterations;

            Assert.LessOrEqual(iterationsFast, iterationsSlow);
        }

Пример #26

        public void ConstPropagationIterativeTest()
        {
            var TAC       = GenTAC(@"
var a, x, c;
if c > 5
    x = 10;
else
    input(c);
if c > 5
    a = x;
");
            var cfg       = new ControlFlowGraph(BasicBlockLeader.DivideLeaderToLeader(TAC));
            var constProp = new ConstPropagation();
            var result    = constProp.Execute(cfg);

            var blocks = cfg.GetCurrentBasicBlocks();

            Assert.AreEqual(LatticeTypeData.CONST, result[blocks[6]].Out["x"].Type);
            Assert.AreEqual("10", result[blocks[6]].Out["x"].ConstValue);
            Assert.AreEqual(LatticeTypeData.CONST, result[blocks[6]].Out["a"].Type);
            Assert.AreEqual("10", result[blocks[6]].Out["a"].ConstValue);
            Assert.AreEqual(LatticeTypeData.NAC, result[blocks[6]].Out["c"].Type);
        }

Пример #27

        public void ConstPropagationIterativeTest()
        {
            var program   = @"
var a, x, c;
if c > 5
    x = 10;
else
    input(c);
if c > 5
    a = x;
";
            var cfg       = GenCFG(program);
            var constProp = new ConstPropagation();
            var result    = constProp.Execute(cfg);
            var blocks    = cfg.GetCurrentBasicBlocks();
            var actual    = result[blocks.Last()];

            Assert.AreEqual(LatticeTypeData.NAC, actual.Out["c"].Type);
            Assert.AreEqual(LatticeTypeData.CONST, actual.Out["x"].Type);
            Assert.AreEqual(LatticeTypeData.CONST, actual.Out["a"].Type);

            Assert.AreEqual("10", actual.Out["x"].ConstValue);
            Assert.AreEqual("10", actual.Out["a"].ConstValue);
        }