Closes the specified timescope, returns a map of wires to values of any signals that need to be updated.

Logs a peek operation for later checking.

Logs a poke operation for later checking. Returns whether to execute it, based on priorities compared to other active pokes.

Returns the stack trace elements of parent threads. If currently in the root thread, returns empty. TODO: refactor this, figure out how to do this in a structurally cleaner way

Returns set of clocks associated with sinks of the signal

Returns set of clocks associated with sources of the signal

Returns the value associated with the key in a per-test map.

Creates a new timescope in the current thread.

Returns the current value on a wire. If stale is true, returns the current combinational value (after previous pokes have taken effect). If stale is false, returns the value at the beginning of the current cycle.

Read the value of a clock.

Writes a value to a writable wire. Throws an exception if write is not writable.

Writes a value to a clock.

Runs of tests are wrapped in this, for any special setup/teardown that needs to happen. Takes the test function, which takes the module used as the testing interface. TesterContext setup is done externally.

Internal API

Runs the specified threads, blocking this thread while those are running. Newly formed threads or unblocked join threads will also run. Returns a list of threads run (either passed in, newly forked, or joined) that are waiting on a clock edge.

TODO: uses shared schedule state, as an optimization (so that control doesn't need to return to the driver thread between runs. But control still needs to return to the calling thread between timesteps. TODO: this provides a separation which isolates the threading infrastructure from clock control, but there are other structures which accomplish the same thing.

Invokes the thread scheduler, which should be done anytime a thread needs to pass time. Prior to this call: caller should add itself to the blocked / joined threads list (unless terminating). After this call: caller should block on its semaphore (unless terminating). currentThread will no longer be valid.

Unblocks the next thread to be run, possibly also also stepping time via advanceTime(). When there are no more active threads, unblocks the driver thread via driverSemaphore.

Sets the timeout of the clock: the number of cycles the clock can advance without some non-nop poke operation. Setting cycles=0 disables the timeout. Setting cycles=1 means every cycle must have some non-nop poke operation. Resets the idle counter associated with the specified clock.

Sets the value associated with a key in a per-test map.

Advances the target clock by one cycle.

Called on thread completion to remove this thread from the running list. Does not terminate the thread, does not schedule the next thread.

Starts a new timestep, checking if there were any conflicts on the previous timestep (and throwing exceptions if there were).