0% found this document useful (1 vote)
689 views15 pages

Specman Cheat Book

The document provides an overview and syntax guide for the e language. It covers topics such as syntax conventions, comments and identifiers, types, structs and units, methods, operators and flow control.

Uploaded by

Praphul MC
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (1 vote)
689 views15 pages

Specman Cheat Book

The document provides an overview and syntax guide for the e language. It covers topics such as syntax conventions, comments and identifiers, types, structs and units, methods, operators and flow control.

Uploaded by

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

e Language

Field Guide

Syntax Conventions
Comments, Identifiers & Literals
Types, Constants, Fields & Variables
Operators, Loops and Flow Control
Structs & Units
Methods & TCMs
Checking & Coverage
Packing & Simulator Interface
Events & Temporal Expressions (TE)
Generation & Constraints
Lists & List Pseudo-Methods
Actions (Predefined Routines)
Miscellaneous & Specman Test Flow

e Language
Field Guide
Revision 1.0 (for e v3.3)

The following conventions are used in this guide:


bold

->

Keywords & required syntax elements

name

->

User supplied/specified name

expr

->

User supplied/specified e expression

[xyz]

->

Optional elements ([ ] not included)

[]

->

Required elements ([ ] only)

->

Choice

...

->

Optional repeated element

->

Explanatory note

Syntax Conventions
Comments, Identifiers & Literals
Types, Constants, Fields & Variables
Operators, Loops and Flow Control
Structs & Units
Methods & TCMs
Checking & Coverage
Packing & Simulator Interface
Events & Temporal Expressions (TE)
Generation & Constraints
Lists & List Pseudo-Methods
Actions (Predefined Routines)
Miscellaneous & Specman Test Flow

Comments, Identifiers, & Literals


Sized Numeric Literals
Comments

All can include _ for readability and - for negation

Code blocks are enclosed by <'' '>


// or -- used for inline comments

Legal Characters

Identifiers
Case sensitive
Start with letter, then any combination of a-z, A-Z, _ and
0-9
File names follow these same rules and end with ''e''

#'d, #'D then: 0..9

2'd3, 8'D11, -14'D8763

Binary

#'b, #'B then: 0..1

-2'b11, 4'b10_01

Hex

#'x, #'X, #'h, #'H then: 8'x2F, -4'h1, 16'X2a_3b


0..9, a..f, A..F

Octal

#'o, #'O then 0..7

3'o7, -6'O37, 12'o55_66

String Literals
Any ASCII character or escape sequence enclosed in
Escape sequences: \n = new line \t = tab
\f = form feed \ = quote
\\ = backslash \r = carriage return

Unsized Numeric Literals


All may include _ for readability and - for negation
Decimals may use K (kilo *1024) and M (mega *10242)
Legal Characters

Examples

Decimal

Examples

Decimal

0..9

2K, 11, 3_456, -8763

Binary

0b, 0B then: 0..1

-0b11, 0B10_01

Hex

0x, 0X, 0h, 0H then:


0..9, a..f, A..F

0x2F, -0h10, 0X2a_3b

Octal

0o, 0O then 0..7

0o76, -0O37, 0o55_66

Character Literals
Single ASCII character enclosed in & preceded by 0c
var c: uint (bytes:2) = 0cA

Comments, Identifiers & Literals


Types, Constants, Fields & Variables
Operators, Loops & Flow Control
Structs & Units
Methods & TCMs
Checking & Coverage
Packing & Simulator Interface
Events & Temporal Expressions (TE)
Generation & Constraints
Lists & List Pseudo-Methods
Actions (Predefined Routines)
Miscellaneous & Specman Test Flow

Types, Constants, Fields & Variables


Constants
Predefined Types
Type
int
uint
bit
byte
time
bool
string
locker
file

Name

Description
32 bit signed integer
32 bit unsigned integer
1 bit unsigned integer (values: 0 or 1)
8 bit unsigned integer (values: 0..255)
64 bit unsigned integer (values: 0..263-1)
1 bit boolean (values: 0=FALSE, 1=TRUE)
A group of ASCII characters enclosed in
Struct to control access to shared resources
Used for file I/O

User-Defined Types (Statements)


