public static void LoopAwareBlockOrder1()
{
var basicBlocks = BlockTests.Scenario1;
LoopAwareBlockOrder loopAwareBlockOrder = new LoopAwareBlockOrder(basicBlocks);
Assert.AreEqual(loopAwareBlockOrder.GetLoopDepth(basicBlocks[0]), 0);
Assert.AreEqual(loopAwareBlockOrder.GetLoopDepth(basicBlocks[1]), 1);
Assert.AreEqual(loopAwareBlockOrder.GetLoopDepth(basicBlocks[2]), 1);
Assert.AreEqual(loopAwareBlockOrder.GetLoopDepth(basicBlocks[3]), 1);
Assert.AreEqual(loopAwareBlockOrder.GetLoopDepth(basicBlocks[4]), 2);
Assert.AreEqual(loopAwareBlockOrder.GetLoopDepth(basicBlocks[5]), 0);
Assert.AreEqual(loopAwareBlockOrder.GetLoopDepth(basicBlocks[6]), 2);
Assert.AreEqual(loopAwareBlockOrder.GetLoopDepth(basicBlocks[7]), 1);
Assert.AreEqual(loopAwareBlockOrder.GetLoopIndex(basicBlocks[0]), -1);
Assert.AreEqual(loopAwareBlockOrder.GetLoopIndex(basicBlocks[1]), 1);
Assert.AreEqual(loopAwareBlockOrder.GetLoopIndex(basicBlocks[2]), 1);
Assert.AreEqual(loopAwareBlockOrder.GetLoopIndex(basicBlocks[3]), 1);
Assert.AreEqual(loopAwareBlockOrder.GetLoopIndex(basicBlocks[4]), 0);
Assert.AreEqual(loopAwareBlockOrder.GetLoopIndex(basicBlocks[5]), -1);
Assert.AreEqual(loopAwareBlockOrder.GetLoopIndex(basicBlocks[6]), 0);
Assert.AreEqual(loopAwareBlockOrder.GetLoopIndex(basicBlocks[7]), 1);
Assert.AreSame(loopAwareBlockOrder.NewBlockOrder[0], basicBlocks[0]);
Assert.AreSame(loopAwareBlockOrder.NewBlockOrder[1], basicBlocks[1]);
Assert.AreSame(loopAwareBlockOrder.NewBlockOrder[2], basicBlocks[2]);
Assert.AreSame(loopAwareBlockOrder.NewBlockOrder[3], basicBlocks[4]);
Assert.AreSame(loopAwareBlockOrder.NewBlockOrder[4], basicBlocks[6]);
Assert.AreSame(loopAwareBlockOrder.NewBlockOrder[7], basicBlocks[5]);
Dump(basicBlocks, loopAwareBlockOrder);
}
public static void LoopAwareBlockOrder1()
{
var basicBlocks = BlockTests.Scenario1;
var loopAwareBlockOrder = new LoopAwareBlockOrder(basicBlocks);
Assert.Equal(loopAwareBlockOrder.GetLoopDepth(basicBlocks[0]), 0);
Assert.Equal(loopAwareBlockOrder.GetLoopDepth(basicBlocks[1]), 1);
Assert.Equal(loopAwareBlockOrder.GetLoopDepth(basicBlocks[2]), 1);
Assert.Equal(loopAwareBlockOrder.GetLoopDepth(basicBlocks[3]), 1);
Assert.Equal(loopAwareBlockOrder.GetLoopDepth(basicBlocks[4]), 2);
Assert.Equal(loopAwareBlockOrder.GetLoopDepth(basicBlocks[5]), 0);
Assert.Equal(loopAwareBlockOrder.GetLoopDepth(basicBlocks[6]), 2);
Assert.Equal(loopAwareBlockOrder.GetLoopDepth(basicBlocks[7]), 1);
Assert.Equal(loopAwareBlockOrder.GetLoopIndex(basicBlocks[0]), -1);
Assert.Equal(loopAwareBlockOrder.GetLoopIndex(basicBlocks[1]), 1);
Assert.Equal(loopAwareBlockOrder.GetLoopIndex(basicBlocks[2]), 1);
Assert.Equal(loopAwareBlockOrder.GetLoopIndex(basicBlocks[3]), 1);
Assert.Equal(loopAwareBlockOrder.GetLoopIndex(basicBlocks[4]), 0);
Assert.Equal(loopAwareBlockOrder.GetLoopIndex(basicBlocks[5]), -1);
Assert.Equal(loopAwareBlockOrder.GetLoopIndex(basicBlocks[6]), 0);
Assert.Equal(loopAwareBlockOrder.GetLoopIndex(basicBlocks[7]), 1);
Assert.Same(loopAwareBlockOrder.NewBlockOrder[0], basicBlocks[0]);
Assert.Same(loopAwareBlockOrder.NewBlockOrder[1], basicBlocks[1]);
Assert.Same(loopAwareBlockOrder.NewBlockOrder[2], basicBlocks[2]);
Assert.Same(loopAwareBlockOrder.NewBlockOrder[3], basicBlocks[4]);
Assert.Same(loopAwareBlockOrder.NewBlockOrder[4], basicBlocks[6]);
Assert.Same(loopAwareBlockOrder.NewBlockOrder[7], basicBlocks[5]);
Dump(basicBlocks, loopAwareBlockOrder);
}
private void DumpTrace(LoopAwareBlockOrder blockOrderAnalysis)
{
var trace = CreateTraceLog();
if (trace == null)
{
return;
}
int index = 0;
foreach (var block in blockOrderAnalysis.NewBlockOrder)
{
if (block != null)
{
trace.Log($"# {index} Block {block} #{block.Sequence}");
}
else
{
trace.Log($"# {index} NONE");
}
index++;
}
trace.Log();
foreach (var block in BasicBlocks)
{
int depth = blockOrderAnalysis.GetLoopDepth(block);
int depthindex = blockOrderAnalysis.GetLoopIndex(block);
trace.Log($"Block {block} #{block.Sequence} -> Depth: {depth} Index: {depthindex}");
}
}
/// <summary>
/// Runs the specified compiler.
/// </summary>
void IMethodCompilerStage.Run()
{
loopAwareBlockOrder = new LoopAwareBlockOrder(this.basicBlocks);
basicBlocks.ReorderBlocks(loopAwareBlockOrder.NewBlockOrder);
if (IsLogging)
DumpTrace();
}
private void OrderBlocks()
{
// don't remove any blocks when the flow control is unusual
if (HasProtectedRegions)
return;
var blockOrderAnalysis = new LoopAwareBlockOrder();
blockOrderAnalysis.PerformAnalysis(BasicBlocks);
BasicBlocks.ReorderBlocks(blockOrderAnalysis.NewBlockOrder);
}
protected override void Run()
{
var blockOrderAnalysis = new LoopAwareBlockOrder();
blockOrderAnalysis.Analyze(BasicBlocks);
var newBlockOrder = blockOrderAnalysis.NewBlockOrder;
newBlockOrder = AddMissingBlocksIfRequired(newBlockOrder);
BasicBlocks.ReorderBlocks(newBlockOrder);
DumpTrace(blockOrderAnalysis);
}
private void OrderBlocks()
{
// don't remove any blocks when the flow control is unusual
if (HasProtectedRegions)
{
return;
}
var blockOrderAnalysis = new LoopAwareBlockOrder();
blockOrderAnalysis.PerformAnalysis(BasicBlocks);
BasicBlocks.ReorderBlocks(blockOrderAnalysis.NewBlockOrder);
}
private void OrderBlocks()
{
//var blockOrderAnalysis = new SimpleTraceBlockOrder(); // faster than others
var blockOrderAnalysis = new LoopAwareBlockOrder();
blockOrderAnalysis.PerformAnalysis(BasicBlocks);
var newBlockOrder = blockOrderAnalysis.NewBlockOrder;
if (HasProtectedRegions)
{
newBlockOrder = AddMissingBlocks(newBlockOrder, true);
}
BasicBlocks.ReorderBlocks(newBlockOrder);
}
private void OrderBlocks()
{
//var blockOrderAnalysis = new SimpleTraceBlockOrder(); // faster than others
var blockOrderAnalysis = new LoopAwareBlockOrder();
blockOrderAnalysis.PerformAnalysis(BasicBlocks);
var newBlockOrder = blockOrderAnalysis.NewBlockOrder;
if (HasProtectedRegions)
{
newBlockOrder = AddMissingBlocks(newBlockOrder, true);
}
BasicBlocks.ReorderBlocks(newBlockOrder);
}
internal static void Dump(BasicBlocks basicBlocks, LoopAwareBlockOrder loopAwareBlockOrder)
{
int index = 0;
foreach (var block in loopAwareBlockOrder.NewBlockOrder)
{
if (block != null)
Console.WriteLine("# " + index.ToString() + " Block " + block.ToString() + " #" + block.Sequence.ToString());
else
Console.WriteLine("# " + index.ToString() + " NONE");
index++;
}
Console.WriteLine();
foreach (var block in basicBlocks)
{
int depth = loopAwareBlockOrder.GetLoopDepth(block);
int depthindex = loopAwareBlockOrder.GetLoopIndex(block);
Console.WriteLine("Block " + block.ToString() + " #" + block.Sequence.ToString() + " -> Depth: " + depth.ToString() + " index: " + depthindex.ToString());
}
}
private void CreateExtendedBlocks()
{
var blockOrder = new LoopAwareBlockOrder(this.basicBlocks);
// The re-ordering is not strictly necessary; however, it reduces "holes" in live ranges.
// Less "holes" increase readability of the debug logs.
//basicBlocks.ReorderBlocks(loopAwareBlockOrder.NewBlockOrder);
// Allocate and setup extended blocks
for (int i = 0; i < basicBlocks.Count; i++)
{
extendedBlocks.Add(new ExtendedBlock(basicBlocks[i], registerCount, blockOrder.GetLoopDepth(basicBlocks[i])));
}
}
