Scribd
Upload
116 views2 pages

Example 1:: by Default, Structures Are Unpacked. Unpacked Structures Can Contain Any Data Type

The document compares always_comb and always @* constructs in Verilog. It notes that: 1) always_comb automatically executes once at time zero while always @* waits for a change on a signal in its sensitivity list. 2) always_comb is sensitive to changes within functions while always @* is only sensitive to arguments of functions. 3) Variables on the left side of assignments in always_comb cannot be written to by other processes.

Uploaded by

RAGUL RAJ S
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
116 views2 pages

Example 1:: by Default, Structures Are Unpacked. Unpacked Structures Can Contain Any Data Type

The document compares always_comb and always @* constructs in Verilog. It notes that: 1) always_comb automatically executes once at time zero while always @* waits for a change on a signal in its sensitivity list. 2) always_comb is sensitive to changes within functions while always @* is only sensitive to arguments of functions. 3) Variables on the left side of assignments in always_comb cannot be written to by other processes.

Uploaded by

RAGUL RAJ S
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 2

always_comb compared to always @*

 always_comb automatically  always @* waits until a


executes once at time zero, change occurs on a signal in the
 always_comb is sensitive to inferred sensitivity list
changes within the contents of a  always @* is only sensitive
function, to changes to the arguments of a
 always_comb is sensitive to function.
expressions in immediate  always @* is sensitive to
assertions within the procedure expressions in immediate
and within the contents of a assertions within the procedure
function called in the procedure only.
 Variables on the left-hand side of  always @* permits multiple
assignments within an processes to write to the same
always_comb procedure, variable.
including variables from the  always @* is sensitive to
contents of a called function, shall expressions in immediate
not be written to by any other assertions within the procedure
processes only.
 always_comb is sensitive to
expressions in immediate
assertions within the procedure Example 1:
and within the contents of a always @(*) // equivalent
function called in the procedure, to @(a or b or c or d or
Eg. f)
always_comb y = (a & b) | (c & d) |
a = b & c; myfunction(f);
always_comb Example 2:
d <= #1ns b & c; always @* begin //
equivalent to @(a or b or
c or d or tmp1 or tmp2)
tmp1 = a & b;
tmp2 = c & d;
y = tmp1 | tmp2;
end
Example 3:
always @* begin //
equivalent to @(b)
@(i) kid = b; // i is not
added to @*
end

Structures
 A structure represents a collection of data types that can be referenced as a whole, or
the individual data types that make up the structure can be referenced by name.
 By default, structures are unpacked. Unpacked structures can contain any data type.
Structure declarations follow the C syntax, but without the optional structure tags before the “{”. The syntax
for structure declarations is

Eg
struct { bit [7:0] opcode; bit [23:0] addr; }IR; // anonymous structure
// defines variable IR
IR.opcode = 1; // set field in IR.

typedef struct {
bit [7:0] opcode;
bit [23:0] addr;
} instruction; // named structure type
instruction IR; // define variable

Unions
 A union is a data type that represents a single piece of storage that can be accessed using one of the
named member data types. Only one of the data types in the union can be used at a time.
 By default, a union is unpacked, meaning there is no required representation for how members of the
union are stored.
 Dynamic types and chandle types can only be used in tagged unions

Examples:
typedef union { int i; shortreal f; } num; // named union type
num n;
n.f = 0.0; // set n in floating point format
typedef struct {
bit isfloat;
union { int i; shortreal f; } n; // anonymous union type
} tagged_st; // named structure

Packed and unpacked arrays

 The term packed array is used to refer to the dimensions declared before the data identifier name.
 The term unpacked array is used to refer to the dimensions declared after the data identifier name.

bit [7:0] c1; // packed array of scalar bit types


real u [7:0]; // unpacked array of real types

Packed arrays

 A packed array is a mechanism for subdividing a vector into subfields, which can be conveniently
accessed as array elements.
 packed array is guaranteed to be represented as a contiguous set of bits. An unpacked array may or may
not be so represented

byte c2; // same as bit signed [7:0] c2;


integer i1; // same as logic signed [31:0] i1;

Unpacked arrays
 Unpacked arrays can be made of any data type.
 Arrays whose elements are themselves arrays are declared as multidimensional arrays

int Array[0:7][0:31]; // array declaration using ranges


int Array[8][32]; // array declaration using sizes

You might also like