public bool TryGetTemplate(string moduleName, ModuleLayout modLayout, out PlacementInfo placement)
{
PlaceTemplate modTemplate;
lock (Templates)
{
if (!Templates.TryGetValue(moduleName, out modTemplate))
{
placement = null;
return(false);
}
}
lock (Converters)
{
if (Converters.TryGetValue(moduleName, out var cons))
{
placement = cons.First(x => x.Ctrl == modLayout).Convert(modTemplate);
return(true);
}
}
placement = null;
return(false);
}
private void displayModuleList(List<IModule> moduleList)
{
if (nestedPaneList == null)
nestedPaneList = new List<StackPanel>();
int size = moduleList.Count;
int rows = (int)Math.Ceiling((decimal)size / ROW_SIZE);
for (int n = 0; n < rows; n++)
{
StackPanel newPanel = new StackPanel();
newPanel.Orientation = Orientation.Horizontal;
nestedPaneList.Add(newPanel);
}
if (moduleList != null && moduleList.Count > 0)
{
for (int i = 0; i < moduleList.Count; i++)
{
IModule module = moduleList[i] as IModule;
// Calcul de la position du ModuleLayout
int position = (int)Math.Ceiling((decimal)(i + 1) / ROW_SIZE) - 1;
// On crée l'objet graphique lié au module, et on lui donne sa classe
ModuleLayout view = new ModuleLayout(module);
nestedPaneList[position].Children.Add(view);
}
}
foreach (StackPanel subPanel in nestedPaneList)
{
modulesPanel.Children.Add(subPanel);
}
}
public bool TryGetTemplate(string moduleName, ModuleLayout modLayout, out List <WirePath> wires)
{
RouteTemplate modTemplate;
lock (Templates)
{
if (!Templates.TryGetValue(moduleName, out modTemplate))
{
wires = null;
return(false);
}
}
lock (Converters)
{
if (Converters.TryGetValue(moduleName, out var cons))
{
wires = cons.First(x => x.Ctrl == modLayout).Convert(modTemplate);
return(true);
}
}
wires = null;
return(false);
}
public void SubscribeToTemplate(string moduleName, ModuleLayout ctrl, FIRRTLNode[] nodeOrder)
{
PlaceTemplateConversion conversion = new PlaceTemplateConversion(ctrl, nodeOrder);
lock (Converters)
{
if (Converters.TryGetValue(moduleName, out var convs))
{
convs.Add(conversion);
}
else
{
Converters.Add(moduleName, new List <PlaceTemplateConversion>()
{
conversion
});
}
}
lock (Templates)
{
if (Templates.TryGetValue(moduleName, out var template))
{
conversion.TemplateUpdated(template);
}
}
}
public static ModuleLayout ReadBin(string path)
{
ModuleLayout module = new ModuleLayout();
using (BinaryReader b_reader = new BinaryReader(File.Open(path, FileMode.Open))) {
module.Read(b_reader);
}
return(module);
}
public static void Main(string[] args)
{
Console.WriteLine("Reading module file...");
modLayout = ReadBin("content\\out.ptptb");
Console.WriteLine($"Done. Read {modLayout.header.signature}.");
Module mod = new Module(modLayout);
Runner.Prepare(mod);
Runner.Run();
Console.ReadLine();
//ArchitectureBuilder builder = new ArchitectureBuilder();
//var a = builder.Build(File.ReadAllText("content/yafn.arch"))[0];
}
private static Droplet[] GetModulesDropletRoutingOrder(Module module, Board board)
{
ModuleLayout inputLayout = module.GetInputLayout();
HashSet <Droplet> dropletInputs = new HashSet <Droplet>(inputLayout.Droplets);
Rectangle[] layoutRectangles = inputLayout.GetAllRectanglesIncludingDroplets();
//Also contains rectangles for droplets but in this case they are considered
//empty rectangles because they aren't filled with droplet yet
HashSet <Rectangle> layoutEmptyRectangles = layoutRectangles.ToHashSet();
HashSet <Rectangle> outsideEmptyRectangle = module.Shape.AdjacentRectangles
.Where(rectangle => rectangle.isEmpty)
.ToHashSet();
Rectangle.ReplaceRectangles(module.Shape, layoutRectangles);
Droplet[] dropletRoutingOrder = new Droplet[dropletInputs.Count];
int dropletIndex = 0;
//A droplet needs to be routed to all interal droplets of the module.
while (dropletInputs.Count > 0)
{
bool hasDropletBeenRouted = false;
foreach (var dropletInput in dropletInputs)
{
if (Board.DoesNotBlockConnectionToSourceEmptyRectangles(dropletInput, outsideEmptyRectangle, layoutEmptyRectangles))
{
hasDropletBeenRouted = true;
dropletRoutingOrder[dropletIndex++] = dropletInput;
dropletInputs.Remove(dropletInput);
//A droplet has now been placed in that module so
//it's rectangle is no longer empty
layoutEmptyRectangles.Remove(dropletInput.Shape);
break;
}
}
if (!hasDropletBeenRouted)
{
throw new InternalRuntimeException("It is not possible to route a droplet to every internal droplet inside a module. This should always be possible." +
"The module is: " + module.ToString());
}
}
Rectangle.ReplaceRectangles(layoutRectangles, module.Shape);
return(dropletRoutingOrder);
}
public Module(ModuleLayout layout)
{
_layout = layout;
int[] labelsCount = new int[_layout.data.sectionsCount];
Array.Clear(labelsCount, 0, _layout.data.sectionsCount);
Label[] labels = new Label[_layout.data.symbolsCount];
for (int i = 0; i < _layout.data.symbolsCount; i++)
{
SymbolLayout symbol = _layout.data.symbols[i];
labelsCount[symbol.sectionIndex]++;
labels[i] = new Label()
{
Name = _layout.data.strings[symbol.nameIndex],
Offset = symbol.blobEntryIndex,
SectionId = symbol.sectionIndex
};
}
Sections = new Section[_layout.data.sectionsCount];
for (int i = 0; i < _layout.data.sectionsCount; i++)
{
SectionLayout section = _layout.data.sections[i];
int ind = 0;
Sections[i] = new Section()
{
Data = _layout.data.blobs[section.blobIndex].data,
Name = _layout.data.strings[section.bankNameIndex],
Labels = new Label[labelsCount[i]]
};
for (int j = 0; j < _layout.data.symbolsCount; j++)
{
if (labels[j].SectionId == i)
{
Sections[i].Labels[ind++] = labels[j];
}
}
}
}
public RouteTemplateConversion(ModuleLayout ctrl, FIRRTLNode[] nodeOrder, FIRIO[] ioOrder)
{
this.Ctrl = ctrl;
this.NodeOrder = nodeOrder;
this.IOOrder = ioOrder;
}
public PlaceTemplateConversion(ModuleLayout ctrl, FIRRTLNode[] nodeOrder)
{
this.Ctrl = ctrl;
this.NodeOrder = nodeOrder;
}
public void SetLayout(ModuleLayout Layout)
{
this.OutputLayout = Layout;
}