Any user-defined struct/unit can be used as a type.
New scalar types can be defined and extended using:
type type_name : [name [=n],...];
extend type_name : [name [=n],...];
New scalar sub-types can be created using:
type type_name : [u]int (bits:n | bytes:n);

Default
0
0
0
0
0

Used with boolean variables, fields, and expr

FALSE

Used with boolean variables, fields, and expr

NULL

With structs = null pointer, with strings = empty

UNDEF

Indicates NONE when index or value expected

MAX_INT

Largest 32 bit int (231-1)

MAX_UINT Largest 32 bit uint (232-1)

FALSE

Smallest 32 bit int (-231)

MIN_INT

NULL
NULL
NULL

Description & Usage

TRUE

Fields (Struct/Unit Members)


[!!][%
%]field_name : type;
// !=dont gen %=physical
[!!][%
%]field_name : type [ (bits:n | bytes:n)];
// limit size
[!!][%
%]field_name : type [ [ min..max ] ]; // constrain gen value
// create list
[!!][%
%]field_name[gen_size] : list of type;

Variables (Actions)
var var_name : [ type ] [ = expr ]; // create a variable
// assign to existing variable
var_name = expr;

Type Conversion (Actions)


name = expr.as_a(type);

Types, Constants, Fields & Variables


Operators, Loops & Flow Control
Structs & Units
Methods & TCMs
Checking & Coverage
Packing & Simulator Interface
Events & Temporal Expressions (TE)
Generation & Constraints
Lists & List Pseudo-Methods
Actions (Predefined Routines)
Miscellaneous & Specman Test Flow

Operators, Loops & Flow Control


Looping Constructs (Actions)
Operators and Precedence (Expressions)
Operator
[]
[..]
[:]
f( )

Description

List indexing
List slicing
Bit slicing
Method call
Field selection

~
!, not
{;}
%{ }
Unary +, *, /, %
+, >>, <<
<, <=, >, >=
is [not] a
==, !=
===, !==
~, !~
[not] in
&, |, ^
&&, ||, and, or
=>
a?b:c

Bitwise not
Boolean not
List concatenation
Bit concatenation
Unary plus, minus
Multiply, divide, modulus
Add and subtract
Shift right, shift left
Comparison
Subtype identification
Equality, inequality
Verilog four-state comparison
String matching
Range list operator
Bitwise AND, OR, XOR
Boolean AND, OR
Boolean implication
Conditional operator (Ex: if a then b else c)

while bool_expr [do] { action; ... };


for {initial; bool_expr; step} [do] {action;...};
for iterator from expr [down] to expr [step expr]
[do] { action;... };
for each [type] [(iterator_name )]
[using index (index_name)]
in [reverse] list [do] { action;... };
for each file [(iterator_name )] matching file_name_expr
[do] { action;... };
for each line [(iterator_name )] in_file file_name
[do] { action;... };
break; terminates execution of the loop
continue; go to next loop iteration now

Flow Control Constructs (Actions)


if bool_expr [then] { action;... }
[else if bool_expr [then] { action;... }]
[else { action;... }];
case {bool_expr[:] { action;... };
[default[:] { action;...};] };
case expr {value[:] { action;... };
[default[:] { action;...};] };
all of { {action blk1;} {action blk1;}... };
first of { {action blk1;} {action blk1;}... };

Operators, Loops & Flow Control


Structs & Units
Methods & TCMs
Checking & Coverage
Packing & Simulator Interface
Events & Temporal Expressions (TE)
Generation & Constraints
Lists & List Pseudo-Methods
Actions (Predefined Routines)
Miscellaneous & Specman Test Flow

Structs & Units


