com.newisys.dv
Interface OutputSignal

All Superinterfaces:

Signal

All Known Subinterfaces:

InOutSignal

All Known Implementing Classes:

PortSignalWrapper

public interface OutputSignal
extends Signal

Represents an output signal (or multiple-bit output signal bus). It provides methods that:

• describe when the signal is driven (relative to a clock signal)
• drive the value of the signal
• synchronize relative to the drive edge of the clock signal

When driving a signal, the drive value maybe any of the following types:

• BitVector
• Bit
• Integer
• Double
• String

Drives have several options that control how and when the signal is driven:

Synchronous vs. asynchronous drives

Synchronous drives occur relative to a specified edge of an associated clock signal (plus the associated output skew). There are methods to perform synchronous drives on the current/next clock edge, as well as an arbitrary number of edges into the future. Asynchronous drives do not synchronize relative to the clock, and drive their value at the current time (plus the output skew).

Blocking vs. non-blocking drives

Blocking drives suspend the simulation thread (i.e. block the caller) until the appropriate drive edge is reached. Non-blocking drives schedule the drive for the appropriate edge and return immediately.

Strong vs. soft drives

By default, all drives are strong drives, which means that driving a signal with multiple different values in the same simulation cycle results in a simulation error (specifically, a DVRuntimeException). Soft drives allow such drives to occur without causing a simulation error. If multiple soft drives conflict (and there is no strong drive), the signal is driven to X. (For multiple-bit signals, only the conflicting bits are driven to X.) If one or more soft drives conflict with a strong drive, the value of the strong drive is used.

Range drives

By default, when a multiple-bit signal bus is driven, all bits of the bus are driven together. Range drives allow a specified range of bits in the bus to be driven independently. Bits that are not driven in a given cycle retain their current value. For the purposes of detecting drive conflicts (strong or soft), each bit in the bus is considered independently (i.e. multiple drives of different bits is not a conflict, whereas multiple drives of different values to the same bit or bits is a conflict).

Method Summary

void	drive(Object value) Performs a strong drive of this signal, after synchronizing to the drive edge of the clock, as if by a call to syncDrive().
void	driveAsync(Object value) Performs an immediate strong drive of this signal, without synchronizing to the drive edge of the clock.
void	driveAsyncSoft(Object value) Performs an immediate soft drive of this signal, without synchronizing to the drive edge of the clock.
void	driveDelay(int cycles, Object value) Suspends this thread until the clock for this signal reaches the drive edge the given number of times, then performs a strong drive of the signal.
void	driveDelayNB(int cycles, Object value) Performs a non-blocking strong drive of this signal the given number of cycles into the future.
void	driveDelaySoft(int cycles, Object value) Suspends this thread until the clock for this signal reaches the drive edge the given number of times, then performs a soft drive of the signal.
void	driveDelaySoftNB(int cycles, Object value) Performs a non-blocking soft drive of this signal the given number of cycles into the future.
void	driveNB(Object value) Performs a non-blocking strong drive of this signal.
void	driveRange(BitRange range, Object value) Performs a strong range drive of this signal, after synchronizing to the drive edge of the clock, as if by a call to syncDrive().
void	driveRange(int highBit, int lowBit, Object value) Performs a strong range drive of this signal, after synchronizing to the drive edge of the clock, as if by a call to syncDrive().
void	driveRangeAsync(BitRange range, Object value) Performs an immediate strong range drive of this signal, without synchronizing to the drive edge of the clock.
void	driveRangeAsync(int highBit, int lowBit, Object value) Performs an immediate strong range drive of this signal, without synchronizing to the drive edge of the clock.
void	driveRangeAsyncSoft(BitRange range, Object value) Performs an immediate soft range drive of this signal, without synchronizing to the drive edge of the clock.
void	driveRangeAsyncSoft(int highBit, int lowBit, Object value) Performs an immediate soft range drive of this signal, without synchronizing to the drive edge of the clock.
void	driveRangeDelay(int cycles, BitRange range, Object value) Suspends this thread until the clock for this signal reaches the drive edge the given number of times, then performs a strong range drive of the signal.
void	driveRangeDelay(int cycles, int highBit, int lowBit, Object value) Suspends this thread until the clock for this signal reaches the drive edge the given number of times, then performs a strong range drive of the signal.
void	driveRangeDelayNB(int cycles, BitRange range, Object value) Performs a non-blocking strong range drive of this signal the given number of cycles into the future.
void	driveRangeDelayNB(int cycles, int highBit, int lowBit, Object value) Performs a non-blocking strong range drive of this signal the given number of cycles into the future.
void	driveRangeDelaySoft(int cycles, BitRange range, Object value) Suspends this thread until the clock for this signal reaches the drive edge the given number of times, then performs a soft range drive of the signal.
void	driveRangeDelaySoft(int cycles, int highBit, int lowBit, Object value) Suspends this thread until the clock for this signal reaches the drive edge the given number of times, then performs a soft range drive of the signal.
void	driveRangeDelaySoftNB(int cycles, BitRange range, Object value) Performs a non-blocking soft range drive of this signal the given number of cycles into the future.
void	driveRangeDelaySoftNB(int cycles, int highBit, int lowBit, Object value) Performs a non-blocking soft range drive of this signal the given number of cycles into the future.
void	driveRangeNB(BitRange range, Object value) Performs a non-blocking strong range drive of this signal.
void	driveRangeNB(int highBit, int lowBit, Object value) Performs a non-blocking strong range drive of this signal.
void	driveRangeSoft(BitRange range, Object value) Performs a soft range drive of this signal, after synchronizing to the drive edge of the clock, as if by a call to syncDrive().
void	driveRangeSoft(int highBit, int lowBit, Object value) Performs a soft range drive of this signal, after synchronizing to the drive edge of the clock, as if by a call to syncDrive().
void	driveRangeSoftNB(BitRange range, Object value) Performs a non-blocking soft range drive of this signal.
void	driveRangeSoftNB(int highBit, int lowBit, Object value) Performs a non-blocking soft range drive of this signal.
void	driveSoft(Object value) Performs a soft drive of this signal, after synchronizing to the drive edge of the clock, as if by a call to syncDrive().
void	driveSoftNB(Object value) Performs a non-blocking soft drive of this signal.
com.newisys.verilog.EdgeSet	getOutputEdges() Returns the set of clock edges this signal is driven at.
int	getOutputSkew() Returns the skew (in simulator ticks) relative to the clock edge at which this signal is driven.
void	syncDrive() Suspends this thread until the clock for this signal is at the drive edge.
void	syncDriveDelay(int cycles) Suspends this thread until the clock for this signal reaches the drive edge the given number of times.

