예제 #1
0
파일: Demos.cs 프로젝트: koyre/b8
        public void naturalCycleTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.sample1);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LinearToBaseBlock.Build(code);
            var cfg    = ListBlocksToCFG.Build(blocks);

            cfg.ShowCompact = true;
            Console.WriteLine(cfg);
            var ncg = new NaturalCycleGraph(cfg);
            var res = ncg.findBetween(6, 4);

            res.Sort();
            var expected = new List <int>()
            {
                4, 6
            };

            CollectionAssert.AreEqual(res, expected);

            var res1 = ncg.findBetween(13, 8);

            res1.Sort();
            Console.Write("Cycle btw 13, 8: " + string.Join(", ", res1));
            var expected1 = new List <int>()
            {
                8, 10, 11, 12, 13
            };

            CollectionAssert.AreEqual(res1, expected1);
        }
예제 #2
0
파일: UnitTest1.cs 프로젝트: koyre/b8
        public void SimpleInterpret()
        {
            var root = Parser.ParseString("n = 666; print(n);");
            var code = ProgramTreeToLinear.Build(root);
            var res  = LinearInterpretator.Run(code);

            Assert.AreEqual(res[0], 666);
            Assert.AreEqual(res.Count, 1);
        }
예제 #3
0
파일: UnitTest1.cs 프로젝트: koyre/b8
        public void LabelGotoTest()
        {
            var root = Parser.ParseString("label1 :" +
                                          "n = 1;" +
                                          "goto label1;");
            var code = ProgramTreeToLinear.Build(root);

            foreach (var threeAddressCode in code)
            {
                Console.WriteLine(threeAddressCode);
            }
            Assert.AreEqual(code.Count, 3);
        }
예제 #4
0
파일: UnitTest1.cs 프로젝트: koyre/b8
        public void DominatorTreeTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.domSampleTrivial);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LYtest.BaseBlocks.LinearToBaseBlock.Build(code);
            var cfg    = ListBlocksToCFG.Build(blocks);

            var dt   = new LYtest.DominatorTree.DominatorTree(cfg);
            var node = dt.GetRoot();

            Console.WriteLine(dt.ToString());
            Console.WriteLine(cfg.ToString());
            Assert.AreEqual(dt.NumberOfVertices(), 4);
        }
예제 #5
0
파일: Demos.cs 프로젝트: koyre/b8
        public void SsaConstructionTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.ssaoptimizationSample2);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LinearToBaseBlock.Build(code);
            var cfg    = new CFGraph(blocks);

            Console.WriteLine("###--------- Input CF Graph ---------###");
            Console.WriteLine(cfg.ToString());
            SsaConstruction ssa = new SsaConstruction(cfg);

            Console.WriteLine("###--------- Output SSA Graph ---------###");
            Console.WriteLine(ssa.SsaForm.ToString());
        }
예제 #6
0
파일: Demos.cs 프로젝트: koyre/b8
        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);
        }
예제 #7
0
파일: UnitTest1.cs 프로젝트: koyre/b8
        public void RegionSequenceTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.regionSqeuenceSample);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LinearToBaseBlock.Build(code);
            var cfg    = ListBlocksToCFG.Build(blocks);

            var regSeq    = new RegionSequence(cfg);
            var natCycles = cfg.getNaturalCyclesForBackwardEdges();

            Assert.AreEqual(regSeq.Regions.Count, 24);
            Assert.AreEqual(regSeq.Regions.Last().Header, cfg.GetVertices().ToList()[0]);
            Assert.IsTrue(regSeq.Regions.Exists(r => natCycles[0][0] == r.Header));
        }
