API Reference

Domain-Specific Language API

Data and Constraints

vsc.attrs.attr(t)

Wraps a recognized datatype as a non-rand field

vsc.attrs.rand_attr(t)

Wraps a VSC datatype, or recognized datatype, as a rand field

class vsc.constraints.constraint_t(c)

constraint_mode(en)

set_model(m)

elab()

class vsc.constraints.dynamic_constraint_t(c)

set_model(m)

class call_closure(c, *args, **kwargs)

vsc.constraints.dynamic_constraint(c)

vsc.constraints.constraint(c)

class vsc.constraints.weight(val, w)

vsc.constraints.dist(lhs, weights)

Applies distribution weights to the specified field

class vsc.constraints.if_then(e)

class vsc.constraints.else_if(e)

class vsc.constraints.else_then_c

class vsc.constraints.implies(e)

vsc.constraints.soft(e)

vsc.constraints.unique(*args)

class vsc.constraints.forall(target_type)

class vsc.constraints.foreach(l, it=None, idx=None)

class idx_term_c(index)

to_expr()

class it_term_c(em)

to_expr()

vsc.constraints.solve_order(before, after)

vsc.rand_obj.randobj(*args, **kwargs)

vsc.rand_obj.generator(T)

Mark a class as a generator

vsc.types.unsigned(v, w=-1)

vsc.types.signed(v, w=-1)

class vsc.types.expr(em)

bin_expr(op, rhs)

inside(rhs)

outside(rhs)

not_inside(rhs)

class vsc.types.dynamic_constraint_proxy(em)

class vsc.types.expr_subscript(em)

class vsc.types.rng(low, high)

class vsc.types.rangelist(*args)

clear()

extend(ranges)

append(a)

vsc.types.to_expr(t)

class vsc.types.field_info(is_composite=False)

Model-specific information about the field

set_is_rand(is_rand)

class vsc.types.type_base(width, is_signed, i=0)

Base type for all primitive-type fields that participate in constraints

get_model()

build_field_model(name)

to_expr()

property rand_mode

property val

get_val()

set_val(val)

bin_expr(op, rhs)

inside(rhs)

outside(rhs)

not_inside(rhs)

clone()

class vsc.types.type_bool(i=False)

Base class for boolean fields

build_field_model(name)

get_val()

Gets the field value

set_val(val)

Sets the field value

class vsc.types.type_enum(t, i=None)

Base class for enumerated-type fields

build_field_model(name)

get_val()

Returns the enum id

set_val(val)

Sets the enum id

class vsc.types.enum_t(t, i=None)

Creates a non-random enumerated-type attribute

class vsc.types.rand_enum_t(t, i=None)

Creates a random enumerated-type attribute

class vsc.types.bit_t(w=1, i=0)

Creates an unsigned arbitrary-width attribute

class vsc.types.bool_t(i=False)

Creates a boolean field

class vsc.types.uint8_t(i=0)

Creates an unsigned 8-bit attribute

class vsc.types.uint16_t(i=0)

Creates an unsigned 16-bit attribute

class vsc.types.uint32_t(i=0)

Creates an unsigned 32-bit attribute

class vsc.types.uint64_t(i=0)

Creates an unsigned 64-bit attribute

class vsc.types.rand_bit_t(w=1, i=0)

Creates a random unsigned arbitrary-width attribute

class vsc.types.rand_uint8_t(i=0)

Creates a random unsigned 8-bit attribute

class vsc.types.rand_uint16_t(i=0)

Creates a random unsigned 16-bit attribute

class vsc.types.rand_uint32_t(i=0)

Creates a random unsigned 32-bit attribute

class vsc.types.rand_uint64_t(i=0)

Creates a random unsigned 64-bit attribute

class vsc.types.int_t(w=32, i=0)

Creates a signed arbitrary-width attribute

class vsc.types.int8_t(i=0)

Creates a signed 8-bit attribute

class vsc.types.int16_t(i=0)

Creates a signed 16-bit attribute

class vsc.types.int32_t(i=0)

Creates a signed 32-bit attribute

class vsc.types.int64_t(i=0)

Creates a signed 64-bit attribute

class vsc.types.rand_int_t(w=32, i=0)

Creates a random signed arbitrary-width attribute

class vsc.types.rand_int8_t(i=0)

Creates a random signed 8-bit attribute

class vsc.types.rand_int16_t(i=0)

Creates a random signed 16-bit attribute

class vsc.types.rand_int32_t(i=0)

Creates a random signed 32-bit attribute

class vsc.types.rand_int64_t(i=0)

Creates a random signed 64-bit attribute

class vsc.types.list_t(t, sz=0, is_rand=False, is_randsz=False, init=None)

get_model()

build_field_model(name)

property size

property sum

property product

append(v)

extend(v)

clear()

to_expr()

class vsc.types.rand_list_t(t, sz=0)

List of random elements with a non-random size