Methods inherited from interface com.newisys.dv.Signal

getClock, getName, getSize

Method Detail

getOutputEdges

com.newisys.verilog.EdgeSet getOutputEdges()

Returns the set of clock edges this signal is driven at.

Returns:

the drive edge set

getOutputSkew

int getOutputSkew()

Returns the skew (in simulator ticks) relative to the clock edge at which this signal is driven. The skew can be any non-negative integer, though the use of zero skew is not recommended for output signals. For in/out signals, the skew must be postive.

Returns:

the drive skew

drive

void drive(Object value)

Performs a strong drive of this signal, after synchronizing to the drive edge of the clock, as if by a call to syncDrive().

Parameters:

value - the value to drive

See Also:

syncDrive()

driveNB

void driveNB(Object value)

Performs a non-blocking strong drive of this signal. If the clock for this signal is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). If the clock is not at the drive edge, the drive is queued until that edge (i.e. at next edge time + skew).

Parameters:

value - the value to drive

driveDelay

void driveDelay(int cycles,
                Object value)

Suspends this thread until the clock for this signal reaches the drive edge the given number of times, then performs a strong drive of the signal. If cycles is 1, this method waits for the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). In other words, driveDelay(0, value) is equivalent to drive(value).

Parameters:

cycles - the number of times the drive edge must be observed

value - the value to drive

driveDelayNB

void driveDelayNB(int cycles,
                  Object value)

Performs a non-blocking strong drive of this signal the given number of cycles into the future. If cycles is 1, this method drives the value at the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). In other words, driveDelayNB(0, value) is equivalent to driveNB(value).

Parameters:

cycles - the number of times the drive edge must be observed

value - the value to drive

driveAsync

void driveAsync(Object value)

Performs an immediate strong drive of this signal, without synchronizing to the drive edge of the clock.

Parameters:

value - the value to drive

driveSoft

void driveSoft(Object value)

Performs a soft drive of this signal, after synchronizing to the drive edge of the clock, as if by a call to syncDrive().

Parameters:

value - the value to drive

See Also:

syncDrive()

driveSoftNB

void driveSoftNB(Object value)

Performs a non-blocking soft drive of this signal. If the clock for this signal is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). If the clock is not at the drive edge, the drive is queued until that edge (i.e. at next edge time + skew).

Parameters:

value - the value to drive

driveDelaySoft

void driveDelaySoft(int cycles,
                    Object value)