예제 #8
0
파일: UnitTest1.cs 프로젝트: koyre/b8
        public void LinearCodeTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.sample1);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LYtest.BaseBlocks.LinearToBaseBlock.Build(code);

            var labels = code.Select(c => c.Label);

            // All elems have label
            Assert.IsFalse(labels.Any(c => c == null));

            // All labels different
            Assert.AreEqual(labels.Distinct().Count(), code.Count);


            // All elems in blocks
            Assert.AreEqual(blocks.Select(b => b.Enumerate().Count()).Sum(), code.Count);

            // There is no empty blocks
            Assert.IsTrue(blocks.All(b => b.Enumerate().Any()));

            var isGotoOp =
                new Func <IThreeAddressCode, bool>(
                    c => c.Operation == Operation.CondGoto || c.Operation == Operation.Goto);

            foreach (var baseBlock in blocks)
            {
                var notLast = baseBlock.Enumerate().Reverse().Skip(1);
                Assert.IsFalse(notLast.Any(isGotoOp));
            }

            foreach (var baseBlock in blocks)
            {
                foreach (var threeAddressCode in baseBlock.Enumerate())
                {
                    Console.WriteLine(threeAddressCode);
                }

                Console.WriteLine();
            }

            var gotoLables  = code.Where(isGotoOp).Select(c => c.Destination.Value);
            var firstLabels = blocks.Select(b => b.Enumerate().First().Label.Value);

            foreach (var d in gotoLables)
            {
                Assert.IsTrue(firstLabels.Contains(d));
            }
        }
예제 #9
0
파일: UnitTest1.cs 프로젝트: koyre/b8
        public void SimpleInterpret2()
        {
            var root = Parser.ParseString("n = 1;" +
                                          "k=n;" +
                                          "z=k+1;" +
                                          "print(2);" +
                                          "print(z);" +
                                          "");
            var code = ProgramTreeToLinear.Build(root);
            var res  = LinearInterpretator.Run(code);

            Assert.AreEqual(res.Count, 2);
            Assert.AreEqual(res[0], 2);
            Assert.AreEqual(res[1], 2);
        }
예제 #10
0
파일: Demos.cs 프로젝트: koyre/b8
        public void DominatorTreeDemo()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.sample2);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LYtest.BaseBlocks.LinearToBaseBlock.Build(code);
            var cfg    = ListBlocksToCFG.Build(blocks);

            var dt   = new LYtest.DominatorTree.DominatorTree(cfg);
            var node = dt.GetRoot();

            cfg.ShowCompact = true;
            Console.WriteLine(cfg);

            Console.WriteLine("\nDominator tree:");
            Console.WriteLine(dt.ToString());
        }
예제 #11
0
파일: UnitTest1.cs 프로젝트: koyre/b8
        public void CFGNodeSetTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.sample1);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LYtest.BaseBlocks.LinearToBaseBlock.Build(code);
            var cfg    = ListBlocksToCFG.Build(blocks);

            var nodes = cfg.graph.Vertices.Select(n => n.Value);

            Assert.AreEqual(nodes.Count(), blocks.Count());

            foreach (var b in blocks)
            {
                Assert.IsTrue(nodes.Contains(b));
            }
        }
예제 #12
0
파일: UnitTest1.cs 프로젝트: koyre/b8
        public void AvailableExpressionsTest()
        {
            Console.Write("----------- Available Expressions Analyzer ---------- \n");
            var root   = Parser.ParseString(Samples.SampleProgramText.AvailableExprsSample);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LinearToBaseBlock.Build(code);
            var cfg    = ListBlocksToCFG.Build(blocks);


            var exprsAnalizer = new AvailableExprAnalyzer(cfg);

            exprsAnalizer.analyze();

            Assert.IsTrue(exprsAnalizer.OutBlocks[blocks[0]].Count == 1);
            Assert.IsTrue(exprsAnalizer.InBlocks[blocks[2]].Count == 1);
            Assert.IsTrue(exprsAnalizer.OutBlocks[blocks[2]].Count == 0);
        }
