Skip to main content

rohd 0.7.1 copy "rohd: ^0.7.1" to clipboard
rohd: ^0.7.1 copied to clipboard

The Rapid Open Hardware Development (ROHD) framework, a framework for describing and verifying hardware.

0.7.1 #

  • Exclude independently published package sources and the DevTools and VS Code application sources from the ROHD pub.dev archive, while retaining the built DevTools extension and checkout-only workspace configuration.
  • Avoid quadratic memory growth during SystemVerilog synthesis by sharing inline-expression lookup tables and remapping them only once during enum-port lowering, while preserving instance-specific net connections.
  • Avoid repeated synthesis alias-list copies by reusing immutable snapshots and reading signal metadata without materializing aliases, including during array merges.
  • Avoid quadratic SystemVerilog concat driver checks by indexing driver ownership once per optimization pass.

0.7.0 #

Breaking Changes #

  • FiniteStateMachine and State now require Dart enum state identifiers. Replace integer, string, or custom-object identifiers with enum members; update reset and transition targets accordingly. currentState and nextState are now LogicEnum signals (https://github.com/intel/rohd/pull/599).
  • Removed long-deprecated and obsolete APIs: StateMachine, FF, IfBlock, ExternalModule, LogicValues, Logic.bit, valueInt, valueBigInt, hasValidValue, isFloating, LogicValue.length, LogicValue.bit, the LogicValue.from... constructors and LogicValue.from(iterable), global concatenation helpers, gate y output aliases including Add.out, getReceivers, getDrivers, getConditionals, FiniteStateMachine.clk, Pipeline.clk, Port, PairInterface.modify, the PairInterface.clone constructor, LogicStructure.bit, Module.unpreferredName, Module.isUnpreferred, Dumper, WaveDumper, SynthBuilder.top, SynthBuilder.getFileContents(), SynthesisResult.toFileContents() and backend overrides, CustomSystemVerilog, SystemVerilogSynthesizer.instantiationVerilogWithParameters, Module.generateSynth, ModuleTree.hierarchyJSON, NetlistSynthesisResult.toFileContents(), and SystemVerilogService.contentsByName. See the 0.7.0 migration guide for replacements. The legacy Swizzle module and List concatenation aliases remain available but are deprecated in favor of Concat, concat, and rconcat.

Major Features #

  • Added opt-in exactMatch to Case and cases for SystemVerilog-style four-state matching in functional simulation, including exact X/Z matches in expressions and dynamic case items. Existing pessimistic behavior remains the default; generated SystemVerilog is unchanged.
  • Added type-safe [PairInterface] provider/consumer endpoints and role-specific module connection helpers, while preserving the existing untyped API (https://github.com/intel/rohd/issues/613).
  • Added TypedLogicArray<TLogic, TValue> for multidimensional arrays with fixed typed hardware elements and associated semantic values, including typed snapshots and ports, traversal, cloning, net support, and synthesis. Added shaped LogicValueArray and codec-backed TypedLogicValueArray<TValue> values with nested construction, packed LogicValue interoperability, and hardware-array assignment. Existing LogicArray, LogicValueArray, and concrete array port APIs remain available as specializations (https://github.com/intel/rohd/pull/686).
  • Added LogicEnum<T> hardware signals with explicit enum encodings, mapped member assignments, driveable cloning, and SystemVerilog enum generation (https://github.com/intel/rohd/pull/599).
  • Added compact FST waveform capture alongside VCD, with block-based reading and waveform query APIs for incremental access (https://github.com/intel/rohd/pull/671).
  • Added SystemC generation, runtime support, and SystemCService for generating and writing module artifacts. Generated SystemC uses a two-state representation and does not preserve X/Z semantics (https://github.com/intel/rohd/pull/662).
  • Added source tracing and FLC (File-Line-Column) sidecars for cross-probing signals and module instances between Dart source and generated SystemVerilog or SystemC, with an optional standalone HTML report (https://github.com/intel/rohd/pull/707).
  • Added rohd_hierarchy 0.1.1 hierarchy query and netlist adapter APIs, and design-shell APIs using SignalOccurrence and HierarchyOccurrence handles for hierarchy search and connectivity traversal (https://github.com/intel/rohd/pull/707, https://github.com/intel/rohd/pull/716).
  • Added the standalone ROHD Live Debugger with hierarchy browsing, signal inspection, connectivity traversal, source navigation, waveform access, and cross-probing over DTD and VM-service transports (https://github.com/intel/rohd/pull/736).
  • Added rohd-shell, a DTD-attached terminal client for hierarchy, port, signal, and fan-in/fan-out queries, JSON output, and cross-probe selections (https://github.com/intel/rohd/pull/736).
  • Added the ModuleService API, the ModuleServices registry, ArtifactProducingService, ModuleServiceArtifact, SystemVerilogService, and WaveformService for module-scoped generation, capture, and inspection.
  • Added Module.dumpSystemVerilog and Module.dumpWaves convenience methods. dumpSystemVerilog() returns in-memory SystemVerilog; dumpWaves() provides standard VCD capture and replaces the removed generateSynth and WaveDumper APIs.

Improvements #

  • Fixed SystemVerilog addition with carry to preserve the original width of inline operands, including bitwise complements and modulo expressions, and to emit a zero carry for zero-width operands.
  • Added name parameters to the flop and mux convenience helpers; cases already supports naming its generated result (https://github.com/intel/rohd/issues/517).
  • Added concat and rconcat as the preferred concatenation APIs; the legacy aliases are deprecated (https://github.com/intel/rohd/issues/597).
  • Include current signal value and built hierarchy in Logic.toString() diagnostic output (https://github.com/intel/rohd/issues/96).
  • Added LSB-first Logic.split and LogicValue.split helpers for exact arbitrary-width chunking (https://github.com/intel/rohd/issues/236).
  • Warn on accidental non-negative integer truncation in Const and LogicValue.of, with allowTruncation for intentional narrowing (https://github.com/intel/rohd/issues/142).
  • Added arbitrary-rank TypedLogicArray.transpose, including concrete LogicArray and net-array views with live reordered element connections (https://github.com/intel/rohd/issues/427).
  • Added exact int and BigInt base-two logarithm and power-of-two helpers, and migrated FSM state sizing away from floating-point logarithms. ROHD-HCL migration follows its next major-version change (https://github.com/intel/rohd/issues/508).
  • Warn when Simulator.run() completes without registered or injected events (https://github.com/intel/rohd/issues/595).
  • Expanded zero-width Logic and LogicValue coverage across functional simulation, SystemVerilog/Icarus, SystemC, and Node; added isEmpty convenience getters while preserving empty-value composition (https://github.com/intel/rohd/issues/111).
  • Added X/Z optimism and pessimism regression coverage for combinational and sequential conditional controls (https://github.com/intel/rohd/issues/103).
  • Expanded the SystemVerilog module-instantiation guide with external, inline, and custom non-inline SystemVerilog examples (https://github.com/intel/rohd/issues/430).
  • Name Logic.abs() two's-complement intermediates and final values descriptively in generated output (https://github.com/intel/rohd/issues/608).
  • Allow concatenation and subset views to resolve as assignment receivers when safe, including nested partial writes without claiming unselected bits, and merge legal full packed-array/scalar assignments in generated SystemVerilog (https://github.com/intel/rohd/issues/530, https://github.com/intel/rohd/issues/553, and https://github.com/intel/rohd/issues/619).
  • Fixed zero-width SystemC ports and constant bindings to use bindable placeholder types while preserving empty-value reads as zero, including address ports in single-register CSR blocks.
  • Fixed SimCompare.checkSystemCVector to honor explicit clock vectors instead of silently replacing them with a free-running clock. Reusable SystemC executables accept drivenClockNames, and compiled cache keys distinguish clock modes. Automatic clocks remain available when vectors omit clock inputs.
  • Emit child-driven unpacked arrays as nets to avoid unknown values in Icarus 12.0, while retaining variable declarations for procedurally written arrays. Child-driven unpacked outputs use output wire logic by default; explicit object-type configuration remains honored.
  • Fixed procedural reads of enum leaves in typed arrays to convert packed array selections back into the destination enum type.
  • Added rank-zero TypedLogicArray<T, V> construction with shape [], a checked scalar getter, and fromScalar connected views that preserve source ownership. Typed value arrays also support rank-zero snapshots, indexing, and reshaping. Typed ports and synthesis preserve the leaf width without introducing a phantom array index.
  • Added experimental Module.addStructuredInterface and Module.addStructuredPairInterface for directional interface grouping. Multi-field input and output directions become typed LogicStructure ports, singleton directions become direct prefixed ports, and inOuts remain individual ports. Read-only structured-interface bindings retain the source interface, internal clone, and actual directional ports. addInterfaceFrom and addPairInterfaceFrom continue to register a provided target, while addInterfacePorts and addPairInterfacePorts retain flat individual-port behavior.
  • Improved generated synthesis wiring across module boundaries and driver-name selection (https://github.com/intel/rohd/pull/726).
  • Retain whole child-output buses when their slices feed temporary consumer wires, and connect order-preserving packed destinations as a whole rather than as a concatenation of their elements. Explicit split-output names and structure-aware wiring remain preserved. Independently declared, named structure fields can receive child outputs directly, avoiding redundant packed buses and field-slicing assignments in CSR hierarchies.
  • Same-width Logic.zeroExtend now returns the original signal instead of creating a redundant extension (https://github.com/intel/rohd/pull/729).
  • Migrated rohd_source_navigator into its package in preparation for independent publication (https://github.com/intel/rohd/pull/718).
  • Netlist JSON format is now 0.1.0, preserving enum types and encodings on retained netnames using Yosys-style attributes, including constant-driven enum uses (https://github.com/intel/rohd/pull/599).
  • Refined the typed-array hierarchy so LogicArray directly specializes TypedLogicArray<Logic, LogicValue>, and strengthened custom TypedLogicArray cloning to preserve runtime types, codecs, unpacked dimensions, and constructor-only naming prefixes without exposing them as public axis metadata (https://github.com/intel/rohd/pull/686).
  • Expanded TypedLogicArray support for recursively nested typed and ordinary arrays, structures containing array fields, mixed packed/unpacked dimensions, structured net and inout ports, and recursive netlist type metadata. Fixed generated SystemVerilog for array-valued elements to use packed offsets consistent with declarations and module-port connections, avoiding invalid chained selections in Icarus and Verilator (https://github.com/intel/rohd/pull/686).
  • Preserved configured SystemVerilog output object types for nested arrays and added the opt-in iverilogWorkaroundForUnpackedArrayVariables setting for child-driven unpacked array variables that remain unknown in Icarus Verilog 12.0 (https://github.com/intel/rohd/pull/686).
  • LogicArray remains source-compatible for construction and operations. Its value and previousValue now return shape-carrying LogicValueArray instances, which remain LogicValue subtypes; code relying on their exact concrete runtime types may observe this behavior change (https://github.com/intel/rohd/pull/686).
  • Added support for structures with constant leaves when their clone() implementation produces driveable fields, preserving domain-specific constant structures through generic operations.
  • Integrated LogicEnum with generic operations. Enum mappings are preserved through typed operation results, enum members can be used as cases keys, and incompatible enum mappings are rejected.
  • Fixed generic operations to reject incompatible LogicEnum mappings inside structures and typed arrays, and to preserve mapped enum constant reset values in netlist register cells.
  • Pipeline.get, PipelineStageInfo.get, and PipelineStageInfo.getAbs now preserve each identifier's concrete type through stage reconstruction and SSA, allowing structures, typed arrays, enums, and scalar signals in one pipeline. ReadyValidPipeline retains its established multi-signal API and gains the same per-identifier typed access without separate payload pipeline classes.
  • Preserved aggregate structure assignment metadata through synthesis and netlist generation.
  • Fixed SystemVerilog synthesis of internally computed packed logic assigned to packed-array outputs, retaining required intermediate declarations.
  • Upgraded Mux, FlipFlop, Passthrough, mux, flop, cases, selectIndex, and selectFrom to preserve compatible concrete Logic subtypes, including nested LogicArray and TypedLogicArray boundaries. Removed the parallel structure-only operation APIs.
  • Migration: plain Const and LogicNet sources no longer infer driveable outputs for operations that construct hardware. Normalize the source once with Logic.from(...), for example flop(clk, Logic.from(Const(1))) or mux(sel, Logic.from(Const(1)), Logic.from(Const(0))). Use an operation outputGenerator when an explicit output representation is required, including mixed packed and structured cases branches.
  • Migration: type-preserving operations on TypedLogicArray operands now require the identical valueCodec instance. Reuse a shared codec or cross an explicit packed boundary to reinterpret compatible bits.
  • Migration: type-preserving operations reject structure operands with different runtimeTypes, because the output takes the static type of the first operand. Clone the result with clone(name: ...) to keep a subclass type, for example in a negate() that returns the receiver's type, rather than returning a base class.
  • Added public cloneTyped() and namedTyped() conveniences for retaining a receiver's static type. Const.cloneTyped() remains a literal clone; Const.namedTyped() is rejected because a named alias must be driveable.
  • Added configurable waveform timescales, recording windows, and output overwrite policies (https://github.com/intel/rohd/pull/671).
  • Added opt-in DebugSession setup for source tracing, netlist and FLC services, and live waveform recording (https://github.com/intel/rohd/pull/707).
  • Expanded reusable rohd_devtools_widgets components for hierarchy browsing, signal formatting, bit expansion, overlays, help, capture, and cross-probing (https://github.com/intel/rohd/pull/736).
  • Added rohd_waveform 0.1.1 client APIs for hierarchy normalization, repository-backed waveform access, caching, readiness, streaming, computed signals, and sub-field/bit-slice waveforms (https://github.com/intel/rohd/pull/736).

Bug Fixes #

  • Avoid a circular-assignment assertion when merging connected net aliases makes a net-to-net connection redundant during synthesis.

  • Made file-free, retained VCD waveform capture available on web platforms for DartPad and other browser workflows (https://github.com/intel/rohd/issues/273).

  • Preserve four-state z values through procedural assignments and muxes, including SystemVerilog’s bitwise merge behavior for unknown mux controls (https://github.com/intel/rohd/issues/570).

  • Replaced per-wire simulator lifecycle subscriptions with a shared weak wire registry, so discarded elaborations no longer retain callbacks or degrade future simulation ticks (https://github.com/intel/rohd/issues/708).

  • Prevent truncation diagnostics from throwing on non-finite arithmetic intermediates in Node.

  • Fixed default [Case] and [CaseZ] handling of invalid item values: dynamic x and z patterns now drive x, while only literal constant z patterns remain CaseZ wildcards (https://github.com/intel/rohd/issues/102). Opt-in Case.exactMatch instead compares all four states exactly.

  • Fixed downstream [Sequential] blocks to capture edges from upstream [Sequential] outputs during the same simulation tick after their producer completes all assignments, restoring clock-divider behavior and correct jointly driven async-reset release (https://github.com/intel/rohd/issues/191).

  • Omit zero-width ports and their connections from generated SystemVerilog definitions and instantiations, including conditional assignments nested in reset and branch bodies. SystemVerilog vector testbenches also omit scalar zero-width endpoint declarations, connections, stimulus, and checks (https://github.com/intel/rohd/issues/57).

  • Warn when [Sequential] combines asyncReset with a non-constant resetValues driver, which can infer independently timed async set and clear pins in synthesis (https://github.com/intel/rohd/issues/728).

  • Fixed LogicValue arithmetic and comparisons with direct BigInt operands at widths up to the native integer width, preserving unsigned sign-boundary semantics (https://github.com/intel/rohd/pull/319).

  • SystemC implementation matching now includes internal signal declarations and child-module types, preventing distinct hierarchical implementations from being incorrectly merged.

  • Structured Mux output generators now select leaf-by-leaf even when the operands have been widened to Logic, preserving typed layouts and avoiding raw-value writes through domain-specific put overrides.

  • SystemC generation now emits structured mux hierarchies instead of incorrectly treating them as inline scalar gates and omitting their drivers.

  • Fixed a netlist pass that could drop connections to module output ports (https://github.com/intel/rohd/pull/731).

  • Fixed LogicValue.ofRadixString round trips with empty separators and separators containing regular-expression metacharacters (https://github.com/intel/rohd/issues/722).

Issue Housekeeping #

0.6.11 #

0.6.10 #

  • Improved Logic.replicate(1) and same-width signExtend to return the original signal, eliminating redundant replication modules and generated SystemVerilog (https://github.com/intel/rohd/pull/689).
  • Improved simulation performance and generated outputs by avoiding module creation for four-state-safe operations involving Consts, zero shifts, and muxes with constant controls (https://github.com/intel/rohd/issues/429).
  • Enforced that Const values cannot be changed through put or inject, including through another Logic driven by a Const (https://github.com/intel/rohd/issues/486).
  • Added per-Const preferred radix control for generated literals, normalized Const names to reflect their displayed radix, and enhanced LogicValue.toRadixString to omit its width and radix decorator or digit separators (https://github.com/intel/rohd/issues/601).
  • Fixed a bug to prevent stack overflows when synthesizing designs with combinational loops (https://github.com/intel/rohd/pull/680).
  • Improved generated SystemVerilog to collapse contiguous partial array and range assignments into packed slice assignments when safe (https://github.com/intel/rohd/pull/676).
  • Added per-direction configuration of explicit or implicit object and data types for generated SystemVerilog ports. Defaults preserve the existing input logic, output logic, and inout wire declarations (https://github.com/intel/rohd/pull/678, https://github.com/intel/rohd/pull/687).
  • Significantly enhanced ROHD DevTools with embedded and standalone VM connections, live hierarchy and signal inspection, filtering, snapshots and export, and cross-probe integration (https://github.com/intel/rohd/pull/665).
  • Added the rohd_hierarchy package for compact hierarchy dictionaries, canonical occurrence addresses, hierarchy search, and netlist adapters (https://github.com/intel/rohd/pull/653).
  • Added the ROHD VS Code extension with context-aware snippets, Dart Tooling Daemon integration, and source navigation for cross-probing from ROHD viewers (https://github.com/intel/rohd/pull/670).
  • Improved Logic.getRange and slice on filled Consts to return direct constants instead of constructing BusSubset modules (https://github.com/intel/rohd/pull/677).
  • Improved generated SystemVerilog for concatenations to compact adjacent bit selections into legal slice expressions (https://github.com/intel/rohd/pull/674).
  • Improved generated SystemVerilog to collapse a variety of intermediate LogicArrays and net buses (e.g. from bit-blasting, aggregate connections, assignSubset) into inline concatenations on their consuming connections, eliminating unnecessary intermediate declarations, assigns, and net_connects when it is safe to do so (https://github.com/intel/rohd/pull/663).
  • Centralized synthesizer naming so output names in different contexts are more consistent. Generated SystemVerilog signal and instance names may change in designs with name collisions, repeated constants, or mergeable intermediate signals, so tests or downstream scripts that match exact generated identifiers may need updates (https://github.com/intel/rohd/pull/652).

0.6.9 #

0.6.8 #

0.6.7 #

0.6.6 #

  • Added cloneing for Interfaces and Logics and APIs that leverage the new capabilities (https://github.com/intel/rohd/pull/614).
    • Added a new expectation for Interfaces and Logics (and derivative classes) to implement a clone function, to enable better APIs and reuse in various scenarios.
    • Deprecated PairInterface.clone constructor in favor of new clone method on PairInterface instances.
    • Added new addTyped* functions on Module which will create a clone of original source for ports. This also supports LogicStructures as ports.
    • Added new addInterfacePorts and addPairInterfacePorts functions on Module which wrap connectIO and pairConnectIO, respectively, to make adding interfaces on Modules easier and more consistent with creation of other ports.
  • Updated naming of generated SystemVerilog signals (without reserved names) that were part of LogicStructures to include the name of the parent structure as a prefix.
  • Added packed to base Logic, which just returns itself, so that it can safely be called on any Logic without first checking the type.
  • Fixed a bug related to module selection in the ROHD DevTools Extension (https://github.com/intel/rohd/pull/612).

0.6.5 #

0.6.4 #

0.6.3 #

0.6.2 #

0.6.1 #

0.6.0 #

  • Added LogicNet, inOuts, and TriStateBuffer to enable multi-directional wires, ports, and drivers. Includes support for "wire-only" operations supporting multiple drivers.
  • Deprecated CustomSystemVerilog in favor of SystemVerilog, which has similar functionality but supports inOut ports, and collapses all ports into a single ports argument, as well as some other new features like custom definitions and parameter passthroughs.
  • Breaking: ExternalSystemVerilogModule and InlineSystemVerilog now extend SystemVerilog instead of CustomSystemVerilog, meaning the instantiationVerilog API arguments have been modified.
  • Breaking: Increased minimum Dart SDK version to 3.0.0.
  • Breaking: Interface.connectIO has an additional optional named argument for inOutTags. Implementations of Interface which override connectIO will need to be updated.
  • Fixed a bug where expressionlessInputs may not have been honored in non-inline custom SystemVerilog modules.
  • Fixed a bug where in some cases an xor between two LogicValues could cause an exception due to a false width mismatch.
  • Added better checking, error handling, and message when module hierarchy cannot be properly resolved (e.g. self-containing modules, modules within multiple hierarchies).
  • Breaking: Updated APIs for Synthesizer.synthesize and down the stack to use a Function to calculate the instance type of a module instead of a Map look-up table.
  • Added srcConnections API to Logic to make it easier to trace drivers of subtypes of Logic which contain multiple drivers.
  • Improved SystemVerilog generation to be more succinct for array to array assignments.
  • Breaking: Const constructor updated so that specified width takes precedence over the inherent width of a provided LogicValue val.
  • Added flags to support an asyncReset option in places where sequential reset automation was already present.
  • Breaking: Sequential has new added strictness checking when triggers and non-triggers change simultaneously (in the same Simulator tick) when it may be unpredictable how the hardware would synthesize or sample the inputs. In these scenarios, Sequential will interpret affected inputs as X, thus driving Xs on affected outputs instead of just picking an order. Descriptions that properly imply asynchronous resets are predictable and therefore unaffected.
  • Breaking: injected actions in the Simulator now occur in the mainTick phase. This API will generally continue to work as expected and as it always has, but in some scenarios could slightly change the behavior of existing testbenches.
  • Added a new API Simulator.injectEndOfTickAction which behaves similarly to Simulator.injectAction, except it registers the event to occur at the end of the tick rather than in the main phase. This is useful for some specific simulation situations like cosimulation, but not generally expected to be used for "normal" testbench development.
  • Breaking: Simulator.run now yields execution of the Dart event loop prior to beginning the simulation. This makes actions taken before starting the simulation more predictable, but may slightly change behavior in existing testbenches that relied on a potential delay.
  • Improved error and exception messages.
  • Various performance enhancements.
  • Fixed a bug where asynchronous events could sometimes show up late in generated waveforms from WaveDumper.
  • Added support for negative edge triggers to Sequential.multi for cases where synthesis may interpret an inverted posedge as different from a negedge.
  • Fixed a bug where resetValues would not take effect in Pipelines.
  • Fixed a bug where a multi-triggered Sequential may not generate X's if one trigger is valid and another trigger is invalid.
  • Fixed bugs related to array signal discovery during the build process that, while they do not affect functionality or generated SystemVerilog, could provide incomplete information related to the contents of Modules from an API perspective.
  • Fixed bugs where generated SystemVerilog could have parameter declaration or assignment sections that were empty, which is illegal SystemVerilog and would cause build errors (https://github.com/intel/rohd/pull/498).
  • Fixed a bug where sometimes getRange on LogicStructures and LogicArrays could access the wrong set of signals (https://github.com/intel/rohd/pull/499).
  • Add the assignSubset API to Logic and LogicStructure which behave similarly to the already-present API in LogicArray (https://github.com/intel/rohd/pull/502).
  • Added convenience APIs for accessing the original sources external to a Module for inputs and inOuts (https://github.com/intel/rohd/pull/503).
  • Added functionality to LogicValue to enable conversion to and from various different radix strings.
  • Fixed bugs related to the handling of errors which cause the Simulator to halt (https://github.com/intel/rohd/pull/515).

0.5.3 #

0.5.2 #

  • Added APIs for accessing indices of a List<Logic> using another Logic: Logic.selectFrom and List<Logic>.selectIndex (https://github.com/intel/rohd/pull/438).
  • Added/fixed support for compiling ROHD to JavaScript via bug fixes, compile-time arithmetic precision consideration, and testing (https://github.com/intel/rohd/pull/445).
  • Added isZero to LogicValue.
  • Improved Pipeline abstraction via bug fixes, better error checking, improved documentation, and new APIs (https://github.com/intel/rohd/pull/447).
  • Improved performance of construction of Combinational.ssa (https://github.com/intel/rohd/pull/443).
  • Updated Simulator.endSimulation API to return a Future which completes once the simulation has ended (https://github.com/intel/rohd/pull/455).
  • Fixed bugs where certain non-synthesizable function calls on LogicStructures (e.g. for verification) could add additional hardware (which did not affect functionality) and also cause unexpected behavior on previousValue (https://github.com/intel/rohd/issues/457).
  • Fixed bugs where certain APIs on Logic (e.g. changed, previousValue) could have incorrect behavior after a Simulator.reset (https://github.com/intel/rohd/pull/458).
  • Fixed a bug where LogicValue.clog2 was inaccurate in rare scenarios.
  • Fixed a bug that caused a crash when comparing certain LogicValues.
  • Fixed a bug where conversions between BigInts and LogicValues could result in incorrect arithmetic operations.
  • Fixed a bug where FiniteStateMachine-generated mermaid diagrams were missing "default next state" cases (https://github.com/intel/rohd/pull/454).
  • Allowed generated SystemVerilog to contain assignments to z (floating) if explicitly connected to a constant z (https://github.com/intel/rohd/pull/441).

0.5.1 #

  • Fixed bugs and improved controllability around naming of internal signals and collapsing of inlineable functionality, leading to significantly more readable generated SystemVerilog (https://github.com/intel/rohd/pull/439).
  • Fixed a bug where identical module definitions with different reserved definition names would merge incorrectly in generated outputs(https://github.com/intel/rohd/issues/345).
  • Improved organization of port and internal signal declarations in generated outputs.
  • Fixed bugs where generated SystemVerilog could flag lint issues due to unsafe truncation of signals in cases like + and << (https://github.com/intel/rohd/pull/423).

0.5.0 #

  • Added LogicArray for N-dimensional packed and unpacked (and mixed) arrays. Added LogicStructure for grouping sets of related signals together in a convenient way (https://github.com/intel/rohd/pull/375).
  • Added a ConditionalGroup which can group a collection of other Conditionals into one Conditional object.
  • Breaking: some APIs which previously returned ConditionalAssign now return a Conditional, such as the < operator for Logic.
  • Updated LogicValue.of which now accepts a dynamic input and tries its best to build what you're looking for. Added LogicValue.ofIterable to replace the old LogicValue.of.
  • Added previousValue to Logic to make testbench and modelling easier for things like clock edge sampling.
  • Breaking: Modified the way Combinational sensitivities are implemented to improve performance and prevent some types of simulation/synthesis mismatch bugs. Added Combinational.ssa as a method to safely build procedural logic. Combinational will now throw fatal exceptions in cases of "write after read" violations. (https://github.com/intel/rohd/pull/344)
  • Deprecated getReceivers, getDrivers, and getConditionals in always blocks like Combinational and Sequential in favor of simpler and more efficient APIs receivers, drivers, and conditionals.
  • Breaking: shorthand notation APIs for incr, decr, mulAssign, and divAssign have been modified.
  • Replaced IfBlock with If.block (deprecated IfBlock).
  • Replaced StateMachine with FiniteStateMachine (deprecated StateMachine).
  • Added support for multi-trigger (e.g. async reset) to abstractions like FiniteStateMachine and Pipeline. Deprecated clk on FiniteStateMachine and Pipeline.
  • Added ability to generate an FSM diagram in mermaid from a FiniteStateMachine.
  • Added PairInterface to make it easier to build and use simple Interfaces.
  • Breaking: connectIO in Interface now accepts Iterables instead of only Sets.
  • Improved numerous Exceptions throughout to provide more specific information about errors and make them easier to catch and handle.
  • Upgraded some operations to avoid generating unnecessary hardware and SystemVerilog when configured to leave a signal unchanged (e.g. getRange, concat, slice, etc.).
  • Added extension to generate randomized LogicValues from a Random.
  • Added replication operations to LogicValue and Logic.
  • Added equalsWithDontCare to LogicValue for comparisons where invalid bits are "don't-care".
  • Improved timestamps in generated outputs to make timezones apparent.
  • Added the flop function to construct FlipFlops in an easier way.
  • Added the cases function to construct simple Case statements in an easier way.
  • Added APIs for configuring reset and reset values in Sequential and flip flops.
  • Added APIs for adding an enable to flip flops.
  • Implemented a variety of performance enhancements for both build and simulation.
  • Added tryInput and tryOutput to Module and tryPort to Interface to more easily handle conditionally present ports by leveraging Dart's null safety by returning null if the port does not exist (instead of an exception).
  • Added gt and gte to Logic to make APIs more consistent.
  • Added clog2 to LogicValue.
  • Added neq and pow to both Logic and LogicValue.
  • Made LogicValue implement Comparable, enabling things like sorting.
  • Enabled WaveDumper to recursively create necessary directories for specified output paths.
  • Fixed a bug where ports could be created with an empty string as the name (https://github.com/intel/rohd/issues/281).
  • Fixed a bug where generated SystemVerilog for arithmetic shift-right operations would sometimes be incorrect (https://github.com/intel/rohd/issues/295).
  • Fixed a bug where SynthBuilder would not flag an error when run on a Module that hadn't yet been built (https://github.com/intel/rohd/issues/246).
  • Disallowed signals from being connected directly to themselves in a combinational loop.
  • Fixed a bug where non-synthesizable deposits on undriven signals could affect the generated output SystemVerilog by inserting a non-floating constant (https://github.com/intel/rohd/issues/254).
  • Reinstated an accidentally removed exception for when signal width mismatch occurs (https://github.com/intel/rohd/issues/311).
  • Fixed a bug where indexing a constant value could generate invalid SystemVerilog.
  • Fixed a bug where constants and values that could be interpreted as negative 64-bit values would sometimes generate a - sign in output SystemVerilog.
  • Fixed bugs so Ifs that are illegally constructed throw an Exception (https://github.com/intel/rohd/issues/382).
  • Fixed a bug where FiniteStateMachine could create an inferred latch (https://github.com/intel/rohd/pull/390).
  • Fixed an issue where Case statements with multiple matches would throw an Exception instead of driving x on the output, which could cause spurious crashes during glitch simulation (https://github.com/intel/rohd/issues/107).
  • Fixed a number of bugs related to logical, shift, math, and comparison operations related to width and sign interpretation.
  • Fixed a bug where Case and CaseZ would not use the properly edge-sampled value in Sequential blocks (https://github.com/intel/rohd/issues/348).
  • Fixed bugs where logic that is driven by floating signals would sometimes drive z instead of x on outputs (https://github.com/intel/rohd/issues/235).

0.4.2 #

0.4.1 #

0.4.0 #

0.3.2 #

  • Added the StateMachine abstraction for finite state machines.
  • Added support for the modulo % operator.
  • Added ability to register actions to be executed at the end of the simulation.
  • Modified the WaveDumper to write to the .vcd file asynchronously to improve simulation performance while waveform dumping is enabled (https://github.com/intel/rohd/issues/3)

0.3.1 #

0.3.0 #

  • Breaking: Merged LogicValue and LogicValues into one type called LogicValue.
  • Deprecation: Aligned LogicValue to Logic by renaming length to width.
  • Breaking: Logic.put no longer accepts List<LogicValue>; concatenate it together instead.
  • Deprecated Logic.valueInt and Logic.valueBigInt; instead use equivalent functions on Logic.value.
  • Deprecated bit on both LogicValue and Logic; instead just check width.
  • Added ability in LogicValue.toString to decide whether or not to include the width annotation through includeWidth argument.
  • Fixed a bug related to zero-width construction of LogicValues (https://github.com/intel/rohd/issues/90).
  • Fixed a bug where generated constants in SystemVerilog had no width, which can cause issues in some cases (e.g. concatenations) (https://github.com/intel/rohd/issues/89)
  • Added capability to convert binary strings to ints with underscore separators using bin (https://github.com/intel/rohd/issues/56).
  • Added getRange and reversed on Logic and slice on LogicValue to improve consistency.
  • Using slice in reverse-index order now reverses the order.
  • Added the ability to extend signals (e.g. zeroExtend and signExtend) on both Logic and LogicValue (https://github.com/intel/rohd/issues/101).
  • Improved flexibility of IfBlock.
  • Added withSet on LogicValue and Logic to make it easier to assign subsets of signals and values (https://github.com/intel/rohd/issues/101).
  • Fixed a bug where 0-bit signals would sometimes improperly generate 0-bit constants in generated SystemVerilog (https://github.com/intel/rohd/issues/122).
  • Added capability to reserve instance names, as well as provide and reserve definition names, for Modules and their corresponding generated outputs.

0.2.0 #

  • Updated implementation to avoid Iterable.forEach to make debug easier.
  • Added ofBool to LogicValue and LogicValues (https://github.com/intel/rohd/issues/34).
  • Breaking: updated Interface API so that getPorts returns a Map from port names to Logic signals instead of just a list, which makes it easier to work with when names are uniquified.
  • Breaking: removed setPort from Interface. Use setPorts instead.
  • Deprecated legacy global concatenation functions and replaced them with extensions on Lists of certain types including Logic, LogicValue, and LogicValues (https://github.com/intel/rohd/issues/70).
  • Breaking: renamed ExternalModule to ExternalSystemVerilogModule since it is specifically for SystemVerilog.
  • Breaking: made topModuleName a required named parameter in ExternalSystemVerilogModule to reduce confusion.
  • Added simulationHasEnded bool to Simulator.
  • Updated Simulator to allow for injected actions to return Futures which will be awaited.
  • Fixed bug where Simulator warns about maximum simulation time when not appropriate.
  • Fixed a bug where ExternalSystemVerilogModule could enter infinite recursion.
  • Some improvements to SimCompare to properly check values at the end of a tick and support a wider variety of values in Vectors.
  • Fixed a bug related to Sequential signal sampling where under certain scenarios, signals would pass through instead of being flopped (https://github.com/intel/rohd/issues/79).
  • Deprecated a number of from functions and replaced them with of to more closely follow Dart conventions (https://github.com/intel/rohd/issues/72).

0.1.2 #

0.1.1 #

0.1.0 #

  • The first formally versioned release of ROHD.
21
likes
0
points
10.1k
downloads

Documentation

Documentation

Publisher

unverified uploader

Weekly Downloads

The Rapid Open Hardware Development (ROHD) framework, a framework for describing and verifying hardware.

Homepage
Repository (GitHub)
View/report issues

License

unknown (license)

Dependencies

collection, logging, meta, rohd_hierarchy, test, yaml

More

Packages that depend on rohd