Suspends this thread until the clock for this signal reaches the drive edge the given number of times, then performs a soft drive of the signal. If cycles is 1, this method waits for the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). In other words, driveDelaySoft(0, value) is equivalent to driveSoft(value).

Parameters:

cycles - the number of times the drive edge must be observed

value - the value to drive

driveDelaySoftNB

void driveDelaySoftNB(int cycles,
                      Object value)

Performs a non-blocking soft drive of this signal the given number of cycles into the future. If cycles is 1, this method drives the value at the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). In other words, driveDelaySoftNB(0, value) is equivalent to driveSoftNB(value).

Parameters:

cycles - the number of times the drive edge must be observed

value - the value to drive

driveAsyncSoft

void driveAsyncSoft(Object value)

Performs an immediate soft drive of this signal, without synchronizing to the drive edge of the clock.

Parameters:

value - the value to drive

driveRange

void driveRange(int highBit,
                int lowBit,
                Object value)

Performs a strong range drive of this signal, after synchronizing to the drive edge of the clock, as if by a call to syncDrive().

Parameters:

highBit - the index of the highest bit to drive

lowBit - the index of the lowest bit to drive

value - the value to drive

See Also:

syncDrive()

driveRange

void driveRange(BitRange range,
                Object value)

Performs a strong range drive of this signal, after synchronizing to the drive edge of the clock, as if by a call to syncDrive().

Parameters:

range - the range of bits to drive

value - the value to drive

See Also:

syncDrive()

driveRangeNB

void driveRangeNB(int highBit,
                  int lowBit,
                  Object value)

Performs a non-blocking strong range drive of this signal. If the clock for this signal is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). If the clock is not at the drive edge, the drive is queued until that edge (i.e. at next edge time + skew).

Parameters:

highBit - the index of the highest bit to drive

lowBit - the index of the lowest bit to drive

value - the value to drive

driveRangeNB

void driveRangeNB(BitRange range,
                  Object value)

Performs a non-blocking strong range drive of this signal. If the clock for this signal is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). If the clock is not at the drive edge, the drive is queued until that edge (i.e. at next edge time + skew).

Parameters:

range - the range of bits to drive

value - the value to drive

driveRangeDelay

void driveRangeDelay(int cycles,
                     int highBit,
                     int lowBit,
                     Object value)

Suspends this thread until the clock for this signal reaches the drive edge the given number of times, then performs a strong range drive of the signal. If cycles is 1, this method waits for the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). In other words, driveRangeDelay(0, value) is equivalent to driveRange(value).

Parameters:

cycles - the number of times the drive edge must be observed

highBit - the index of the highest bit to drive

lowBit - the index of the lowest bit to drive

value - the value to drive

driveRangeDelay

void driveRangeDelay(int cycles,
                     BitRange range,
                     Object value)

Suspends this thread until the clock for this signal reaches the drive edge the given number of times, then performs a strong range drive of the signal. If cycles is 1, this method waits for the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). In other words, driveRangeDelay(0, value) is equivalent to driveRange(value).

Parameters:

cycles - the number of times the drive edge must be observed

range - the range of bits to drive

value - the value to drive

driveRangeDelayNB

void driveRangeDelayNB(int cycles,
                       int highBit,
                       int lowBit,
                       Object value)

Performs a non-blocking strong range drive of this signal the given number of cycles into the future. If cycles is 1, this method drives the value at the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). In other words, driveRangeDelayNB(0, value) is equivalent to driveRangeNB(value).

Parameters:

cycles - the number of times the drive edge must be observed

highBit - the index of the highest bit to drive

lowBit - the index of the lowest bit to drive

value - the value to drive

driveRangeDelayNB

void driveRangeDelayNB(int cycles,
                       BitRange range,
                       Object value)

Performs a non-blocking strong range drive of this signal the given number of cycles into the future. If cycles is 1, this method drives the value at the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). In other words, driveRangeDelayNB(0, value) is equivalent to driveRangeNB(value).

Parameters:

cycles - the number of times the drive edge must be observed

range - the range of bits to drive

value - the value to drive

driveRangeAsync

void driveRangeAsync(int highBit,
                     int lowBit,
                     Object value)

Performs an immediate strong range drive of this signal, without synchronizing to the drive edge of the clock.

Parameters:

highBit - the index of the highest bit to drive

lowBit - the index of the lowest bit to drive

value - the value to drive

driveRangeAsync

void driveRangeAsync(BitRange range,
                     Object value)

Performs an immediate strong range drive of this signal, without synchronizing to the drive edge of the clock.

Parameters:

range - the range of bits to drive

value - the value to drive