class vsc.types.randsz_list_t(t)

List of random elements with a random size

Data and Constraints

vsc.coverage.covergroup(T)

Covergroup decorator marks as class as being a covergroup

class vsc.coverage.bin(*args)

Specifies a single coverage bin

build_cov_model(parent, name, exclude_bins: RangelistModel)

class vsc.coverage.bin_array(nbins, *args)

Specifies an array of bins

args may be one of two formats - Single list of tuples or lists of values or ranges (eg [[1], [2,4], [8]]) - Arguments comprising values and ranges (eg 1, [2,4], 8)

build_cov_model(parent, name, exclude_bins: RangelistModel)

class vsc.coverage.wildcard_bin(*args)

Specifies a single wildcard coverage bin

build_cov_model(parent, name, excluded_bins)

class vsc.coverage.wildcard_bin_array(nbins, *args)

Specifies an array of bins using wildcard specifications

args may be one of two formats - Single list of wildcard strings (eg “0x82x”) - Single list of value/mask tuples (eg [(0x820,0xFF0)]) - Single string - Single tuple

build_cov_model(parent, name, excluded_bins)

class vsc.coverage.binsof(cp)

intersect(rng)

class vsc.coverage.coverpoint(target, cp_t=None, iff=None, bins=None, ignore_bins=None, illegal_bins=None, options=None, type_options=None, name=None)

get_coverage()

get_inst_coverage()

build_cov_model(parent, name)

get_model()

get_val(cp_m)

set_val(val)

class vsc.coverage.cross(target_l, bins=None, options=None, name=None, iff=None)

build_cov_model(parent, name)

get_coverage()

Model API

Data and constraints

class vsc.model.field_composite_model.FieldCompositeModel(name, is_rand=False, rand_if=None)

finalize()

property is_declared_rand

set_used_rand(is_rand, level=0)

build(builder)

add_field(f) → FieldModel

get_field(idx)

set_field(idx, f)

find_field(name)

add_constraint(c)

get_constraint(name)

add_dynamic_constraint(c)

get_constraints(constraint_l)

get_fields(field_l)

pre_randomize()

Called during the randomization process to propagate pre_randomize event

post_randomize()

Called during the randomization process to propagate post_randomize event

accept(v)

dispose()

class vsc.model.constraint_block_model.ConstraintBlockModel(name, constraints=None)

Information about a top-level constraint block described by the user

set_constraint_enabled(en)

accept(v)

clone(deep=False) → ConstraintModel

class vsc.model.constraint_expr_model.ConstraintExprModel(e)

build(btor, soft=False)

accept(visitor)

clone(deep=False) → ConstraintModel

class vsc.model.constraint_if_else_model.ConstraintIfElseModel(cond: ExprModel, true_c: Optional[ConstraintScopeModel] = None, false_c: Optional[ConstraintScopeModel] = None)

build(btor, soft=False)

accept(visitor)

clone(deep=False) → ConstraintModel

class vsc.model.constraint_implies_model.ConstraintImpliesModel(cond, constraints=None)

build(btor, soft=False)

get_nodes(node_l)

accept(visitor)

clone(deep=False) → ConstraintModel

class vsc.model.constraint_model.ConstraintModel

Base class for all constraint models

dispose()

build(btor, soft=False) → BoolectorNode

get_nodes(node_l)

static and_nodelist(node_l, btor)

Creates a boolean AND across a list of expression nodes

accept(visitor)

clone(deep=False) → ConstraintModel

class vsc.model.constraint_scope_model.ConstraintScopeModel(constraints=None)

addConstraint(c) → ConstraintModel

build(btor, soft=False)

get_nodes(node_l)

accept(visitor)

clone(deep=False) → ConstraintModel

class vsc.model.constraint_unique_model.ConstraintUniqueModel(unique_l)

build(btor, soft=False)

get_nodes(node_l)

accept(visitor)

clone(deep=False) → ConstraintModel

Coverage

class vsc.model.covergroup_model.CovergroupModel(name: str, options=None)

finalize()

sample()

add_coverpoint(cp)

get_coverage()

coverage_ev(cp, bin_idx)

get_inst_coverage()

accept(v)

dump(ind='')

equals(oth: CovergroupModel) → bool

clone() → CovergroupModel

class vsc.model.covergroup_registry.CovergroupRegistry

accept(v)

static inst()

class vsc.model.coverpoint_bin_array_model.CoverpointBinArrayModel(name, low, high)

finalize(bin_idx_base: int) → int

Accepts the bin index where this bin starts ; returns number of bins

get_bin_expr(idx)

Builds expressions to represent a single bin

get_bin_name(bin_idx)

sample()

dump(ind='')

get_bin_range(bin_idx)

get_n_bins()

hit_idx()

accept(v)

equals(oth)

clone() → CoverpointBinArrayModel

class vsc.model.coverpoint_bin_collection_model.CoverpointBinCollectionModel(name)