예제 #13
0
파일: Demos.cs 프로젝트: koyre/b8
        public void ReachingDefsIterTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.sample2);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LYtest.BaseBlocks.LinearToBaseBlock.Build(code);
            var cfg    = ListBlocksToCFG.Build(blocks);

            var defs = new ReachingDefsIterAlg(cfg);

            cfg.InfoFunc = node =>
            {
                var outs = string.Join(", ", defs.Out[node]);
                var ins  = node.ParentsNodes.Count > 0 ? string.Join(", ", defs.In[node]) : "";
                return($" In: {ins} \n\t\t\tOut: {outs}");
            };
            Console.WriteLine(cfg);
        }
예제 #14
0
파일: UnitTest1.cs 프로젝트: koyre/b8
        public void CFGTest()
        {
            var tree   = Parser.ParseString(Samples.SampleProgramText.sample1);
            var code   = ProgramTreeToLinear.Build(tree);
            var blocks = LYtest.BaseBlocks.LinearToBaseBlock.Build(code);

            var cfg = ListBlocksToCFG.Build(blocks);

            Assert.AreEqual(cfg.GetRoot().ParentsNodes.Count, 0);

            Assert.AreEqual(cfg.Blocks.Count, 15);

            Assert.IsNotNull(cfg.GetRoot().directChild);
            Assert.IsNotNull(cfg.GetRoot().gotoNode);

            cfg.Blocks.ForEach(Console.WriteLine);
        }
예제 #15
0
파일: UnitTest1.cs 프로젝트: nikki161/b8
        public void GenKillTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.sample2);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LYtest.BaseBlocks.LinearToBaseBlock.Build(code);

            blocks.ForEach(Console.WriteLine);

            var genKill = new GenKillBuilder(blocks);

            Assert.AreEqual(genKill.Gen[blocks[0]].Count, 3);
            Assert.AreEqual(genKill.Kill[blocks[0]].Count, 4);


            Assert.AreEqual(genKill.Gen[blocks[6]].Count, 1);
            Assert.AreEqual(genKill.Kill[blocks[6]].Count, 2);
        }
예제 #16
0
파일: UnitTest1.cs 프로젝트: koyre/b8
        public void SimpleInterpret3()
        {
            var root = Parser.ParseString("n = 1;" +
                                          "k=n;" +
                                          "z=k+1;" +
                                          "print(z);" +
                                          "t = 2*3;" +
                                          "if (z > 0) {" +
                                          "for x = 2..(z+2) {" +
                                          "t = t + 1; }" +
                                          "}" +
                                          "print (t);");
            var code = ProgramTreeToLinear.Build(root);
            var res  = LinearInterpretator.Run(code);

            Assert.AreEqual(res.Count, 2);
            Assert.AreEqual(res[0], 2);
            Assert.AreEqual(res[1], 9);
        }
예제 #17
0
파일: Demos.cs 프로젝트: koyre/b8
        public void SsaCopyPropagationTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.ssaoptimizationSample3);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LinearToBaseBlock.Build(code);
            var cfg    = new CFGraph(blocks);

            Console.WriteLine("###--------- Input CF Graph ---------###");
            Console.WriteLine(cfg.ToString());
            SsaConstruction ssa      = new SsaConstruction(cfg);
            CFGraph         ssaGraph = ssa.SsaForm;

            Console.WriteLine("###--------- Constructed SSA Graph ---------###");
            Console.WriteLine(ssaGraph.ToString());

            SsaCopyPropagation ssaCopyPropagation = new SsaCopyPropagation(ssaGraph);

            ssaCopyPropagation.Launch();
            Console.WriteLine("###--------- Output SSA Graph after copy propagation ---------###");
            Console.WriteLine(ssaCopyPropagation.OptimizedSsaGraph);
        }
예제 #18
0
파일: UnitTest1.cs 프로젝트: koyre/b8
        public void ActiveVarsIterTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.sample3);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LYtest.BaseBlocks.LinearToBaseBlock.Build(code);
            var cfg    = ListBlocksToCFG.Build(blocks);

            var DefUse = new ActiveVarsIterAlg(cfg);

            foreach (var block in cfg.graph.Vertices)
            {
                Console.Write(block);
                foreach (var labelValue in DefUse.In[block])
                {
                    Console.Write(labelValue);
                    Console.Write(", ");
                }
                Console.WriteLine();
                Console.WriteLine("-----------------------");
            }
        }
