WI #2045 Change Review

mayanje · mayanje · commit dc9a4c4f3288 · 2021-10-18T10:18:31.000+02:00
diff --git a/TypeCobol.Analysis.Test/BasicCfgInstrs/Declaratives1.int b/TypeCobol.Analysis.Test/BasicCfgInstrs/Declaratives1.int
@@ -71,4 +71,4 @@ Leaving block : 4
 =======
 METRICS
 =======
-{EdgeCount=27; NodeCount=24; ControlSubgraphCount=1; HighCyclomaticComplexity=5; HighEssentialComplexityPath=4}
+{EdgeCount=28; NodeCount=24; ControlSubgraphCount=1; HighCyclomaticComplexity=6; HighEssentialComplexityPath=5}
diff --git a/TypeCobol.Analysis.Test/BasicCfgInstrs/MixPerformEvaluateIf0.int b/TypeCobol.Analysis.Test/BasicCfgInstrs/MixPerformEvaluateIf0.int
@@ -170,4 +170,4 @@ Leaving block : 57
 =======
 METRICS
 =======
-{EdgeCount=78; NodeCount=58; ControlSubgraphCount=19; HighCyclomaticComplexity=22; HighEssentialComplexityPath=3}
+{EdgeCount=76; NodeCount=58; ControlSubgraphCount=19; HighCyclomaticComplexity=20; HighEssentialComplexityPath=1}
diff --git a/TypeCobol.Analysis/Graph/CfgAbstractInterpretation.Environment.cs b/TypeCobol.Analysis/Graph/CfgAbstractInterpretation.Environment.cs
@@ -16,46 +16,47 @@ public class Environment
             /// <summary>
             /// The Abstract Interpretation Stack
             /// </summary>
-            private Stack<BasicBlock<N, D>> InterpretationStack { get; set; }
+            private Stack<BasicBlock<N, D>> _interpretationStack;        
 
             /// <summary>
             /// The current execution stack
             /// </summary>
-            public IReadOnlyCollection<BasicBlock<N, D>> ExecutionStack => InterpretationStack;
+            public IReadOnlyCollection<BasicBlock<N, D>> ExecutionStack => _interpretationStack;
 
             /// <summary>
             /// The DFS Run stack
             /// </summary>
-            private Stack<BasicBlock<N, D>> DFSStack;
+            private Stack<BasicBlock<N, D>> _dFSStack;
 
             /// <summary>
             /// Already Visited Block
             /// </summary>
-            private System.Collections.BitArray Visited;
+            private System.Collections.BitArray _visited;
 
             /// <summary>
             /// Current CFG being run.
             /// </summary>
-            public readonly ControlFlowGraph<N, D> Cfg;
+            public ControlFlowGraph<N, D> Cfg { get; private set; }
             private IObserver[] _observers;
             /// <summary>
             /// Some metrics calculated.
             /// </summary>
-            public readonly Metrics Metrics;
-            public Environment(ControlFlowGraph<N, D> cfg, params IObserver[] observers)
+            public Metrics Metrics { get; private set; }
+            public Environment(params IObserver[] observers)
             {
-                this.Cfg = cfg;
                 this._observers = observers;
-                InterpretationStack = new Stack<BasicBlock<N, D>>();
-                // We use an iterative DFS algorithm.
-                Visited = new System.Collections.BitArray(cfg.AllBlocks.Count);
-                DFSStack = new Stack<BasicBlock<N, D>>();
-                this.Metrics = new Metrics();
             }
 
-            public virtual void Run()
+            public virtual Metrics Run(ControlFlowGraph<N, D> cfg)
             {
-                Run(Cfg.RootBlock, null);
+                this.Cfg = cfg;
+                _interpretationStack = new Stack<BasicBlock<N, D>>();
+                // We use an iterative DFS algorithm.
+                _visited = new System.Collections.BitArray(Cfg.AllBlocks.Count);
+                _dFSStack = new Stack<BasicBlock<N, D>>();
+                this.Metrics = new Metrics();
+                Run(Cfg.RootBlock, null);                
+                return this.Metrics;
             }
 
             /// <summary>