DEBUG_EN = False

finalize(bin_idx_base: int) → int

Accepts the bin index where this bin starts ; returns number of bins

get_bin_expr(idx)

Builds expressions to represent the values in this bin

get_bin_name(idx)

add_bin(bin_m) → CoverpointBinModelBase

get_coverage()

sample()

get_bin_range(idx)

dump(ind='')

get_hits(idx)

get_n_bins()

hit_idx()

set_bin_type(bin_type)

accept(v)

equals(oth) → bool

clone() → CoverpointBinCollectionModel

static mk_collection(name: str, rangelist: RangelistModel, n_bins) → CoverpointBinCollectionModel

Creates a bin collection by partitioning a rangelist

class vsc.model.coverpoint_bin_enum_model.CoverpointBinEnumModel(name, val)

finalize(bin_idx_base: int) → int

Accepts the bin index where this bin starts ; returns number of bins

get_bin_name(bin_idx)

sample()

accept(v)

equals(oth) → bool

clone() → CoverpointBinEnumModel

class vsc.model.coverpoint_bin_model_base.CoverpointBinModelBase(name)

finalize(bin_idx_base: int) → int

Accepts the bin index where this bin starts ; returns number of bins

get_bin_expr(idx)

get_bin_name(bin_idx)

sample()

get_n_bins()

hit_idx()

set_bin_type(bin_type)

equals(oth)

class vsc.model.coverpoint_bin_single_bag_model.CoverpointBinSingleBagModel(name, binspec: Optional[RangelistModel] = None)

Coverpoint single bin that is triggered on a set of values or value ranges

finalize(bin_idx_base: int) → int

Accepts the bin index where this bin starts ; returns number of bins

get_bin_expr(bin_idx)

Builds expressions to represent the values in this bin

get_bin_name(bin_idx)

sample()

dump(ind='')

accept(v)

equals(oth) → bool

clone() → CoverpointBinSingleBagModel

class vsc.model.coverpoint_bin_single_range_model.CoverpointBinSingleRangeModel(name, target_val_low: int, target_val_high: int)

finalize(bin_idx_base: int) → int

Accepts the bin index where this bin starts ; returns number of bins

get_bin_expr(bin_idx)

Builds expressions to represent the values in this bin

get_bin_name(bin_idx)

sample()

accept(v)

equals(oth) → bool

clone() → CoverpointBinSingleRangeModel

class vsc.model.coverpoint_bin_single_val_model.CoverpointBinSingleValModel(name, target_val: int)

finalize(bin_idx_base: int) → int

Accepts the bin index where this bin starts ; returns number of bins

get_bin_expr(bin_idx)

Builds expressions to represent the values in this bin

get_bin_name(bin_idx)

sample()

get_bin_range(idx)

accept(v)

equals(oth) → bool

clone() → CoverpointBinSingleValModel

class vsc.model.coverpoint_cross_model.CoverpointCrossModel(name, options, iff=None)

set_target_value_cache(iff)

reset()

coverpoints()

get_coverage()

get_n_bins()

get_bin_expr(bin_idx: int) → ExprModel

select_unhit_bin(r: RandIF) → int

get_bin_hits(bin_idx)

get_bin_name(bin_idx) → str

add_coverpoint(cp_m)

finalize()

accept(v)

sample()

dump(ind='')

equals(oth: CoverpointCrossModel) → bool

clone(coverpoint_m) → CoverpointCrossModel

class vsc.model.coverpoint_model.CoverpointModel(target: ExprModel, name: str, options, iff: Optional[ExprModel] = None)

set_target_value_cache(val, iff=True)

reset()

add_bin_model(bin_m)

add_ignore_bin_model(bin_m)

add_illegal_bin_model(bin_m)

finalize()

get_bin_expr(bin_idx)

get_coverage() → float

get_inst_coverage()

sample()

select_unhit_bin(r: RandIF) → int

get_bin_range(bin_idx) → RangelistModel

coverage_ev(bin_idx, bin_type)

Called by a bin to signal that an uncovered bin has been covered

get_val()

accept(v)

dump(ind='')

get_n_bins()

get_n_ignore_bins()

get_n_illegal_bins()

get_n_hit_bins()

get_bin_hits(bin_idx)

get_ignore_bin_hits(bin_idx)

get_illegal_bin_hits(bin_idx)

get_bin_name(bin_idx) → str

get_ignore_bin_name(bin_idx) → str

get_illegal_bin_name(bin_idx) → str

get_hit_bins(bin_l)

equals(oth: CoverpointModel) → bool

clone() → CoverpointModel

Expressions

class vsc.model.rangelist_model.RangelistModel(rl: Optional[List[List[int]]] = None)

add_value(v)

add_range(low, high)

compact()

intersect(other)

Intersects another list or ranges with this one, trimming values that overlap

equals(oth) → bool

toString()

clone()

accept(v)