예제 #19
0
파일: UnitTest1.cs 프로젝트: nikki161/b8
        public void CFGTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.sample1);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LYtest.BaseBlocks.LinearToBaseBlock.Build(code);
            var cfg    = ListBlocksToCFG.Build(blocks);

            Assert.AreEqual(cfg.GetRoot().ParentsNodes.Count, 0);

            var cfgview = new CFGLookup(cfg.GetRoot());

            while (cfgview.MoveDirect())
            {
            }
            Assert.AreEqual(cfgview.PathLen, 14);

            while (cfgview.MoveBack())
            {
            }
            Assert.AreEqual(cfgview.Current, cfg.GetRoot());
        }
예제 #20
0
파일: Demos.cs 프로젝트: koyre/b8
        public void allRetreatingEdgesAreBackwardsTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.sample1);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LinearToBaseBlock.Build(code);
            var cfg    = ListBlocksToCFG.Build(blocks);

            cfg.ShowCompact = true;
            Console.WriteLine(cfg);
            Console.WriteLine("allRetreatingEdgesAreBackwards: " + cfg.allRetreatingEdgesAreBackwards());
            Assert.AreEqual(cfg.allRetreatingEdgesAreBackwards(), true);

            root            = Parser.ParseString(Samples.SampleProgramText.veryStrangeCode);
            code            = ProgramTreeToLinear.Build(root);
            blocks          = LinearToBaseBlock.Build(code);
            cfg             = ListBlocksToCFG.Build(blocks);
            cfg.ShowCompact = true;
            Console.WriteLine(cfg);
            Console.WriteLine("allRetreatingEdgesAreBackwards: " + cfg.allRetreatingEdgesAreBackwards());
            Assert.AreEqual(cfg.allRetreatingEdgesAreBackwards(), false);
        }
예제 #21
0
파일: Demos.cs 프로젝트: koyre/b8
        public void AvailableExpressionsTest()
        {
            Console.Write("----------- Available Expressions Analyzer ---------- \n");
            var root   = Parser.ParseString(Samples.SampleProgramText.AvailableExprsSample);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LYtest.BaseBlocks.LinearToBaseBlock.Build(code);
            var cfg    = ListBlocksToCFG.Build(blocks);


            var exprsAnalizer = new AvailableExprAnalyzer(cfg);

            exprsAnalizer.analyze();


            foreach (var block in blocks)
            {
                Console.Write("Block: " + block);

                Console.Write("\n");

                Console.Write("IN: \t");
                foreach (var expr in exprsAnalizer.InBlocks[block])
                {
                    Console.Write(expr);
                    Console.Write(", ");
                }
                Console.Write("\n");

                Console.Write("Out: \t");
                foreach (var expr in exprsAnalizer.OutBlocks[block])
                {
                    Console.Write(expr);
                    Console.Write(", ");
                }
                Console.Write("\n");

                Console.WriteLine("-----------------------");
            }
        }
예제 #22
0
파일: Demos.cs 프로젝트: koyre/b8
        public void GenKillTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.sample2);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LYtest.BaseBlocks.LinearToBaseBlock.Build(code);

            var genKill = new GenKillBuilder(blocks);

            foreach (var b in blocks)
            {
                Console.WriteLine(b);
                Console.Write("Gen: ");
                Console.WriteLine(string.Join(",", genKill.Gen[b]));
                Console.Write("Kill: ");
                Console.WriteLine(string.Join(",", genKill.Kill[b]));
                Console.WriteLine("-------------------------");
            }
            Assert.AreEqual(genKill.Gen[blocks[0]].Count, 3);
            Assert.AreEqual(genKill.Kill[blocks[0]].Count, 4);

            Assert.AreEqual(genKill.Gen[blocks[6]].Count, 1);
            Assert.AreEqual(genKill.Kill[blocks[6]].Count, 2);
        }