@@ -65,17 +66,17 @@ public virtual void Run()
             /// <param name="stopBlock">The stopping branch which will not be executed.</param>
             protected virtual void Run(BasicBlock<N, D> startBlock, BasicBlock<N, D> stopBlock)
             {
-                if (Visited.Get(startBlock.Index))
+                if (_visited.Get(startBlock.Index))
                     return;
-                DFSStack.Push(startBlock);
-                while (DFSStack.Count > 0)
+                _dFSStack.Push(startBlock);
+                while (_dFSStack.Count > 0)
                 {
-                    BasicBlock<N, D> block = DFSStack.Pop();
+                    BasicBlock<N, D> block = _dFSStack.Pop();
                     if (block == stopBlock)
                         return;
-                    if (!Visited[block.Index])
+                    if (!_visited[block.Index])
                     {
-                        Visited.Set(block.Index, true);
+                        _visited.Set(block.Index, true);
                         Metrics.NodeCount++;
                         EnterBlock(block);
                         IterateBlock(block);
@@ -86,28 +87,18 @@ protected virtual void Run(BasicBlock<N, D> startBlock, BasicBlock<N, D> stopBlo
                         {                            
                             nextFlowBlock = InterpretContext(block);
                         }
-
-                        LeaveBlock(block);
+                        Metrics.EdgeCount += block.SuccessorEdges.Count;
+                        LeaveBlock(block);                        
                         if (nextFlowBlock == null)
                         {
                             foreach (var edge in block.SuccessorEdges)
                             {
-                                DFSStack.Push(Cfg.SuccessorEdges[edge]);
-                                Metrics.EdgeCount++;
+                                _dFSStack.Push(Cfg.SuccessorEdges[edge]);
                             }
                         }
                         else
                         {
-                            DFSStack.Push(nextFlowBlock);
-                            // If the multi branch context instruction has a successor
-                            // to the next flow block, add one edge.
-                            foreach (var edge in block.SuccessorEdges)
-                            {
-                                if (Cfg.SuccessorEdges[edge] == nextFlowBlock)
-                                {
-                                    Metrics.EdgeCount++;
-                                }
-                            }
+                            _dFSStack.Push(nextFlowBlock);
                         }
                     }
                 }
@@ -119,7 +110,7 @@ protected virtual void Run(BasicBlock<N, D> startBlock, BasicBlock<N, D> stopBlo
             /// <param name="block"></param>
             private void IterateBlock(BasicBlock<N, D> block)
             {
-                if (_observers != null)
+                if (_observers != null && block.Instructions != null)
                 {
                     foreach (var i in block.Instructions)
                     {
@@ -174,30 +165,28 @@ private BasicBlock<N, D> CheckRelocatedBlock(MultiBranchContext<N, D> ctx, Basic
             /// <returns>The next block</returns>
             private BasicBlock<N, D> InterpretContext(BasicBlock<N, D> block)
             {
-                InterpretationStack.Push(block);
+                _interpretationStack.Push(block);
 
                 Metrics.ControlSubgraphCount++;
                 if (block.Context.SubContexts != null)
                 {                    
                     //Instruction with sub context : run all sub context.
                     foreach (var ctx in block.Context.SubContexts)
                     {
-                        Metrics.EdgeCount++;
                         Run(CheckRelocatedBlock(ctx, ctx.OriginBlock), CheckRelocatedBlock(ctx, ctx.NextFlowBlock));
                     }
                 }
                 else
                 {
                     foreach (var b in block.Context.Branches)
                     {
-                        Metrics.EdgeCount++;
                         Run(CheckRelocatedBlock(block.Context, b), CheckRelocatedBlock(block.Context, block.Context.NextFlowBlock));
                     }
                 }
 
-                System.Diagnostics.Debug.Assert(this.InterpretationStack.Count > 0 &&
-                                                this.InterpretationStack.Peek() == block);
-                this.InterpretationStack.Pop();
+                System.Diagnostics.Debug.Assert(this._interpretationStack.Count > 0 &&
+                                                this._interpretationStack.Peek() == block);
+                this._interpretationStack.Pop();
                 return CheckRelocatedBlock(block.Context, block.Context.NextFlowBlock);
             }
 
diff --git a/TypeCobol.Analysis/Graph/CfgAbstractInterpretation.cs b/TypeCobol.Analysis/Graph/CfgAbstractInterpretation.cs
@@ -21,9 +21,8 @@ public partial class CfgAbstractInterpretation<N, D>
         /// <returns>Metrics collected during abstract interpretation</returns>
         public static Metrics Run(ControlFlowGraph<N, D> cfg, params IObserver[] observers)
         {
-            Environment env = new Environment(cfg, observers);
-            env.Run();
-            return env.Metrics;
+            Environment env = new Environment(observers);
+            return env.Run(cfg);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -16,46 +16,47 @@ public class Environment`
`16`	`16`	`/// <summary>`
`17`	`17`	`/// The Abstract Interpretation Stack`
`18`	`18`	`/// </summary>`
`19`		`- private Stack<BasicBlock<N, D>> InterpretationStack { get; set; }`
	`19`	`+ private Stack<BasicBlock<N, D>> _interpretationStack;`
`20`	`20`
`21`	`21`	`/// <summary>`
`22`	`22`	`/// The current execution stack`
`23`	`23`	`/// </summary>`
`24`		`- public IReadOnlyCollection<BasicBlock<N, D>> ExecutionStack => InterpretationStack;`
	`24`	`+ public IReadOnlyCollection<BasicBlock<N, D>> ExecutionStack => _interpretationStack;`
`25`	`25`
`26`	`26`	`/// <summary>`
`27`	`27`	`/// The DFS Run stack`
`28`	`28`	`/// </summary>`
`29`		`- private Stack<BasicBlock<N, D>> DFSStack;`
	`29`	`+ private Stack<BasicBlock<N, D>> _dFSStack;`
`30`	`30`
`31`	`31`	`/// <summary>`
`32`	`32`	`/// Already Visited Block`
`33`	`33`	`/// </summary>`
`34`		`- private System.Collections.BitArray Visited;`
	`34`	`+ private System.Collections.BitArray _visited;`
`35`	`35`
`36`	`36`	`/// <summary>`
`37`	`37`	`/// Current CFG being run.`
`38`	`38`	`/// </summary>`
`39`		`- public readonly ControlFlowGraph<N, D> Cfg;`
	`39`	`+ public ControlFlowGraph<N, D> Cfg { get; private set; }`
`40`	`40`	`private IObserver[] _observers;`
`41`	`41`	`/// <summary>`
`42`	`42`	`/// Some metrics calculated.`
`43`	`43`	`/// </summary>`
`44`		`- public readonly Metrics Metrics;`
`45`		`- public Environment(ControlFlowGraph<N, D> cfg, params IObserver[] observers)`
	`44`	`+ public Metrics Metrics { get; private set; }`
	`45`	`+ public Environment(params IObserver[] observers)`
`46`	`46`	`{`
`47`		`- this.Cfg = cfg;`
`48`	`47`	`this._observers = observers;`
`49`		`- InterpretationStack = new Stack<BasicBlock<N, D>>();`
`50`		`- // We use an iterative DFS algorithm.`
`51`		`- Visited = new System.Collections.BitArray(cfg.AllBlocks.Count);`
`52`		`- DFSStack = new Stack<BasicBlock<N, D>>();`
`53`		`- this.Metrics = new Metrics();`
`54`	`48`	`}`
`55`	`49`
`56`		`- public virtual void Run()`
	`50`	`+ public virtual Metrics Run(ControlFlowGraph<N, D> cfg)`
`57`	`51`	`{`
`58`		`- Run(Cfg.RootBlock, null);`
	`52`	`+ this.Cfg = cfg;`
	`53`	`+ _interpretationStack = new Stack<BasicBlock<N, D>>();`
	`54`	`+ // We use an iterative DFS algorithm.`
	`55`	`+ _visited = new System.Collections.BitArray(Cfg.AllBlocks.Count);`
	`56`	`+ _dFSStack = new Stack<BasicBlock<N, D>>();`
	`57`	`+ this.Metrics = new Metrics();`
	`58`	`+ Run(Cfg.RootBlock, null);`
	`59`	`+ return this.Metrics;`
`59`	`60`	`}`
`60`	`61`
`61`	`62`	`/// <summary>`
`@@ -65,17 +66,17 @@ public virtual void Run()`
`65`	`66`	`/// <param name="stopBlock">The stopping branch which will not be executed.</param>`
`66`	`67`	`protected virtual void Run(BasicBlock<N, D> startBlock, BasicBlock<N, D> stopBlock)`
`67`	`68`	`{`
`68`		`- if (Visited.Get(startBlock.Index))`
	`69`	`+ if (_visited.Get(startBlock.Index))`
`69`	`70`	`return;`
`70`		`- DFSStack.Push(startBlock);`
`71`		`- while (DFSStack.Count > 0)`
	`71`	`+ _dFSStack.Push(startBlock);`
	`72`	`+ while (_dFSStack.Count > 0)`
`72`	`73`	`{`
`73`		`- BasicBlock<N, D> block = DFSStack.Pop();`
	`74`	`+ BasicBlock<N, D> block = _dFSStack.Pop();`
`74`	`75`	`if (block == stopBlock)`
`75`	`76`	`return;`
`76`		`- if (!Visited[block.Index])`
	`77`	`+ if (!_visited[block.Index])`
`77`	`78`	`{`
`78`		`- Visited.Set(block.Index, true);`
	`79`	`+ _visited.Set(block.Index, true);`
`79`	`80`	`Metrics.NodeCount++;`
`80`	`81`	`EnterBlock(block);`
`81`	`82`	`IterateBlock(block);`
`@@ -86,28 +87,18 @@ protected virtual void Run(BasicBlock<N, D> startBlock, BasicBlock<N, D> stopBlo`
`86`	`87`	`{`
`87`	`88`	`nextFlowBlock = InterpretContext(block);`
`88`	`89`	`}`
`89`		`-`
`90`		`- LeaveBlock(block);`
	`90`	`+ Metrics.EdgeCount += block.SuccessorEdges.Count;`
	`91`	`+ LeaveBlock(block);`
`91`	`92`	`if (nextFlowBlock == null)`
`92`	`93`	`{`
`93`	`94`	`foreach (var edge in block.SuccessorEdges)`
`94`	`95`	`{`
`95`		`- DFSStack.Push(Cfg.SuccessorEdges[edge]);`
`96`		`- Metrics.EdgeCount++;`
	`96`	`+ _dFSStack.Push(Cfg.SuccessorEdges[edge]);`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`	`else`
`100`	`100`	`{`
`101`		`- DFSStack.Push(nextFlowBlock);`
`102`		`- // If the multi branch context instruction has a successor`
`103`		`- // to the next flow block, add one edge.`
`104`		`- foreach (var edge in block.SuccessorEdges)`
`105`		`- {`
`106`		`- if (Cfg.SuccessorEdges[edge] == nextFlowBlock)`
`107`		`- {`
`108`		`- Metrics.EdgeCount++;`
`109`		`- }`
`110`		`- }`
	`101`	`+ _dFSStack.Push(nextFlowBlock);`
`111`	`102`	`}`
`112`	`103`	`}`
`113`	`104`	`}`
`@@ -119,7 +110,7 @@ protected virtual void Run(BasicBlock<N, D> startBlock, BasicBlock<N, D> stopBlo`
`119`	`110`	`/// <param name="block"></param>`
`120`	`111`	`private void IterateBlock(BasicBlock<N, D> block)`
`121`	`112`	`{`
`122`		`- if (_observers != null)`
	`113`	`+ if (_observers != null && block.Instructions != null)`
`123`	`114`	`{`
`124`	`115`	`foreach (var i in block.Instructions)`
`125`	`116`	`{`
`@@ -174,30 +165,28 @@ private BasicBlock<N, D> CheckRelocatedBlock(MultiBranchContext<N, D> ctx, Basic`
`174`	`165`	`/// <returns>The next block</returns>`
`175`	`166`	`private BasicBlock<N, D> InterpretContext(BasicBlock<N, D> block)`
`176`	`167`	`{`
`177`		`- InterpretationStack.Push(block);`
	`168`	`+ _interpretationStack.Push(block);`
`178`	`169`
`179`	`170`	`Metrics.ControlSubgraphCount++;`
`180`	`171`	`if (block.Context.SubContexts != null)`
`181`	`172`	`{`
`182`	`173`	`//Instruction with sub context : run all sub context.`
`183`	`174`	`foreach (var ctx in block.Context.SubContexts)`
`184`	`175`	`{`
`185`		`- Metrics.EdgeCount++;`
`186`	`176`	`Run(CheckRelocatedBlock(ctx, ctx.OriginBlock), CheckRelocatedBlock(ctx, ctx.NextFlowBlock));`
`187`	`177`	`}`
`188`	`178`	`}`
`189`	`179`	`else`
`190`	`180`	`{`
`191`	`181`	`foreach (var b in block.Context.Branches)`
`192`	`182`	`{`
`193`		`- Metrics.EdgeCount++;`
`194`	`183`	`Run(CheckRelocatedBlock(block.Context, b), CheckRelocatedBlock(block.Context, block.Context.NextFlowBlock));`
`195`	`184`	`}`
`196`	`185`	`}`
`197`	`186`
`198`		`- System.Diagnostics.Debug.Assert(this.InterpretationStack.Count > 0 &&`
`199`		`- this.InterpretationStack.Peek() == block);`
`200`		`- this.InterpretationStack.Pop();`
	`187`	`+ System.Diagnostics.Debug.Assert(this._interpretationStack.Count > 0 &&`
	`188`	`+ this._interpretationStack.Peek() == block);`
	`189`	`+ this._interpretationStack.Pop();`
`201`	`190`	`return CheckRelocatedBlock(block.Context, block.Context.NextFlowBlock);`
`202`	`191`	`}`
`203`	`192`
Original file line number	Diff line number	Diff line change
`@@ -21,9 +21,8 @@ public partial class CfgAbstractInterpretation<N, D>`
`21`	`21`	`/// <returns>Metrics collected during abstract interpretation</returns>`
`22`	`22`	`public static Metrics Run(ControlFlowGraph<N, D> cfg, params IObserver[] observers)`
`23`	`23`	`{`
`24`		`- Environment env = new Environment(cfg, observers);`
`25`		`- env.Run();`
`26`		`- return env.Metrics;`
	`24`	`+ Environment env = new Environment(observers);`
	`25`	`+ return env.Run(cfg);`
`27`	`26`	`}`
`28`	`27`	`}`
`29`	`28`	`}`