aboutsummaryrefslogtreecommitdiffstats
path: root/backends/cxxrtl
Commit message (Collapse)AuthorAgeFilesLines
* cxxrtl: make logging a little bit nicer.whitequark2020-05-261-2/+10
|
* cxxrtl: add missing parts of commit 281c9685.whitequark2020-05-261-5/+3
|
* cxxrtl: get rid of -O5 aka `opt_clean -purge` optimization level.whitequark2020-05-221-8/+2
| | | | | | This isn't actually necessary anymore after scheduling was improved, and `clean -purge` disrupts the mapping between wires in the input RTLIL netlist and the output CXXRTL code.
* Reorder cases to avoid fall-through warningXiretza2020-05-071-3/+3
| | | | | | log_assert(false) never returns and thus can't fall through, but gcc doesn't seem to think that far. Making it the last case avoids the problem entirely.
* Add YS_FALLTHROUGH macro to mark case fall-throughXiretza2020-05-071-0/+6
| | | | | C++17 introduced [[fallthrough]], GCC and clang had their own vendored attributes before that. MSVC doesn't seem to have such a warning at all.
* cxxrtl: Round up constant widthDavid Shah2020-04-251-1/+1
| | | | Signed-off-by: David Shah <dave@ds0.me>
* cxxrtl: use `cxxrtl_` prefix rather than `cxxrtl.`whitequark2020-04-241-45/+45
| | | | | The former prefix does not need to be escaped in Verilog, unlike the latter, and the Yosys convention is to use the former.
* cxxrtl: improve printing of narrow memories.whitequark2020-04-241-3/+4
|
* cxxrtl: fix handling of parametric modules with large parameters.whitequark2020-04-241-1/+1
| | | | These have a `$paramod$` prefix, not `$paramod\\`.
* cxxrtl: keep the memory write queue sorted on insertion.Asu2020-04-221-3/+5
| | | | | | | Strategically inserting the pending memory write in memory::update to keep the queue sorted allows us to skip the queue sort in memory::commit. The Minerva SRAM SoC runs ~7% faster as a result.
* cxxrtl: run edge detectors only once in eval().whitequark2020-04-221-6/+22
| | | | As a result, Minerva SRAM SoC runs ~15% faster.
* cxxrtl: add an unsupported knob for manipulating clock trees.whitequark2020-04-221-0/+18
| | | | | | | | | This is quite possibly the worst way to implement this, but it does work for a subset of well-behaved designs, and can be used to measure how much performance is lost simulating the inactive edge of a clock. It should be replaced with a clock tree analyzer generating safe code once it is clear how should such a thing look like.
* cxxrtl: use log_id() where appropriate. NFC.whitequark2020-04-211-4/+4
|
* cxxrtl: add (*cxxrtl.{comb,sync}*) annotations on black box outputs.whitequark2020-04-211-65/+186
| | | | | | | | | | | | | | | | | | | | | | If the annotations are not used, this commit does not alter semantics at all, other than removing elision of outputs of black box cells. (Elision of such outputs is expected to be too rare to have any noticeable benefit, and the implementation was somewhat of a hack.) The (* cxxrtl.comb *) annotation alters the semantics of the output of the black box it is applied to such that, if the black box converges immediately, no additional delta cycle is necessary to propagate the computed combinatorial value upwards in hierarchy. The (* cxxrtl.sync *) annotation alters the semantics of the output of the black box it is applied to such as to remove any uses of the black box by the wires connected to this output, and break false feedback arcs arising from conservative modeling of dependencies of the black box. Although currently these attributes are only recognized on black boxes, if separate compilation is added in the future, it could also emit and consume them.
* cxxrtl: s/sync_{wire,type}/edge_{wire,type}/. NFC.whitequark2020-04-211-23/+23
| | | | | | | The attribute for this is called (* cxxrtl.edge *), and there is a planned attribute (* cxxrtl.sync *) that would cause blackbox cell outputs to be added to sync defs rather than comb defs. Rename the edge detector related stuff to avoid confusion.
* cxxrtl: use one delta cycle for immediately converging netlists.whitequark2020-04-212-11/+21
| | | | | | | | | | | If it is statically known that eval() will converge in one delta cycle (that is, the second commit() will always return `false`) because the design contains no feedback or buffered wires, then there is no need to run the second delta cycle at all. After this commit, the case where eval() always converges immediately is detected and the second delta cycle is omitted. As a result, Minerva SRAM SoC runs ~25% faster.
* cxxrtl: add -O6, a shortcut for running `proc; flatten`.whitequark2020-04-211-4/+14
| | | | | | | People judge a compiler backend by the first impression, and the metric they judge it for is speed. -O6 does severely impact debuggability, but it provides equally massive gains in performance, so use it by default.
* cxxrtl: unbuffer module input wires.whitequark2020-04-211-31/+61
| | | | | | | | Module input wires are never set by the module, so it is unnecessary to buffer them. Although important for all inputs, this is especially critical for clocks, since after this commit, hierarchy levels no longer add delta cycles. As a result, Minerva SRAM SoC runs ~73% faster when flattened, and ~264% (!!) faster when hierarchical.
* cxxrtl: simplify generated edge detection logic.whitequark2020-04-211-56/+29
| | | | | | | | | This commit changes the way edge detectors are represented in generated code from a variable that is set in commit() and reset in eval() to a function that considers .curr and .next of the clock wire. Behavior remains the same. Besides being simpler to generate and providing more opportunities for optimization, this commit paves way for unbuffering module inputs.
* cxxrtl: localize wires with multiple comb drivers, too.whitequark2020-04-211-32/+31
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Before this commit, any wire that was not driven by an output port of exactly one comb cell would not be localized, even if there were no feedback arcs through that wire. This would cause the wire to become buffered and require (often quite a few) extraneous delta cycles during evaluation. To alleviate this problem, -O5 was running `splitnets -driver`. However, this solution was mistaken. Because `splitnets -driver` followed by `opt_clean -purge` would produce more nets with multiple drivers, it would have to be iterated to fixpoint. Moreover, even if this was done, it would not be sufficient because `opt_clean -purge` does not currently remove wires with the `\init` attribute (and it is not desirable to remove such wires, since they correspond to registers and may be useful for debugging). The proper solution is to consider the condition in which a wire may be localized. Specifically, if there are no feedback arcs through this wire, and no part of the wire is driven by an output of a sync cell, then the wire holds no state and is localizable. After this commit, the original condition for not localizing a wire is replaced by a check for any sync cell driving it. This makes it unnecessary to run `splitnets -driver` in the majority of cases to get a design with no buffered wires, and -O5 no longer includes that pass. As a result, Minerva SRAM SoC no longer has any buffered wires, and runs ~27% faster. In addition, this commit prepares the flow graph for introduction of sync outputs of black boxes. Co-authored-by: Jean-François Nguyen <jf@lambdaconcept.com>
* cxxrtl: detect buffered comb wires, not just feedback wires.whitequark2020-04-211-5/+40
| | | | | | | | | | Any buffered combinatorial wires (including, as a subset, feedback wires) will prevent the design from always converging in one delta cycle. Before this commit, only feedback wires were detected. After this commit, any buffered combinatorial wires, including feedback wires, are detected. Co-authored-by: Jean-François Nguyen <jf@lambdaconcept.com>
* cxxrtl: provide attributes to black box factories, too.whitequark2020-04-192-49/+57
| | | | | | | | | Both parameters and attributes are necessary because the parameters have to be the same between every instantiation of the cell, but attributes may well vary. For example, for an UART PHY, the type of the PHY (tty, pty, socket) would be a parameter, but configuration of the implementation specified by the type (socket address) would be an attribute.
* cxxrtl: add templated black box support.whitequark2020-04-181-16/+193
|
* cxxrtl: make eval() and commit() inline in blackboxes.whitequark2020-04-181-82/+103
| | | | | This change is a preparation for template blackboxes. It has no effect on current generated code.
* cxxrtl: add simple black box support.whitequark2020-04-182-70/+311
| | | | | | | This commit adds support for replacing RTLIL modules with CXXRTL black boxes. Black box port widths may not depend on the parameters with which it is instantiated (yet); the parameters may only be used to change the behavior of the black box.
* cxxrtl: use ID::X instead of ID(X). NFC.whitequark2020-04-181-107/+107
|
* cxxrtl: correctly handle `sync always` rules.whitequark2020-04-171-3/+13
| | | | Fixes #1948.
* cxxrtl: make ROMs writable, document memory::operator[].whitequark2020-04-162-4/+6
| | | | | | | | | | | There is no practical benefit from using `const memory` for ROMs; it uses an std::vector internally, which prevents contemporary compilers from constant-propagating ROM contents. (It is not clear whether they are permitted to do so.) However, there is a major benefit from using non-const `memory` for ROMs, which is the ability to dynamically fill the ROM for each individual simulation.
* cxxrtl: fix misleading example, caution about race conditions.whitequark2020-04-161-4/+13
| | | | Fixes #1944.
* cxxrtl: remove inaccurate comment. NFC.whitequark2020-04-161-2/+0
|
* cxxrtl: Fix handling of unclocked memory read portsDavid Shah2020-04-141-2/+3
| | | | Signed-off-by: David Shah <dave@ds0.me>
* Merge pull request #1922 from whitequark/write_cxxrtl-disconnected-outputswhitequark2020-04-141-0/+2
|\ | | | | write_cxxrtl: ignore disconnected module ports
| * write_cxxrtl: ignore disconnected module ports.whitequark2020-04-141-0/+2
| | | | | | | | | | | | E.g. port `q` in `submod x(.p(p), .q());`. Fixes #1920.
* | write_cxxrtl: enable separate compilation.whitequark2020-04-141-9/+81
|/ | | | | | This commit makes it possible to use several cxxrtl-generated files in one application, as well as compiling cxxrtl-generated code as a separate compilation unit.
* write_cxxrtl: add basic documentation.whitequark2020-04-091-1/+16
|
* write_cxxrtl: add support for $dlatch and $dlatchsr cells.whitequark2020-04-091-3/+16
| | | | Also, fix codegen for $dffe and $adff.
* write_cxxrtl: add support for $sr cell.whitequark2020-04-091-27/+35
| | | | | | Also, fix the semantics of SET/CLR inputs of the $dffsr cell, and fix the scheduling of async FF cells to consider ARST/SET/CLR->Q as a forward combinatorial arc.
* write_cxxrtl: add support for $slice and $concat cells.whitequark2020-04-091-1/+16
|
* write_cxxrtl: improve writable memory handling.whitequark2020-04-092-65/+87
| | | | | | This commit reduces space and time overhead for writable memories to O(write port count) in both cases; implements handling for write port priorities; and simplifies runtime representation of memories.
* write_cxxrtl: add support for hierarchical designs.whitequark2020-04-091-18/+107
| | | | | | | | | | | Hierarchical design simulations are generally much slower, but this comes with a major increase in flexibility: 1. Since the `flatten` pass currently does not support flattening of designs with processes, this is the only way to simulate such designs with cxxrtl. 2. Support for hierarchy paves way for simulation black boxes, which are necessary for e.g. replacing PHYs with C++ code that integrates with the host system.
* write_cxxrtl: avoid undefined behavior on out-of-bounds memory access.whitequark2020-04-092-46/+78
| | | | | | | | | | After this commit, if NDEBUG is not defined, out-of-bounds accesses cause assertion failures for reads and writes. If NDEBUG is defined, out-of-bounds reads return zeroes, and out-of-bounds writes are ignored. This commit also adds support for memories that start with a non-zero index (`Memory::start_offset` in RTLIL).
* write_cxxrtl: statically schedule comb logic and localize wires.whitequark2020-04-092-68/+368
| | | | | | This results in further massive gains in performance, modest decrease in compile time, and, for designs without feedback arcs, makes it possible to run eval() once per clock edge in certain conditions.
* write_cxxrtl: elide wires for results of comb cells used once.whitequark2020-04-091-35/+359
| | | | | This results in massive gains in performance, equally massive reduction in compile time, and improved readability.
* write_cxxrtl: new backend.whitequark2020-04-093-0/+2010
This commit adds a basic implementation that isn't very performant but implements most of the planned features.