예제 #23
0
파일: UnitTest1.cs 프로젝트: koyre/b8
        public void SymbolicAnalysisTest()
        {
            var root   = Parser.ParseString(Samples.SampleProgramText.symbolicAnalysisSample);
            var code   = ProgramTreeToLinear.Build(root);
            var blocks = LinearToBaseBlock.Build(code);

            SymbolicAnalysis syman = new SymbolicAnalysis();
            var map = syman.createMap(blocks[0] as BaseBlock);

            Console.WriteLine("baseblock1");
            Console.WriteLine("------");
            foreach (var b in code)
            {
                Console.Write(b.ToString() + " ");
                Console.WriteLine(b.Operation.ToString());
            }
            Console.WriteLine("------");

            root   = Parser.ParseString(Samples.SampleProgramText.symbolicAnalysisSample2);
            code   = ProgramTreeToLinear.Build(root);
            blocks = LinearToBaseBlock.Build(code);

            var map2 = syman.createMap(blocks[0] as BaseBlock);

            Console.WriteLine("baseblock2");
            Console.WriteLine("------");
            foreach (var b in code)
            {
                Console.Write(b.ToString() + " ");
                Console.WriteLine(b.Operation.ToString());
            }
            Console.WriteLine("------");


            Console.WriteLine("symbolic map for block1");
            Console.WriteLine("------");
            foreach (var m in map.variableTable)
            {
                if (m.Key != null)
                {
                    Console.Write(m.Key.ToString() + " ");
                }
                if (m.Value.type != null)
                {
                    Console.WriteLine(m.Value.type.ToString());
                }
                Console.Write("Constants: ");
                if (m.Value.value.constants != null)
                {
                    foreach (var v in m.Value.value.constants)
                    {
                        Console.Write(v.ToString() + " ");
                    }
                }
                Console.Write("Variables: ");
                if (m.Value.value.variables != null)
                {
                    foreach (var v in m.Value.value.variables)
                    {
                        Console.Write(v.ToString() + " ");
                    }
                }
                Console.WriteLine();
            }
            Console.WriteLine("------");

            Console.WriteLine("symbolic map for block2");
            Console.WriteLine("------");
            foreach (var m in map2.variableTable)
            {
                if (m.Key != null)
                {
                    Console.Write(m.Key.ToString() + " ");
                }
                if (m.Value.type != null)
                {
                    Console.WriteLine(m.Value.type.ToString());
                }
                Console.Write("Constants: ");
                if (m.Value.value.constants != null)
                {
                    foreach (var v in m.Value.value.constants)
                    {
                        Console.Write(v.ToString() + " ");
                    }
                }
                Console.Write("Variables: ");
                if (m.Value.value.variables != null)
                {
                    foreach (var v in m.Value.value.variables)
                    {
                        Console.Write(v.ToString() + " ");
                    }
                }
                Console.WriteLine();
            }
            Console.WriteLine("------");

            Console.WriteLine("Composition of map1 and map2 on x = 4 + 3*y + z; instruction");
            var compmap = syman.Composition(code[code.Count - 1], map2, map);

            Console.WriteLine("------");
            foreach (var m in compmap.variableTable)
            {
                if (m.Key != null)
                {
                    Console.Write(m.Key.ToString() + " ");
                }
                if (m.Value.type != null)
                {
                    Console.WriteLine(m.Value.type.ToString());
                }
                Console.Write("Constants: ");
                if (m.Value.value.constants != null)
                {
                    foreach (var v in m.Value.value.constants)
                    {
                        Console.Write(v.ToString() + " ");
                    }
                }
                Console.Write("Variables: ");
                if (m.Value.value.variables != null)
                {
                    foreach (var v in m.Value.value.variables)
                    {
                        Console.Write(v.ToString() + " ");
                    }
                }
                Console.WriteLine();
            }
            Console.WriteLine("------");
        }