* New: In Cumulus/plugins.block.matrix.RegisterMatrix, based on pattern
matching the output of DFF, allow to rebuild and place a matrix of
DFF constituting a RAM.
It finally proven not useful because it is a too naive approach.
Intermediate gates (buf_x2) must be found too. Most of the control
signals have more than 20 sinks so gets splitted by HFNS and lastly,
we would want the decoder to be integrated too, but they are not
regulars.
The right way to do it is to create a generator that build it
then expose it in a way nMigen can understand (not the other way
around, nMigen -> Yosys).
* New: CRL::SubNetNames (in ToolBox), takes a VHDL signal name, vectorized
or not and allow to generated sub-net names from it, with respect to
the original vector name.
Examples:
* machin -> machin_hfns_0, machin_hfns_1, ...
* bidule(3) -> bidule_bit3_hfns_0, bidule_bit3_hfns_1, ...
Makes use of the POSIX regex library to avoid Boost dependencies.
* Bug: In HyperNet_ComponentOccurrences::Locator::progress(), (Collection
locator), the _netOccurrenceLocator (which progess along the various
Net occurrences of the HyperNet) was not in synch with the
_componentOccurrence locator of the current net. It was pointing
to the *next* net occurrence.
The result was the generation of a path for the net commponents
that was incorrect (it was the path of the *next* net occurrence),
and making Occurrence constructor throw an exception.
* Change: In Cell::flattenNets(), DeepNet::_createRoutingPads(),
Occurrence::Occurrence() and UpdateSession, added even more trace
informations.
* Bug: In RoutingPad::setExternalComponent(), we where always forcing
the materialization of the RoutingPad (QuadTree insertion). Now
respect the Go::enableAutoMaterialization() state.
Forcing the materialization is equivalent to having an
UpdateSession. So when creating large amount of RoutingPads it did
result in huge slow down, like in HFNS algorithms.
With this modification we go down from 6h+ to 4m for the ls180.
* New: CRL::restoreNetsdirection() (in ToolBox) that checks the coherency
of all Nets direction through a complete hierarchy of cells.
Stops at Cells flagged "TerminalNetlist".
Directions are rebuilt for all the Cells part of the hierarchy
in a bottom up fashion. It is also checked that Nets have only one
driver (we assume there is no three-state busses).
To sort cells in hierarchical order (bottom up according to their
depth), copy the DepthOrder class from the GDSII driver. Will unify
them later.
exported to the Python interface.
* New: In cumulus/tools/blif2vst.py, add a call to restoreNetsdirection()
before saving.
* Change: In NetBuilder::getPositions(), ordering of source/target points
is now integrated to this function instead of left to the caller.
In case of real (non-symbolic) routing gauge, skrink the ends of
half the wire width.
* Change: In NetBuilderHV::doRp_AutoContacts(), in case of non-METAL1
RoutingPad, put the axis of the segment on the nearest track.
Issue a warning if we have to shift, as it may be a potential
source of routing problems.
* New: Anabatic::Session::getNearestTrackaAxis(), proxy to compute
track positions, knowing the design abutment box.
* Bug: In Katana::PreProcess::propagateCagedConstraints(), when
looking at all the slave components anchoreds on a RoutingPad,
if they do not have an AutoSegment lookup, skip them instead
of crashing.
* New: In cumulus/plugins.block.Block.placeMacro(), new method to
place a macro cell, partly delegating to the Macro block wrapper.
Must be called *after* both core and corona abutment boxes have
been set.
Adjust the macro block position so the METAL2 & METAL3 pins
are exactly on pitch regarding the full routing grid. The reference
being the corona.
A shift, less than one pitch may be applied, leading in some
cases of overlapping abutment boxes. But this shouldn't be a
problem.
The macro to place is designated through a path of instances
names, rooted at the *core* (not the corona). Meaning that the
head instance must be one of the core.
* Change: In cumulus/plugins.chip.Chip, the complete chip I/O pads
plus corona and core placement is moved out from doPnR() and
put into doChipFloorplan(). It is now mandatory to call this
method *before* doPnR().
Those methods are now cleanly separated so we can perform macro
block placement or any inner core floorplaning operations between
them.
* Change: In cumulus/plugins.macro.Macro, instead of creating large
pads for the I/O pins so whatever the block position, they will
be under a grid point, create a simple dogleg to put them on
grid.
To ensure that they are "on grid", the block pins must be
in METAL2 (horizontal E/W) or METAL3 (vertical N/S) and the block
is assumed to be placed so the bottom left corner of it's
abutment box is exactly on one grid point for M2/M3.
This should be done by Block.placeMacro().
* New: In KatanaEngine::exportExternalnets(), for commercial tools to
correctly regenerate the external pins from GDSII files it seems
necessary that all segments needs to have TEXT label. So make them
external components.
* Bug: In PowerRailsPlanes::Rail::doLayout(), in case of non-blockage but
fixed segments (that is, power lines), expand the segment box of one
picth to put blockage on too close neigboring tracks.
* Change: In Manipulator::avoidBlockage(), more accurate computation of
the blocked area for pushing aside the terminal & turn of the non-pref
segment.
* New: In cumulus/plugins.chip.powerplane, build the overall power
grid when there is a dedicated supply layer. Makes vertical
supply stripes and connect them the *horizontal* power rails
inside the blocks (could be in *any* layer).
Stripes positions are determined by the pins createds by
the pads module.
* New: In cumulus/plugins.chip.chip, use the powerplane builder
if the RoutingGauge provides a PowerSupply kind.
* New: In cumulus/plugins.block.configuration, add support for
PowerSupply gauges.
* New: In cumulus/plugins.block.pads, if the gauge provides a
PowerSupply, create north/south border pins for power & ground
to direct the corona to make vertical power strips.
This assume that we are using LibreSOC like I/O pads that
can be connected straight from everywhere in the corona.
First and last 2 stripes are "cap end" and narrower.
Positions and width of the sripes are set through the
configuration parameters:
* "chip.supplyRailWidth"
* "chip.supplyRailPitch"
* Change: In cumulus/plugins.block.spares, now take into account
the "placeArea" parameter.
* Change: In cumulus/plugins.block.bigvia, now have a per metal layer
area that *may* be expanded if it is too narrow to put at least
one cut. Add flags to allow controlled expansion of the metal
plates.
As a security, now raise an exception if no cut can be created.
* New: In EtesianEngine::flattenPower(), this is a duplication of the
KatanaEngine::PowerRails. The new paradigm is that when a Cell
is placed by etesian it's AbstractedSupply flag is set and the
creation of the abstract is taken care of at this point.
Should provide some speedup when Katana process it.
Note that we still need to keep PowerRails at Katana stage for
design that are loaded already placed (no Etesian run).
* New: In EtesianEngine::setPlaceArea(), as the slice spin is imposed
on us by Coloquinte, the bottom slice of the place area *must*
be on a ID oriented slice, that is an even one, relative to the
fully placed area.
* Bug: In EtesianEngine, remove the slice spin detection. The spin
is imposed on us by Coloquinte which always place the bottom
row in ID orientation.
Code should be completly removed in the future, along with
the obsolete AddFeeds (replaced by Placement).
* New: In CRL::RoutingLayerGauge, add a new kind of gauge "PowerSupply"
to flag a layer which is dedicated to routing power supplies.
* New: In AllianceFramework, add management of PowerSupply gauge kind.
Exported in the Python interface.
* New: In Query & QueryStack, add a new stop criterion "stopCellFlags"
based on the flags of the instances master cell. The instance will
still be processed, but not it's childs. Typically used to stop
exploring on "AbstractedSupply" cells.
Exported in the Python interface.
* New: In Cell::Flags, new value "AbstractedSupply" to mark Cells from
which an abstract has been built for supplies & blockages. But *not*
for common nets. Helps reduce the recursion through the hierarchy
when building supply line in FlattenPower.
Export setter/getter in the Python interface.
* New: In Instance, add a "PruneMaster" filter to stop hierarchical
exploration on instances which master cells have at least one of
the given flags set.
* Change: In NetExternalcomponents::isInternal(), use "const Component*"
instead of "Component*".
* Bug: In Cell::Flags, the NoFlags must be *zero*, not *one*! And we
can reclaim that bit for future use.
* Cleanup: In Hurricane::Cell, remove changeQuadTree() related methods.
Fusing various Cell's QuadTree is not a viable idea.
* Cleanup: In Hurricane::Instance, remove no longer used "_flags"
attributes.
* New: In cumulus/plugins.macro.macro.Macro() to encapsulate foreign blocks.
Round their size to an exact number of GCells and a guard of one GCell.
External terminal must be on the periphery and will be made to stick out
in the guard ring. This is sub-optimal for now but provide a workaround
some Katana bad assumptions.
A "perpandicular padding" is also added to terminals to limit the
offgrid related problems. Have to optimize that in conjuction with
Katana.
NOTE: To myself, one more bug uncovered in the Track segments management.
This is really too complex, must find time to re-think and simplify
the whole thing.
* New: In Katana::NegociateWidow::createTrackSegment(), detect offgrid
fixed segments and insert them into tracks directly (as *wide* segment
of two tracks).
* New: In Katana::TrackSegment::create() factory method, check for offgrid
fixed segment and use a TrackSegmentWide (of 2 tracks) for them.
* New: In Katana::TrackSegmentWide CTOR, check if they are used in the
context of an offgrid segment and in that case set the track span
to two. We *do not* manage yet the case for both *wide* and *offgrid*
segments.
* Change: In Katana::PowerRails::Rails::doLayout(), do not expand blockage
rectangles over their real size. Add the guard only for real layers
segments.
* Bug: In Katana::PreProcess::propagateCagedConstraints(), when looking
for the first track index, check for out of bound value (npos).
* Bug: In Katana::Track::addOverlapCost(), before using the overlap
segment indexes, check if we are not in a free hole (get the free
interval from center).
* Bug: In Katana::Track::expandFreeInterval(), the interval was badly
computed if it was included inside segments of another (same) net.
* New: In Anabatic::NetBuilder::_do_1G_1M3(), RoutingPad in METAL3 from
blocks are most likely to be offgrid in real mode, we must account
for that case. When an offgrid METAL3 is found, a strap of METAL2
is added, as it may be less than one pitch, it will be reduced into
METAL3 often.
* New: In Anabatic::NetBuilder::doRp_Access(), Support for offgrid METAL2
is added but not enabled yet. Seems to need more polishing.
* Change: In cumulus/plugins.block.Block.__init__(), assume that a block
is already built only if *all* it's instances are placed. Not some
of them.
* New: In cumulus/plugins/block/configuration, added support for a
placeArea parameter to restrict the placement area further than the
abutment box (see Etesian for the new feature).
* Change: In cumulus/plugins/CoreToChip, no longer adds I/O pads for
core signals that lacks one. Only issue an error message and
continue. More useful for debugging block support.
under the fixed segment, we were using the axis *of the segment*,
but if it is very wide, this is completly off.
Now use the axis of the *track* to get the right GCells impacteds.
* Bug: In KatanaEngine::annotateGlobalGraph(), overlapping blockages or
fixed segments where taken into account as separate ones. This was
making the edge capacity reservation too high. Creating false
zero-capacity edges at some points.
Didn't show up until now because we did not have overlaps.
* Bug: In Anabatic::GCell::updateDensity(), the GoStraight flag is now
set in this function when the density of blockage is above 40%.
(should be parametrized in the future). This is linked with the
Katabatic TrackFixedsegment bug.
* Bug: In Anabatic::GCell::Key::Compare, the densities of the GCell
where sorted in the *wrong* order, that is *less denser first*.
This was making the layer assignment working on it's head.
WTF, how did it ever work.
Also sort on global saturation.
* New: In EtesianEngine, add a "placedArea" attribute to restrict the
placement area to a part only of the whole abutement box. This a
way to exclude some area containing *big* hard block.
The placer terribly slow down when tring to "push aside" cells
from the area taken by the block.
This will be also used to restrict the clock tree covered area.
It is far from optimal but will do for now.
NOTE: The placeArea must be expressed in the coordinate system of
the sub-block to be placed, if one has been defined.
* Change: In Model::connectSubckts(), when trying to lookup the
Hurricane Net from it's Blif name, try first as a VHDL one then
after a Verilog to VHDL translation. Especially useful for bits
of vectorized names ("signal[X]" --> "signal(X)").
* Change: In EtesianEngine::globalPlace(), disable the call to
antennaProtect(). First reason is that, after all, Coloquinte
do not handle so well the resizing of the cells "on the fly",
it overspill the boundaries sometimes. Second reason is that
as we cannot know the routing tree at this stage, we will not
be able to choose the correct points for diode insertions.
We only have a Steiner tree wich may not be the same as a
density driven Dijkstra.
* Change: In Etesian::Area, the Occurrence to the Instances where
not stored in a uniform way. Some where starting from the
placed sub-block, some where starting from the top level
(corona), making their processing (and remembering it) tricky.
Now, they are all expressed from the top cell (corona).
The coordinate system is now systematically the one of the
top block (*not* the block).
Create various overloaded functions EtesianEngine::toCell()
and EtesianEngine::toBlock() to ease Occurrence & coordinate
translations.
* New: In Etesian::Slice::createDiodeUnder(), add a X position hint.
Search is done by going through the whole slice range and
minimizing the distance to the hint. If it starts to be too
slow, we may optimize.
* Bug: In EtesianEngine::toColoquinte(), the placement of the top
level external pins was not taken into account (this at last
explain their weird positioning).
* New: AnabaticEngine::antennaProtect(), new algorithm to avoid
antenna effect. This step must be done *after* global routing
and *before* detailed routing. This way we have access to the
real routing and can mend it (along with the netlist) to
insert diodes at the rigth points.
From the global routing we build clusters (DiodeCluster) of
RoutingPads connected through a set of wire whose total length
is below the antenna effect threshold. Long wires connecting the
clusters are also tagged because we need to put a diode between
them and the first RoutingPad of the cluster. This is to avoid
a long METAL2 wire connecting to the RoutingPad before the diode is
connected through METAL3 (in case of misalignment).
This protection is not even enough. For *very long* wires, we
needs to put *more* than one diode (this is to be implemented).
* New: In Etesian::Configuration add new parameters for antenna
effect management:
* "etesian.diodeName" : the name of the diode cell.
* "etesian.antennaMaxwl" : maximum length above which antenna
effect can occur. Must be the maximum for all the normal
routing layers.
* "etesian.antennaInsertThreshold" : during the placement steps,
threshold for linear disruption at which we will look for
the RSMT and insert diodes.
* New: In EtesianEngine::antennaProtect(), at a designated point
in the placement iteratives step, when the spreading starts to
be significant enough estimate the RSMT length and add a diode
if need be. The diode will be put side by side with the driver
cell. This is done by enlarging the driver cell of the diode
width.
* New: In EtesianEngine::_updatePlacement(), in the final stage,
modify the netlist to connect the diode. The diode will be
put on the side of the cell closest to the driver. This may
alow to make the connexion directly in METAL1 in the future.
* Change: In etesian/Placement.cpp, make the whole placement
structure a persistent attribute of the EtesianEngine so
it can be used afterwards.
Add a post-placement diode insertion feature. Finally
unused as they are added on the fly during placement.
In the Area, add data about the diode tie in the TieLut.
* Change: Add EtesianEnginea::clearColoquinte(), to keep the
post-placement structure while purging the Coloquinte one.
* Change: In cumulus/plugins.block.block, keep the Etesian engine
until the whole P&R is done, so we potentially can exploit
the post-placement datas.
* Bug: In cumulus/plugins.chip.power.GoCb(), for the METAL1 power
and ground wires coming from the standard cell, it was assumed
they where made of Horizontal segments, this is not the case
in FlexLib... So force to consider the plane as Horizontal when
we are processing that plane.
Better solution should be to use Horizontals...
The policy about how to create slots was not completly clear.
Now, only add *pointers* or *references* to class attributes,
never do a "copy by value". Reflect that change in SlotTemplate<>
various partial specializations.
Hammer in your head that in C++ functions templates do not allow
for partial specialization. So write only *one* template for
::getSlot<>() (refdefinition simply got ignoreds, at least with gcc).
* Bug: In Slot, only one template for getSlot<> (see above).
Adjust SlotTemplates<> to provides partial specialization only for:
* "const Data&".
* "Data*".
* "const Data*".
* "Data* const"
* "Record*".
* Bug: In Instance::_getRecord(), suppress slot based on transient
values "XCenter" & "YCenter".
* Bug: In CRL::ToolEngine::_getRecord(), suppress slot "Name" based
on a transient value.
* Change: In ::getRecord(std::list<Elementt>*) (and variant), pass
all elements to ::getSlot() as (const Element*).
* In CRL::GdsStream::operator<<(Cell*), when encountering an *external*
component, try to find a ".pin" layer associated (if not already
in it). Then drive the BOUNDARY & TEXT in it. This way, Cadence/
Calibre seems to be able to recognize them as Pin.
height is a multiple of sliceHeight. Otherwise, in some situations,
fixed cell may peek out of the placement area, triggering
Coloquinte assert (which says that the top of the cell is *above*
the top row).
* New: In cumulus/plugins.block.hfns4.py, perform simple HFNS by breaking
the net into sub-nets of at most 10 sinks (hard-coded for now).
As this method is called *after* the netlist as been virtually
flattened, we have to create the RoutingPad at the top level
ourselves. Sub-nets are created at the Cell top-level (same
approach as for clock synthesis, because there is no smart way
to guess where they should be).
* New: In cumulus/plugins.block.block.py, perform HFNS (#4) *before*
doing placement. To see the real sink count on each net, we must
perform the virtual net flattening first (Cell::flattenNets()).
* Change: In cumulus/plugins.block.configuration, allow the creation
of spare buffer in any cell (instead of only "self.cellPnR").
* Change: In cumulus/plugins.block.spares.Spares.raddTransNet(),
Check if intermediate masterNet exists in Cells before trying
to blindly re-create it.
Jean-Paul Chaput