public override void BlockUsedResources()
{
foreach (TCLRoutingTreeNode node in RoutingTree.GetAllRoutingNodes().Where(n => !n.VirtualNode))
{
node.Tile.BlockPort(node.Port,Tile.BlockReason.OccupiedByMacro);
}
}
public void SetPins()
{
foreach (TCLRoutingTreeNode node in RoutingTree.GetAllRoutingNodes().Where(n => !n.VirtualNode))
{
Tile t = node.Tile;
foreach (Slice s in t.Slices)
{
bool inport = s.PortMapping.IsSliceInPort(node.Port);
bool outport = s.PortMapping.IsSliceOutPort(node.Port);
if ((inport || outport) && node.Port.Name.Contains('_'))
{
NetPin pin = null;
if (inport)
{
pin = new NetInpin();
}
else
{
pin = new NetOutpin();
}
pin.SlicePort = node.Port.Name.Substring(node.Port.Name.LastIndexOf('_'));
pin.InstanceName = s.SliceName;
bool pinExistsAlready = NetPins.FirstOrDefault(np => np.InstanceName.Equals(pin.InstanceName) && np.SlicePort.Equals(pin.SlicePort)) != null;
if (!pinExistsAlready)
{
Add(pin);
}
}
}
}
}
public void UnflattenNet()
{
List <TCLRoutingTreeNode> nodeQueue = new List <TCLRoutingTreeNode>(RoutingTree.Root.Children);
NetOutpin outPin = (NetOutpin)NetPins.First(np => np is NetOutpin);
Tile rootTile = FPGA.FPGA.Instance.GetTile(outPin.TileName);
TCLRoutingTreeNode newRoot = nodeQueue.FirstOrDefault(n =>
n.Tile.Location.Equals(rootTile.Location) &&
rootTile.GetSliceByName(outPin.SliceName).PortMapping.IsSliceOutPort(outPin.SlicePort));
nodeQueue.Remove(newRoot);
NodeNet = false;
RoutingTree.Root = newRoot;
// try to assign each node to parent
while (nodeQueue.Count > 0)
{
foreach (TCLRoutingTreeNode node in RoutingTree.GetAllRoutingNodes())
{
bool addedNodes = false;
// stay on tile
TCLRoutingTreeNode nodeOnThisTile = nodeQueue.Find(n =>
n.Tile.Location.Equals(node.Tile.Location) &&
n.Tile.SwitchMatrix.Contains(node.Port, n.Port));
if (nodeOnThisTile != null)
{
node.Children.Add(nodeOnThisTile);
nodeQueue.Remove(nodeOnThisTile);
addedNodes = true;
break;
}
// leave tile
foreach (Location loc in Navigator.GetDestinations(node.Tile, node.Port))
{
// look for next hop on loc.Tile
TCLRoutingTreeNode nodeOnOtherTile = nodeQueue.Find(n =>
n.Tile.Location.Equals(loc.Tile.Location) &&
n.Tile.SwitchMatrix.Contains(loc.Pip, n.Port));
if (nodeOnOtherTile != null)
{
node.Children.Add(nodeOnOtherTile);
nodeQueue.Remove(nodeOnOtherTile);
addedNodes = true;
break;
}
}
if (addedNodes)
{
break;
}
}
}
}
public void FlattenNet()
{
// we do not need to overwrite TCLRoutingTree (which is only s very flat class)
TCLRoutingTreeNode newRoot = new TCLRoutingTreeNode(null, null);
newRoot.VirtualNode = true;
// we can ignore virtual nodes as the new root will be the virtual new node
foreach (TCLRoutingTreeNode node in RoutingTree.GetAllRoutingNodes().Where(n => !n.VirtualNode))
{
newRoot.Children.Add(node);
node.Parent = newRoot;
}
// clear children after iterating over GetAllRoutingNodes, otherwise this will change the result fromGetAllRoutingNodes
foreach (TCLRoutingTreeNode node in newRoot.Children)
{
node.Children.Clear();
}
NodeNet = true;
RoutingTree.Root = newRoot;
}
public StatServer()
{
listener = new HttpListener();
routingTree = new RoutingTree();
InitializeRoutingTree();
}
public void RoutingTestMethod()
{
// arrange
RoutingTree routingTree = new RoutingTree();
string endpoint = "123.4.5.6:7070";
string timestampString = "2017-01-22T15:11:12Z";
DateTime timestamp = DateTime.Parse(timestampString).ToUniversalTime();
string name = "player1";
string requestBody = "someBody";
int[,] countMatrix = new int[, ]
{
{ -1, 0 },
{ 100, 50 },
{ 27, 27 }
};
routingTree.AddRule(
"PUT/servers/?endpoint/info",
param =>
{
Assert.AreEqual(endpoint, param["?endpoint"]);
Assert.AreEqual(requestBody, param["requestBody"]);
return(new ApiResponse());
});
routingTree.AddRule(
"PUT/servers/?endpoint/matches/?timestamp",
param =>
{
Assert.AreEqual(endpoint, param["?endpoint"]);
Assert.AreEqual(timestamp, param["?timestamp"]);
Assert.AreEqual(requestBody, param["requestBody"]);
return(new ApiResponse());
});
routingTree.AddRule(
"GET/servers/info",
param =>
{
Assert.AreEqual(requestBody, param["requestBody"]);
return(new ApiResponse());
});
routingTree.AddRule(
"GET/servers/?endpoint/info",
param =>
{
Assert.AreEqual(endpoint, param["?endpoint"]);
Assert.AreEqual(requestBody, param["requestBody"]);
return(new ApiResponse());
});
routingTree.AddRule(
"GET/servers/?endpoint/stats",
param =>
{
Assert.AreEqual(endpoint, param["?endpoint"]);
Assert.AreEqual(requestBody, param["requestBody"]);
return(new ApiResponse());
});
routingTree.AddRule(
"GET/servers/?endpoint/matches/?timestamp",
param =>
{
Assert.AreEqual(endpoint, param["?endpoint"]);
Assert.AreEqual(timestamp, param["?timestamp"]);
Assert.AreEqual(requestBody, param["requestBody"]);
return(new ApiResponse());
});
routingTree.AddRule(
"GET/players/?name/stats",
param =>
{
Assert.AreEqual(name, param["?name"]);
Assert.AreEqual(requestBody, param["requestBody"]);
return(new ApiResponse());
});
routingTree.AddRule(
"GET/reports/recent-matches/?count",
param =>
{
Assert.AreEqual(countMatrix[0, 1], param["?count"]);
Assert.AreEqual(requestBody, param["requestBody"]);
return(new ApiResponse());
});
routingTree.AddRule(
"GET/reports/best-players/?count",
param =>
{
Assert.AreEqual(countMatrix[1, 1], param["?count"]);
Assert.AreEqual(requestBody, param["requestBody"]);
return(new ApiResponse());
});
routingTree.AddRule(
"GET/reports/popular-servers/?count",
param =>
{
Assert.AreEqual(countMatrix[2, 1], param["?count"]);
Assert.AreEqual(requestBody, param["requestBody"]);
return(new ApiResponse());
});
// act
string[] urls = new string[]
{
"PUT/servers/" + endpoint + "/info",
"PUT/servers/" + endpoint + "/matches/" + timestampString,
"GET/servers/info",
"GET/servers/" + endpoint + "/info",
"GET/servers/" + endpoint + "/stats",
"GET/servers/" + endpoint + "/matches/" + timestampString,
"GET/players/" + name + "/stats",
"GET/reports/recent-matches/" + countMatrix[0, 0],
"GET/reports/best-players/" + countMatrix[1, 0],
"GET/reports/popular-servers/" + countMatrix[2, 0]
};
// assert
foreach (var url in urls)
{
Assert.AreEqual(HttpStatusCode.OK, routingTree.Route(url, requestBody).Status);
}
}