driveRangeSoft

void driveRangeSoft(int highBit,
                    int lowBit,
                    Object value)

Performs a soft range drive of this signal, after synchronizing to the drive edge of the clock, as if by a call to syncDrive().

Parameters:

highBit - the index of the highest bit to drive

lowBit - the index of the lowest bit to drive

value - the value to drive

See Also:

syncDrive()

driveRangeSoft

void driveRangeSoft(BitRange range,
                    Object value)

Performs a soft range drive of this signal, after synchronizing to the drive edge of the clock, as if by a call to syncDrive().

Parameters:

range - the range of bits to drive

value - the value to drive

See Also:

syncDrive()

driveRangeSoftNB

void driveRangeSoftNB(int highBit,
                      int lowBit,
                      Object value)

Performs a non-blocking soft range drive of this signal. If the clock for this signal is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). If the clock is not at the drive edge, the drive is queued until that edge (i.e. at next edge time + skew).

Parameters:

highBit - the index of the highest bit to drive

lowBit - the index of the lowest bit to drive

value - the value to drive

driveRangeSoftNB

void driveRangeSoftNB(BitRange range,
                      Object value)

Performs a non-blocking soft range drive of this signal. If the clock for this signal is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). If the clock is not at the drive edge, the drive is queued until that edge (i.e. at next edge time + skew).

Parameters:

range - the range of bits to drive

value - the value to drive

driveRangeDelaySoft

void driveRangeDelaySoft(int cycles,
                         int highBit,
                         int lowBit,
                         Object value)

Suspends this thread until the clock for this signal reaches the drive edge the given number of times, then performs a soft range drive of the signal. If cycles is 1, this method waits for the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). In other words, driveRangeDelaySoft(0, value) is equivalent to driveRangeSoft(value).

Parameters:

cycles - the number of times the drive edge must be observed

highBit - the index of the highest bit to drive

lowBit - the index of the lowest bit to drive

value - the value to drive

driveRangeDelaySoft

void driveRangeDelaySoft(int cycles,
                         BitRange range,
                         Object value)

Suspends this thread until the clock for this signal reaches the drive edge the given number of times, then performs a soft range drive of the signal. If cycles is 1, this method waits for the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). In other words, driveRangeDelaySoft(0, value) is equivalent to driveRangeSoft(value).

Parameters:

cycles - the number of times the drive edge must be observed

range - the range of bits to drive

value - the value to drive

driveRangeDelaySoftNB

void driveRangeDelaySoftNB(int cycles,
                           int highBit,
                           int lowBit,
                           Object value)

Performs a non-blocking soft range drive of this signal the given number of cycles into the future. If cycles is 1, this method drives the value at the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). In other words, driveRangeDelaySoftNB(0, value) is equivalent to driveRangeSoftNB(value).

Parameters:

cycles - the number of times the drive edge must be observed

highBit - the index of the highest bit to drive

lowBit - the index of the lowest bit to drive

value - the value to drive

driveRangeDelaySoftNB

void driveRangeDelaySoftNB(int cycles,
                           BitRange range,
                           Object value)

Performs a non-blocking soft range drive of this signal the given number of cycles into the future. If cycles is 1, this method drives the value at the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method drives the value relative the current edge (i.e. at current time + skew). In other words, driveRangeDelaySoftNB(0, value) is equivalent to driveRangeSoftNB(value).

Parameters:

cycles - the number of times the drive edge must be observed

range - the range of bits to drive

value - the value to drive

driveRangeAsyncSoft

void driveRangeAsyncSoft(int highBit,
                         int lowBit,
                         Object value)

Performs an immediate soft range drive of this signal, without synchronizing to the drive edge of the clock.

Parameters:

highBit - the index of the highest bit to drive

lowBit - the index of the lowest bit to drive

value - the value to drive

driveRangeAsyncSoft

void driveRangeAsyncSoft(BitRange range,
                         Object value)

Performs an immediate soft range drive of this signal, without synchronizing to the drive edge of the clock.

Parameters:

range - the range of bits to drive

value - the value to drive

syncDrive

void syncDrive()

Suspends this thread until the clock for this signal is at the drive edge. If the clock is already at the drive edge, this method returns immediately.

syncDriveDelay

void syncDriveDelay(int cycles)

Suspends this thread until the clock for this signal reaches the drive edge the given number of times. If cycles is 1, this method waits for the next drive edge. If cycles is 0 and the clock is already at the drive edge, this method returns immediately. In other words, syncDriveDelay(0) is equivalent to syncDrive().

Parameters:

cycles - the number of times the drive edge must be observed