when Inheritance (Struct/Unit Members)
when value['field] struct_type { struct/unit_member ;... };
extend value['field] struct_type { struct/unit_member ;... };

Defining (Statements)
struct struct_type [like struct_type] {
struct_member;... };
unit unit_type [like unit_type] { unit_member;... };

Example of using when inheritance


//Add non-generated field to GOOD version on my_unit
extend GOOD my_unit {
!data : my_struct;
};

Extending (Statements)
extend struct_type { new_struct_member;... };
extend unit_type { new_unit_member;... };

Predefined Methods (Struct/Unit Members)

See also when inheritance below.

Common
Methods

Instantiating (Struct/Unit Members)


// !=do not generate
[!!]field_name : struct_type;
// field name=struct type
[!!]struct_type;
[!!]field_name[gen_size] : list of struct_type; // create a list
// instantiate a unit
name : unit_type is instance;
// field name unit name
unit_name is instance;
field_name[gen_size] : list of unit_type;
// create a list
Example: define, extend & instantiate structs/units
struct my_struct {
struct_int : int;
};

unit my_unit {
kind
: [GOOD, BAD];
unit_int : int;
};

extend my_struct {
struct_int2 : int; // Add a new field to my_struct
};

Description

init()

Initializes ungenerated fields, etc.

pre_generate()

[empty] - Prepares for generation

post_generate() [empty] - Manipulates generated data


run()

[empty] - Starts TCMs at time 0

extract()

[empty] - Extracts from DUT post test

check()

[empty] - Defines post test check

quit()

Deactivates a struct/unit instance

finalize()

Creates final reports, etc.

copy()

Returns a non-recursive copy of struct

do_print()

Defines print format; called by print action

print_line()

Prints a struct/unit in a single line

do_pack()

Called when struct/unit is packed

do_unpack()

Called when struct/unit is unpacked

extend sys {
test_bench : my_unit is instance;
my_unit is instance; // instance of my_unit

hdl_path()

Ties unit to DUT component; units only

get _unit()

Returns reference to a unit

};

(get|try)_enclosing_unit(unit-type) Rtn ref nearest unit unit-type

Structs & Units


Methods & TCMs
Checking & Coverage
Packing & Simulator Interface
Events & Temporal Expressions (TE)
Generation & Constraints
Lists & List Pseudo-Methods
Actions (Predefined Routines)
Miscellaneous & Specman Test Flow

Methods & TCMs


Result & Return Keywords
Defining Methods (Struct/Unit Members)
method( [input: [*]type, ...] ) [ :return_type ] is {action;...};

result = expr;
return = [ expr; ]

Extending Methods (Struct/Unit Members)


method( [input: [*]type, ...] ) [ :return_type ]
is also | is first | is only { action;... };

Using Methods (Actions)


A regular method can be called from a regular method.
Example: method() is { method1(); method2();}

Inputs must match those previously defined.

Defining TCMs (Struct/Unit Members)


method( [input: [*]type, ...] ) [ :return_type ] @ event is
{ action;... };

A regular method or TCM can be called from a TCM.


Example: TCM()@event is { method1(); TCM1;}
A TCM can be started from a regular method or TCM.
Example: method() is { method1(); start TCM1;}

Extending TCMs (Struct/Unit Members)


method( [input: [*]type, ...] ) [ :return_type ] @ event
is also | is first | is only { action;... };

Example: using return, result, & invoking methods


extend test {
data
: list of byte;
!parity1 : byte;
!parity2 : byte;
parity_calc1(input:list of byte) :byte is {
result = 0;
for each (byte) in input {
result = result ^ byte

Time Consuming Actions (Actions)


sync TE;
wait [until] TE;

// continue when TE succeeds


// wait until next time TE succeeds

};

Example: define
struct test {
method1() is
method2() is
tcm1() @ clk

};

and extend methods and TCMs

parity_calc2() :byte is {
var tmp : byte = 0;
for each (byte) in data {
tmp = tmp ^ byte;

{ out(Hello - m1); };
{ out(Hello - m2); };
is { wait; out(Hello - tcm1); };

};

};

extend test {
method1() is also { out(2nd msg - m1); };
tcm1() is first { wait; out(1st msg - TCM); );
method2() is only { out(Only msg - m2); };

return tmp;
};

run() is also {
start tcm1; //tcm1 defined in prev example
parity1 = parity_calc1(data);
parity2 = parity_calc2();

};

Executing method1() results in:


Executing method2() results in:
Executing tcm1() results in:

Hello - m1; 2nd msg - m1


Only msg - m2
1st msg - TCM; Hello - tcm1

};
};

Methods & TCMs


Checking & Coverage
Packing & Simulator Interface
Events & Temporal Expressions (TE)
Generation & Constraints
Lists & List Pseudo-Methods
Actions (Predefined Routines)
Miscellaneous & Specman Test Flow

Checking & Coverage


Coverage Group Options
Data Checks (Actions)
check [ that ] bool_expr [else dut_error(string-expr)];

no_collect
count_only
global
text = string
weight = uint (default 1)
when = bool_expr radix = DEC | HEX | BIN (default DEC)

Temporal Checks (Struct/Unit Members)

Coverage Item Options

expect TE [ else dut_error(string-expr) ];

Setting dut_error() Response (Actions)


set_check ( match string, Check Effect );
Check Effect
Description
ERROR
Print message, increase num_dut_errors,
terminate method and test run
ERROR_
Print message, increase num_dut_errors,
BREAK_RUN stop simulation at next clock boundary
Print message, increase num_dut_errors,
ERROR_
AUTOMATIC terminate method as if hit stop_run()
ERROR_
CONTINUE
WARNING
IGNORE

Print message, increase num_dut_errors,


continue the test run
Print message, increase num_dut_warnings,
continue test run
No message and does not increase error or
warning counters

Coverage Definition (Struct/Unit Members)


cover group_event [using cover_group_options]
is [also] {

};

item name [ : type=expr ] [using cover_item_options, ...];


cross item1, item2, ...[using cover_item_options, ...];
transition item [using cover_item_options, ...];

no_collect
at_least = uint (default 1)
text = string
weight = uint (default 1)
when = bool_expr radix = DEC | HEX | BIN (default DEC)
ignore | illegal = cover_item_boolean_expr
ranges={range( [n..m], name, [every_count, at_least] );
range( [n..m], name, [every_count, at_least] ); }

Configuring Coverage (Actions)


set_config(cover, mode, coverage_mode );
coverage_mode: normal = save each sample/time
count_only = save only count/bucket
Typically, set_config is placed in an extension of the
global struct setup_test() method as shown below.
Example of defining coverage:
extend packet {
event pkt_data;
cover pkt_data using text=Packet Coverage is {
item address using illegal=address==0;
item data using
ranges={range([0..100], sm),
range([101..255], lg) },
radix = HEX, at_least = 10 ;
cross address, data ;
};
};

extend global {
setup_test() is also {
set_config(cover, mode, normal);
};
};

Checking & Coverage


Packing & Simulator Interface
Events & Temporal Expressions (TE)
Generation & Constraints
Lists & List Pseudo-Methods
Actions (Predefined Routines)
Miscellaneous & Specman Test Flow

Packing & Simulator Interface


Accessing HDL Signals (Expressions)
'[~/HDL/][path/]name [ @ x | @z ] '

// appends to hdl_path()

Packing (Expressions)
dest_name =pack( option, src_name [, src_name, ... ] );
unpack(option, src_name, dest_name [, dest_name, ...] );
options: packing.high packing.high_big_endian
packing.low
packing.low_big_endian
packing.network
list_of_bits.swap( unit_size, group_size );
Example of packing and unpacking:
struct packet {
%addr : uint (bits:4); keep addr == 2b1111;
%data : uint (bits:8); keep data == 8b10101010;
};

extend sys {
pkt1 : packet;
!pkt2 : packet;
test() is {
var packed : list of bit;
var swapped : list of bit;
packed=pack(packing.high, pkt1);//1111_10101010
unpack(packing.low, packed, pkt2); // oops!
swapped=packed.swap(4,12);
};
};

Executing sys.test() results in:


pkt2.addr=2b1010 and pkt2.data=8b1111_1010
swapped = 1010_10101111

Verilog Specifics (Statements/Struct/Unit Members)


verilog import filename;
verilog code {string [ ; string ] };
verilog time unit_time / precision;

verilog variable '~/HDL/path' using option, [, ...] ; // reg


options: net | wire, forcible
drive = verilog_expr
hold = verilog_expr // must also specify drive=
strobe = verilog_expr
verilog variable '~/HDL/path' [mem_range][width];
verilog function '~/HDL/path''(param1[, ...]) :rtn_bit_size;
verilog task '~/HDL/path' (param1[, ...]);

VHDL Specifics (Statements/Struct/Unit Members)


VHDL code {string [ ; string ] };
VHDL driver '~/HDL/path' using option [, ...];
options: disconnect value= sized_literal
delay= numeric_expr
mode= INERTIAL | TRANSPORT
initial value= sized_literal
VHDL time value units;
VHDL function 'name' using option [, ...];
options: interface= (param1[, ...]) return rtn_type
library= library_name
package= package_name
alias= alias_name
declarative_item= VHDL item;
VHDL procedure 'name' using option [, ...];
options: same as for VHDL function

force & release (Actions)


force '~/HDL/path' = expr;
release '~/HDL/path';
The force/release actions work for any VHDL signal, but
only work for Verilog signals declared forcible in a verilog
variable statement.

Packing & Simulator Interface


Events & Temporal Expressions (TE)
Generation & Constraints
Lists & List Pseudo-Methods
Actions (Predefined Routines)
Miscellaneous & Specman Test Flow

Events & Temporal Expressions (TE)


Defining Events (Struct/Unit Members)
event name;
event name is TE;
event name is only TE;

// named event
// temporal event
// extending

Triggering Events (Actions)


emit event_name;

// trigger named event (Action)

Acting On Events (Struct/Unit Members)


on event_name { action; ... };
TCMs also rely on events (see Methods & TCMs).

Predefined Events
sys.any
sys.tick_start
session.start_of_test
struct.quit sys.new_time

sys.tick_end
session.end_of_test

Temporal Expressions (Expressions)


TEs are valid only within wait and sync constructs,
event declarations, and expect constructs.

@[struct_instance.]event_name // event as a TE
TE @sampling_event
// TE w/ associated sampling event
change | rise | fall (expr)@
@sampling_event // transition TE
change | rise | fall ( '~/HDL/path' )@
@sim // HDL related TE
true(bool_expr)@
@sampling_event
// boolean condition TE
//
occurrence
of a sampling event
cycle @sampling_event
// specify a sim time delay of expr
delay( expr )
// repetition of TE, expr=numeric
[ expr ] [*TE]

[ [min] .. [max] ] [*TE]; TE2 // 1st match or TE2 var repeat


~[ [min] .. [max] ] [*TE]
// xlates: [min]*TE or [min+1]*TE...
{ TE1; TE2 [;...] }
// temporal sequence - TE1 then TE2
TE1 => TE2
// if TE1 succeeds, then TE2 must occur
// logical and/or
TE1 and | or TE2
// logical negation at any time
not TE
fail TE
// succeeds when all possibilities to pass are exhausted
// TE happens eventually
eventually TE
// creates a separate thread
detach(TE)
// exec action on TE succeed
TE exec { action; ... }
// remove event occurrence
consume( @event ;
Some examples of TE:
// Define sim controlled event (rise of clk)
event clk is rise ('~/top/clk') @sim;
// Event A occurs if TE1 and TE2 occur in the same
// clk cycle
event A is {TE1 and TE2} @clk;
// Event B occurs if TE2 occurs 1 cycle after TE1
// (action is exec when TE1 occurs)
event B is {TE1 exec{action;} ; TE2} @clk;
// Event C occurs if TE2 occurs within n1 & n2 clk
// cycles after TE1
event C is {TE1; [n1-1..n2-1]; TE2} @clk;
// Event D occurs if TE2 occurs after n clk cycles
// with no TE1
event D is V{[n]* not TE1 ; TE2} @clk;
// Event E occurs if TE3 occurs anytime after TE1
// with no TE2 in between
event E is {TE1; [..]*not TE2; TE3} @clk;
// TE2 must occur 1 clk cycle after TE1
expect TE1 => TE2 @clk;
// If TE1 occurs, eventually TE2 must occur
expect TE1 => (eventually TE2) @clk;
// TE3 must occur n cycles after TE1 or TE2 occur
expect (TE1 or TE2) => { [n-1]; TE3 } @clk;
// If TE1 occurs, TE2 cant occur for n cycles
expect TE1 => { [n]* not TE2; TE2 }@clk;
// If TE1 occurs ~/top/ready must be true
expect (not TE1 or true('~/top/ready'))@clk;
// If TE2 occurs, TE1 must occur n cycles before
expect TE2 => detach( {TE1; [n+1]} )@clk;

Events & Temporal Expressions (TE)


Generation & Constraints
Lists & List Pseudo-Methods
Actions (Predefined Routines)
Miscellaneous & Specman Test Flow

Generation & Constraints


Generation (Actions)
gen name;
// name can be a field, variable, or struct instance
gen name keeping { [soft] constraint_expr; ... };

Generation Methods (Struct/Unit Members)


Whenever a struct is generated, its predefined methods
are run in order. Extend these to tailor generation.
Method

Description

init()

Initializes ungenerated fields, etc.

pre_generate()

[empty] - prepares for generation

post_generate()

[empty] - manipulates generated data

Constraints (Struct/Unit Members)


[!!][%
%]field_name : type [ [ range ] ];
keep [soft] bool_expr;
keep [soft] name [not] in [ range ];
keep [soft] name [not] in list;
keep bool_expr1 => bool_expr2;
keep for each [(iterator_name)]
[using [index (index_name)] [prev (prev_name) ] ]
in list_name { [soft] bool_expr | nested_for_each };
keep soft name == select {weight : value;
weight : value;... };
keep [soft] gen (name1 [, ...] ) before (name2 [, ...]);
keep struct_list.is_all_iterations( .field_name [, ... ] );
keep struct_list.is_a_permutation( list );

keep name.reset_soft()
keep unit_name.hdl_path() == [~/HDL/][path/]string;
keep struct_name is [not] a value['field] struct_type;
Constraint Examples:
x : int [0..10];
// same as keep x in [0..10]
keep soft x == 1
// x defaults to 1
keep x <= y;
// x less than or equal to y
keep x in {3,4,5}; // x must be 3 or 4 or 5
keep x+y == z;
// restrict x+y to value z
keep parity = parity_calc(); // force w/ method
// if x is 1, then y must be in range 1..10
// translates to: x != 1 or y in [0..10]
keep x == 1 => y in [0..10];
struct packet {
kind :[good, bad];
addr : uint;
data : uint;
};
extend sys {
pkts : list of packet
keep pkts.size() < 20;
// gen < 20
keep for each (pkt) in pkts {
index > 0 =>
pkt.addr == prev.addr; // same addr
index==2 =>
pkt is a good packet;
// #3=good
};
list1 : list of packet;
!list2 : list of packet;
keep list1.is_all_iterations(.addr);
gen_one() is {
gen list2 keeping {
it.is_a_permutation(list1);
};
};

Generation & Constraints


Lists & List Pseudo-Methods
Actions (Predefined Routines)
Miscellaneous & Specman Test Flow

Lists & List Pseudo-Methods


Defining Lists (Struct/Unit Members)
[!!][%
%]field_name[gen_size] : list of type;
[!!][%
%]field_name[gen_size] : list (key: field_name) of type;
Ex: To create multi-dim arrays, create list structs:
struct one_dim { a : list of uint; };
struct two_dim { b : list of one_dim; };

Lists Pseudo-Methods (Actions/Expressions)


Direct Modification of a List
// add item or list to end of list
list.add(item | list);
// add item or list to start of list
list.add0(item | list);
// delete all items in list
list.clear();
list.delete(index);
// delete item at index (adjust others)
// delete item at index (move last)
list.fast_delete(index);
list.insert(index,item | list); // add item / list at index of list
// delete & return last item in list
item = list.pop();
// delete & return first item in list
item = list.pop0();
// add item to the end of list
list.push(item);
// add item to the start of list
list.push0(item);
list.resize(size [,full, filler, keep_old]); // pad or truncate list

Queries & General Operations on a List


// all w/ bool_expr=TRUE
list=list.all(bool_expr);
list1=list.all_indicies(bool_expr); // all w/ bool_expr=TRUE
// compute on each item
list1=list.apply(expr);
// # where bool_expr=TRUE
int=list.count(bool_expr);
// TRUE if index is in the list
bool=list.exists(index);
// 1st w/ bool_expr=TRUE
item=list.first(bool_expr);
int=list.first_index(bool_expr); // index 1st w/ bool_expr=TRUE
list1=list.get_indicies(list_of_int); // new list index items listed
bool=list.has(bool_expr);
// TRUE if list has bool_expr=TRUE

bool=list.is_a_permutation(list1);// checks list vs. list1


// TRUE if no items in list
bool=list.is_empty();
// last item bool_expr=TRUE
item=list.last(bool_expr);
int=list.last_index(bool_expr); // index last w/ bool_expr=TRUE
item=list.max(expr);
// item w/ expr calcs to max
// index w/ expr calcs max
int=list.max_index(expr);
// max value calcd for expr
int=list.max_value(expr);
// item w/ expr calcs to min
item=list.min(expr);
// index w/ expr calcs to min
int=list.min_index(expr);
// min value calcd for expr
int=list.min_value(expr);
// rev order of items of list
list1=list.reverse();
// number of items in the list
int=list.size();
list1=list.sort(expr);
// sort list incr order of expr value
list1=struct_list.sort_by_field(field); // sort list in incr order
var struct_list_holder := struct_list.split(expr); // split on expr
// return last item, no delete
item=list.top();
// return first item, no delete
item=list.top0();
list1=list.unique(expr);
// list1 where expr is unique in list

Math & Logic Operations on a List


bool=list.and_all(bool_expr); // AND of all w/ bool_expr=TRUE
// int avg expr calcd for ea item
int=list.average(expr);
// OR of all w/ bool_expr=TRUE
bool=list.or_all(bool_expr);
// int prod of expr calcd ea item
int=list.product(expr);
// int sum of expr calcd ea item
int=list.sum(expr);
int=list.crc_8(from,num);
// crc8 bit/byte list-start at from byte
int=list.crc_32(from,num); // crc32 bit/byte list-start at from byte
int=list.crc_32_flip(from,num); // crc32 ea byte & result flipped

Specifics for Keyed Lists


// list item with key = value
item=list.key(value);
// index of list item w/ key = value
int=list.key_index(value);
bool=list.key_exists(value); // TRUE if key = value exists in list

Lists & List Pseudo-Methods


Actions (Predefined Routines)
Miscellaneous & Specman Test Flow

Actions (Predefined Routines)


Output (Actions)
// output expr new line end
out(expr [,,expr...]);
outf(format_string,expr [,,expr...]); // formatted output of exprs
format_string = %[ 0 | - ] [ min# ] [. [ max# ] ] (s | d | x | b | o | u)
0 - pads w/ 0s not blanks s- string
b - binary
- aligns left
d - decimal
o - octal
x- hex
u - uint

Arithmetic (Expressions)
int= op=value // (op can be: +,-,*,/,%,&,|,^) ex: x +=1 increments x by 1
int=[min][max[(expr1,expr2); // min / max of expr1 or expr2
// absolute value of expr
int=abs(expr);
// TRUE if expr is odd
bool=odd(expr);
// TRUE if expr is even
bool=even(expr);
// log base-n of expr (n=2, 10)
int=ilogn(expr1);
// x to the power of y (xy)
int=ipow(expr1, expr2);
// square root of expr
int=isqrt(expr);
int=div_round_up(expr1,, expr2); // expr1 / expr2 round nxt int

Bitwise (Expressions)
bit=bitwise_op(expr);

// unary reduct(op = and, or, xor, nand, nor, xnor)

Copy and Compare (Expressions)


// recur struct copy
struct_type=deep_copy(struct_inst);
string_list=deep_compare(struct1,struct1,max); // recur all

string_list=deep_compare_physical(struct1,struct1,max);

String Manipulation (Expressions)


string=append(expr [,expr...]);
string=appendf(expr [,expr...]);
string=bin(expr [,expr...]);
string=dec(expr [,expr...]);
string=hex(expr [,expr...]);
string1=quote(string);

// concat expr to string

string1=str_chop(string,length); // truncate string to length


bool=str_empty(string);
// TRUE if string initd or empty
string1=str_exactly(string,length); // pad or trunc string to len
string1=str_expand_dots(string); // use with macro defines
string1=str_insensitive(reg_exp); // return AWK style reg expr
string1=str_join(string_list,sep); // concat using separator
// get the string length
int=str_len(string);
// conv string to lower case
string1=str_lower(string);
bool=str_match(string,reg_exp); // TRUE if string matches reg_exp
// pad string to length
string1=str_pad(string,length);
string1=str_replace(string,reg_exp,replacement);
string_list=str_split(string,sep); // break to strings on separator
string_list=str_split_all(string,sep); // separator also is string
string1=str_sub(string,from_int,length); // cut out substring
string1=str_upper(string);
// convert string to upper case
string1=expr.to_string(); // convert expr (struct, list, ...) to string

Misc (Actions/Expressions)
Actions
set_config(category, option, value [option,value])
[ [with] {action;...} ];
// set config for only specified actions
value_type=get_config(category, option); // value of option
// write config to file.ecfg
write_config(filename);
// read config from file.ecfg
read_config(filename);
// sets keep-across-restore
set_keep(TRUE | FALSE);
// gets keep-across-restore
bool=get_keep();
The keep-across-restore value controls whether config
& debug settings are retained across restores and reloads.
// concat & send to Specman
specman(command[,,...] );

spawn(command[,,...] );
spawn_check(command);

// concat & exec via system()


// send cmd-errors = error()

// concat fmtd (see outf)


// concat w/ binary num fmt

Expressions

// concat w/ dec num fmt

// snd cmd return result code


int=system(command);
string_list=output_from(command); // get result as string list
string_list=output_from_check(command); // calls error()
string=get_symbol(env_variable); // gets unix env variable
// gets current date and time
string=date_time();

// concat w/ hex num fmt


// copy of string in quotes

Actions (Predefined Routines)


Miscellaneous & Specman Test Flow

Specman Test Flow (Reference)

Miscellaneous
Compile Time Directives
// load e file; if no ext, .e used
import filename;
#ifdef [`]macro then { e code }; // if macro def, incl e code
#ifndef [`]macro then { e code};// if macro not def, incl e code

Initialization
Load
global.init()

Test

Macros

global.setup_test()

define [`]macro replacement;


// simple macro replacement
define <macro'non-terminal-type> match_string
as {replacement using <parsing elements>};
define <macro'non-terminal-type> match_string
as computed {replacement using <parsing elements>};

Pre-Run Generation
global.generate_test()

<struct>.init()

<struct>.pre_generate()

<struct>.post_generate()

Sharing Resources
resource_name: locker; // define locker filed in shared resrc
// reserve resource (waits until avail)
resource_name.lock();
resource_name.unlock(); // release the resource

State Machines

Simulation Run
global.start_test()

<struct>.quit()

Gen action
(on the fly)
global.run_test()

state machine state_holder [until final_state]


{ (transition | state) {action;...} ... };
transition can be: state => state or * => state

sys.time

global.stop_run()

<struct>.run()

Post-Run Check

File I/O

global.extract_test()

file=files.open(filename, mode, description);


mode can be: r, w, rw, a
// r / w line as text
bool=files.read[write](file, string);
bool=files.read[write]_lob((file, string); // r / w line as bin
// close open file
files.close(file);
// flush file buffers
files.flush(file);
string=files.add_file_type(name,ext,check_if_exists);

global.check_test()
<struct>.check()

Finalization

Legend

global.finalize_test()

Extendable method

Recursive call
Simulation run time

Non-extendable method

Miscellaneous & Specman Test Flow

Abstract phase flow

B u i l d y o u r k n o w - h o w.
Learn more than just e syntax. Learn how to apply
the language as a power tool for verifying todays
ultra complex systems.
Qualis offers a family of methodology-based training courses focused on Specman Elite. Youll go
from learning the basics of e to learning an
advanced verification methodology applying random constrained test generation, data/temporal
checking, and functional coverage. Detailed
course descriptions are available on our website at
www.qualis.com/learning.catalog.html/.
Attend a public course in North America or
Europe, or schedule a private onsite class. Start
building your verification knowledge today.

Qualis Design Corporation


Solutions in Advanced Verification and Design
Other quick reference cards available in print or from the web:
VHDL, Verilog, 1164 Packages and e Language.
Phone: +1.503.670.7200
Email: [email protected]

FAX: +1.503.670.0809
Web: http://www.qualis.com

We welcome your comments about this document.


Send them to [email protected]. Identify the revision (Rev 1.0).
2001 Qualis Design Corporation. Permission to reproduce and
distribute strictly verbatim copies of this document in whole is granted.

You might also like