Specifying Groups

In a TS attribute, you specify the set of paths to be analyzed by grouping start and end points in one of the following ways.

• Refer to a predefined group by specifying one of the corresponding keywords - FFS, PADS, LATCHES, or RAMS.
  
  
• Create your own groups within a predefined group by tagging symbols with TNM (pronounced tee-name) attributes.
  
  
• Create groups that are combinations of existing groups using TIMEGRP symbols.
  
  
• Create groups by pattern matching on net names.
  
  

The following sections discuss each method in detail.

Using Predefined Groups

You can refer to a group of flip-flops, input latches, pads, or RAMs by using the corresponding keywords.

From-To statements enable you to define timing specifications for paths between predefined groups. The following examples are TS attributes that reside in the TIMESPEC primitive or are entered in the UCF. This method enables you to easily define default timing specifications for the design, as illustrated by the following examples.

Schematic syntax in TIMESPEC primitive

TS01=FROM FFS TO FFS 30
TS02=FROM LATCHES TO LATCHES 25
TS03=FROM PADS TO RAMS 70
TS04=FROM FFS TO PADS 55

UCF syntax

TIMESPEC TS01=FROM FFS TO FFS 30;
TIMESPEC TS02=FROM LATCHES TO LATCHES 25;
TIMESPEC TS03=FROM PADS TO RAMS 70;
TIMESPEC TS04=FROM FFS TO PADS 55;

A predefined group can also carry a name qualifier; the qualifier can appear any place where the predefined group is used. This name qualifier restricts the number of elements being referred to. The syntax used is as follows.

predefined group (name_qualifier [ name_qualifier ])

name_qualifier is the full hierarchical name of the net that is sourced by the primitive being identified.

The name qualifier can include wildcard characters (*) to indicate any number of characters (or ? to indicate a single character) which allows the specification of more than one net or allows you to shorten the full hierarchical name to something that is easier to type.

As an example, specifying the group FFS(MACRO_A/Q?) selects only the flip-flops driving the Q0, Q1, Q2 and Q3 nets in the following macro.

Figure 6.2 Using Qualifiers with Predefined Groups

To create more specific groups see the following section.

Creating User-Defined Groups Using TNMs

A TNM (timing name) is an attribute that can be used to identify the elements that make up a group which can then be used in a timing specification. A TNM is a property that you place directly on your schematic to tag a specific net, element pin, primitive or macro.
All symbols tagged with the TNM identifier are considered a group. Place TNM attributes directly on your schematic or in a UCF file using the following syntax. Special rules apply when using TNM with the PERIOD constraint for Virtex CLKDLLs. Refer to the “PERIOD Specifications on CLKDLLs” section.

Schematic syntax

TNM=identifier

UCF syntax

{NET | INST | PIN} object_name TNM=identifier;

identifier is a value that consists of any combination of letters, numbers, or underscores. Keep the TNM short for convenience and clarity.

Do not use the reserved words FFS, LATCHES, PADS, RAMS, RISING, FALLING, TRANSHI, TRANSLO, or EXCEPT, as identifiers. The constraints in the table below are also reserved words and should not be used as identifiers.

Note: If you want to use a keyword as an identifier, you can enclose the keyword in quotation marks. In the TNM statement TNM=RAMS ”CMOS”, CMOS is treated as an identifier instead of a keyword.

You can specify as many groups of end points as are necessary to describe the performance requirements of your design. However, to simplify the specification process and reduce the place and route time, use as few groups as possible.

A predefined group can be used in a TNM specification, using the following syntax on a schematic or UCF file.

Schematic syntax

TNM=predefined_group identifier

UCF syntax

{NET | INST | PIN} object_name TNM=predefined_group identifier;

The object_name is the net, pin, or instance name.

The predefined_group is one of the groups (for example, FFS or RAMS) defined in the “Using Predefined Groups” section and identifier is a value that consists of any combination of letters, numbers, or underscores. Paths defined by the TNM are traced forward if placed on a net or pin, through any number of gates or buffers, until they reach a member of the predefined_group. That element is added to the specified TNM group. TNM does not trace through the element to the next element; forward tracing stops at the element.


This mechanism is called forward tracing. If TNM is placed on an instance, paths are traced “downward” through a hierarchy instead of forward along a net.

Note: If a TNM is placed on an input pad net, the constraint only applies to the input pad. In that case, refer to the “Creating User-Defined Groups Using TNM_NET” section.

The specification shown below, when attached to a net, would create a group called FIFO_CORE consisting of all of the RAM primitives traced forward on the net. The specification shows the schematic and UCF syntax.

Schematic syntax

TNM=RAMS FIFO_CORE

UCF syntax

NET net_name TNM=RAMS FIFO_CORE;

The following figure illustrates the preceding TNM identifier. The two RAMs traced forward from the net are included in the group. The flip flop is not.

Figure 6.3 TNM Placed on a Net

A defined net in a TNM statement can have a name qualifier (for example, TNM=FFS (FRED*) GRP_A), as described in the “Creating Groups by Pattern Matching” section.

You can use several methods for tagging groups of end points: placing identifiers on nets, macro or primitive pins, primitives, or macro symbols. Which method you choose depends on how the path end points are related in your design. For each of these elements, you can use the predefined group syntax described earlier in this section.

The following subsections discuss the different methods of placing TNMs in your design. The same TNM attribute can be used as many ways and as many times as necessary to get the TNM applied to all of the elements in the desired group.

You can place TNM attributes in either of two places: in the schematic as discussed in this section or in a constraints file (UCF or NCF).

The syntax for specifying TNMs in a UCF or NCF constraints file is described in the “Attributes, Constraints, and Carry Logic” chapter of the Libraries Guide.

Placing TNMs on Nets

The TNM attribute can be placed on any net in the design. The attribute indicates that the TNM value should be attached to all valid elements fed by all paths that fan forward from the tagged net. Forward tracing stops at any flip-flop, latch, RAM or pad. See the “TNM Placed on a Net” figure. TNMs do not propagate across IBUFs if they are attached to the input pad net. Also refer to the “Creating User-Defined Groups Using TNM_NET” section.

Placing TNMs on Macro or Primitive Pins

The TNM attribute can be placed on any macro or component pin in the design if the design entry package allows placement of attributes on macro or primitive pins. The attribute indicates that the TNM value should be attached to all valid elements fed by all paths that fan forward from the tagged pin. Forward tracing stops at any flip-flop, latch, RAM or pad. The following illustration shows the valid elements for a TNM attached to the schematic a macro pin.

Figure 6.4 TNM Placed on a Macro Pin

The syntax for the UCF file would be

PIN pin_name TNM=FFS FLOPS;

Placing TNMs on Primitive Symbols

You can group individual logic primitives explicitly by flagging each symbol, as illustrated by the following figure.

Figure 6.5 TNM on Primitive Symbols

In the figure, the flip-flops tagged with the TNM form a group called “`FLOPS.” The untagged flip-flop on the right side of the drawing is not part of the group.

Place only one TNM on each symbol, driver pin, or macro driver pin.

Schematic syntax

TNM=FLOPS

UCF syntax

INST symbol_name TNM=FLOPS;

Placing TNMs on Macro Symbols

A macro is an element that performs some general purpose higher level function. It typically has a lower level design that consists of primitives, other macros, or both, connected together to implement the higher level function. An example of a macro function is a 16-bit counter.

A TNM attribute attached to a macro indicates that all elements inside the macro (at all levels of hierarchy below the tagged macro) are part of the named group.

When a macro contains more than one symbol type and you want to group only a single type, use the TNM identifier in conjunction with one of the predefined groups: FFS, RAMS, PADS, or LATCHES as indicated by the following syntax examples.

Schematic syntax

TNM=FFS identifier
TNM=RAMS identifier
TNM=LATCHES identifier
TNM=PADS identifier

UCF syntax

INST macro_name TNM=FFS identifier;
INST macro_name TNM=RAMS identifier;
INST macro_name TNM=LATCHES identifier;
INST macro_name TNM=PADS identifier;

If multiple symbols of the same type are contained in the same hierarchical block, you can simply flag that hierarchical symbol, as illustrated by the following figure. In the figure, all flip-flops included in the macro are tagged with the TNM ``FLOPS”. By tagging the macro symbol, you do not have to tag each underlying symbol individually.

Figure 6.6 TNM on Macro Symbol

Placing TNMs on Nets or Pins to Group Flip-Flops and Latches

You can easily group flip-flops, latches, or both by flagging a common input net, typically either a clock net or an enable net. If you attach a TNM to a net or driver pin, that TNM applies to all flip-flops and input latches that are reached through the net or pin. That is, that path is traced forward, through any number of gates or buffers, until it reaches a flip-flop or input latch. That element is added to the specified TNM group.

The following figure illustrates the use of a TNM on a net that traces forward to create a group of flip-flops.


In the figure, the attribute TNM=FLOPS traces forward to the first two flip-flops, which form a group called FLOPS. The bottom flip-flop is not part of the group FLOPS.

Figure 6.7 TNM on Net Used to Group Flip-Flops

The following figure illustrates placing a TNM on a clock net, which traces forward to all three flip-flops and forms the group Q_FLOPS.

Figure 6.8 TNM on Clock Pin Used to Group Flip-Flops

The TNM parameter on nets or pins is allowed to have a qualifier.

For example, on schematics

TNM=FFS data

TNM=RAMS fifo

TNM=LATCHES capture

In UCF files

{NET | PIN} net_or_pin_name TNM=FFS data;

{NET | PIN} net_or_pin_name TNM=RAMS fifo;

{NET | PIN} net_or_pin_name TNM=LATCHES capture;

A qualified TNM is traced forward until it reaches the first storage element (flip-flop, latch, or RAM). If that type of storage element matches the qualifier, the storage element is given that TNM value. Whether or not there is a match, the TNM is not traced through that storage element.

TNM parameters on nets or pins are never traced through a storage element (flip-flop, latch or RAM).

Creating User-Defined Groups Using TNM_NET

A TNM_NET (timing name for nets) is an attribute that can be used to identify the elements that make up a group which can then be used in a timing specification. Essentially TNM_NET is equivalent to TNM on a net except for pad nets. Special rules apply when using TNM_NET with the PERIOD constraint for Virtex CLKDLLs. Refer to the “PERIOD Specifications on CLKDLLs” section.

A TNM_NET is a property that you normally use in conjunction with an HDL design to tag a specific net. All nets tagged with the TNM_NET identifier are considered a group. The UCF syntax is as follows.

NET net_name TNM_NET=identifier;

identifier is a value that consists of any combination of letters, numbers, or underscores. Keep the TNM_NET short for convenience and clarity. The basic syntax rules for TNM_NET and TNM are identical. Refer to the “Creating User-Defined Groups Using TNMs” section for details.

The TNM_NET attribute can be used to define certain types of nets that cannot be adequately described by the TNM constraint. This attribute is specifically targeted for use in HDL designs.

For example, consider the following design.

In the preceding design, a TNM associated with the PAD symbol only includes the PAD symbol as a member in a timing analysis group. For example, the following UCF file entry creates a time group that includes the IPAD symbol only.

NET PADCLK TNM=PADS(*) PADGRP; (UCF file example)

However, using TNM to define a time group for the net PADCLK creates an empty time group.

NET PADCLK TNM=FFS(*) FFGRP;(UCF file example)

All properties that apply to a pad are transferred from the net to the PAD symbol. Since the TNM is transferred from the net to the PAD symbol, the qualifier, “FFS(*)” does not match the PAD symbol.

To overcome this obstacle for schematic designs using TNM, you can create a time group for the INTCLK net.

NET INTCLK TNM=FFS(*) FFGRP;(UCF file example)

However, for HDL designs, the only meaningful net names are the ones connected directly to pads. Then, use TNM_NET to create the FFGRP time group.

NET PADCLK TNM_NET=FFS(*) FFGRP;(UCF file example)

NGDBuild does not transfer a TNM_NET attribute from a net to a PAD as it does with TNM.

TNM_NET can be used in NCF or UCF files as a property attached to an object in an input netlist (EDIF or XNF). TNM_NET is not supported in PCF files.

TNM_NET can only be used with nets. If TNM_NET is used with any other object such as a pin or symbol, a warning is generated and the TNM_NET definition is ignored.

Creating New Groups from Existing Groups

In addition to naming groups using the TNM identifier, you can also define groups in terms of other groups. You can create a group that is a combination of existing groups by defining a TIMEGRP attribute as follows.

Schematic syntax in TIMEGRP primitive

newgroup=existing_grp1 existing_grp2 [ existing_grp3 . . .]

UCF syntax

TIMEGRP newgroup=existing_grp1 existing_grp2 [ existing_grp3 . . .];

newgroup is a newly created group that consists of existing groups created via TNMs, predefined groups, or other TIMEGRP attributes.

The Mentor netlist writer (ENWRITE™) converts all property names to lower case letters, and the Xilinx netlist reader EDIF2NGD then converts the property names to upper case letters. To ensure references from one constraint to another are processed correctly,

• Group names should contain only upper case letters on a Mentor Schematic (MY_FLOPS, for example, but not my_flops or My_flops).
  
  
• If a group name appears in a property value, it must also be expressed in upper case letters. For example, the GROUP3 in the first constraint below must be entered in upper case letters to match the GROUP3 in the second constraint.
  
  Schematic syntax in TIMEGRP primitive
  
  GROUP1 = gr2 GROUP3
  GROUP3 = FFS except grp5
  
  UCF syntax
  
  TIMEGRP GROUP1 = gr2 GROUP3;
  TIMEGRP GROUP3 = FFS except grp5;
  
  

TIMEGRP attributes reside in the TIMEGRP primitive, as illustrated in the figure below. Once you create a TIMEGRP attribute definition within a TIMEGRP primitive, you can use it in the TIMESPEC primitive. Each TIMEGRP primitive can hold up to eight group definitions. Since your design might include more than eight TIMEGRP attributes, you can use multiple TIMEGRP primitives.

Figure 6.9 TIMEGRP Primitive

You can place TIMEGRP attributes in either of two places: in the TIMEGRP primitive on the schematic as discussed in this section or in a constraints file (UCF or NCF). The syntax for specifying TIMEGRPs in a UCF or NCF constraints file is described in the “Attributes, Constraints, and Carry Logic” chapter of the Libraries Guide.

You can use TIMEGRP attributes to create groups using the following methods.

• Combining multiple groups into one
  
  
• Creating groups by exclusion
  
  
• Defining flip-flop subgroups by clock sense
  
  

The following subsections discuss each method in detail.

Combining Multiple Groups into One

You can define a group by combining other groups. The following syntax example illustrates the simple combining of two groups.

Schematic syntax in TIMEGRP primitive

big_group=small_group medium_group

UCF syntax

TIMEGRP big_group=small_group medium_group;

In this syntax example, small_group and medium_group are existing groups defined using a TNM or TIMEGRP attribute. Within the TIMEGRP primitive, TIMEGRP attributes can be listed in any order; that is, you can create a TIMEGRP attribute that references another TIMEGRP attribute that appears after the initial definition.

Note: A circular definition, as shown below, causes an error when you run your design through NGDBuild.

Schematic syntax in TIMEGRP primitive

many_ffs=ffs1 ffs2
ffs1=many_ffs ffs3

UCF syntax

TIMEGRP many_ffs=ffs1 ffs2;
TIMEGRP ffs1=many_ffs ffs3;

Creating Groups by Exclusion

You can define a group that includes all elements of one group except the elements that belong to another group, as illustrated by the following syntax examples.

Schematic syntax in TIMEGRP primitive

group1=group2 EXCEPT group3

UCF syntax

TIMEGRP group1=group2 EXCEPT group3;

• group1 represents the group being defined. It contains all of the elements in group2 except those that are also in group3.
  
  
• group2 and group3 can be a valid TNM, predefined group, or TIMEGRP attribute.
  
  

As illustrated by the following example, you can specify multiple groups to include or exclude when creating the new group.

Schematic syntax in TIMEGRP primitive

group1=group2 group3 EXCEPT group4 group5

UCF syntax

TIMEGRP group1=group2 group3 EXCEPT group4 group5;

The example defines a group1 that includes the members of group2 and group3, except for those members that are part of group4 or group5. All of the groups before the keyword EXCEPT are included, and all of the groups after the keyword are excluded.

Certain reserved words cannot be used as group names. These reserved words are described in the “Creating User-Defined Groups Using TNMs” section.

Defining Flip-Flop Subgroups by Clock Sense

You can create subgroups using the keywords RISING and FALLING to group flip-flops triggered by rising and falling edges.

Schematic syntax in TIMEGRP primitive

group1=RISING ffs
group2=RISING ffs_group
group3=FALLING ffs
group4=FALLING ffs_group

UCF syntax

TIMEGRP group1=RISING ffs;
TIMEGRP group2=RISING ffs_group;
TIMEGRP group3=FALLING ffs;
TIMEGRP group4=FALLING ffs_group;

group1 to group4 are new groups being defined. The ffs_group must be a group that includes only flip-flops.

Note: Keywords, such as EXCEPT, RISING, and FALLING, appear in the documentation in upper case; however, you can enter them in the TIMEGRP primitive in either lower or upper case. You cannot enter them in a combination of lower and upper case.

The following example defines a group of flip-flops that switch on the falling edge of the clock.

Schematic syntax in TIMEGRP primitive

falling_ffs=FALLING ffs

UCF syntax

TIMEGRP falling_ffs=FALLING ffs;

Defining Latch Subgroups by Gate Sense

Groups of type LATCHES (no matter how these groups are defined) can be easily separated into transparent high and transparent low subgroups. The TRANSHI and TRANSLO keywords are provided for this purpose, and are used in TIMEGRP statements like the RISING and FALLING keywords for flip-flop groups. For example

Schematic syntax in TIMEGRP primitive

lowgroup=TRANSLO latchgroup
highgroup=TRANSHI latchgroup

UCF syntax

TIMEGRP lowgroup=TRANSLO latchgroup;
TIMEGRP highgroup=TRANSHI latchgroup;

Creating Groups by Pattern Matching

When creating groups, you can use wildcard characters to define groups of symbols whose associated net names match a specific pattern.

How to Use Wildcards to Specify Net Names

The wildcard characters, * and ?, enable you to select a group of symbols whose output net names match a specific string or pattern. The asterisk (*) represents any string of zero or more characters. The question mark (?) indicates a single character.

For example, DATA* indicates any net name that begins with “DATA,” such as DATA, DATA1, DATA22, DATABASE, and so on. The string NUMBER? specifies any net names that begin with ``NUMBER” and end with one single character, for example, NUMBER1, NUMBERS but not NUMBER or NUMBER12.

You can also specify more than one wildcard character. For example, *AT? specifies any net names that begin with any series of characters followed by ``AT” and end with any one character such as BAT1, CAT2, and THAT5. If you specify *AT??, you would match BAT11, CAT26, and THAT50.

Pattern Matching Syntax

The syntax for creating a group using pattern matching is shown below.

Schematic syntax in TIMEGRP primitive

group=predefined_group(pattern)

UCF syntax

TIMEGRP group=predefined_group(pattern);

predefined_group can only be one of the following predefined groups - FFS, LATCHES, PADS, or RAMS. The pattern is any string of characters used in conjunction with one or more wildcard characters.

Note: When specifying a net name, you must use its full hierarchical path name so PAR can find the net in the flattened design.

For flip-flops, input latches, and RAMs, specify the output net name. For pads, specify the external net name.

The following example illustrates creating a group that includes the flip-flops that source nets whose names begin with $1I3/FRED.

Schematic syntax in TIMEGRP primitive

group1=ffs($1I3/FRED*)

UCF syntax

TIMEGRP group1=ffs($1I3/FRED*);

The following example illustrates a group that excludes certain flip-flops whose output net names match the specified pattern.

Schematic syntax in TIMEGRP primitive

this_group=ffs EXCEPT ffs(a*)

UCF syntax

TIMEGRP this_group=ffs EXCEPT ffs(a*);

In this example, this_group includes all flip-flops except those whose output net names begin with the letter “a.”

The following defines a group named “some_latches”.

Schematic syntax in TIMEGRP primitive

some_latches=latches($1I3/xyz*)

UCF syntax

TIMEGRP some_latches=latches($113/xyz*);

The group some_latches contains all input latches whose output net names start with “$1I3/xyz.”

Additional Pattern Matching Details

In addition to using pattern matching when you create timing groups, you can specify a predefined group qualified by a pattern any place you specify a predefined group. The syntax below illustrates how pattern matching can be used within a timing specification.

Schematic syntax in TIMESPEC primitive

TSidentifier=FROM predefined_group(pattern) TO predefined_group
(pattern) delay

UCF syntax

TIMESPEC TSidentifier=FROM predefined_group(pattern) TO predefined_group (pattern) delay;

Instead of specifying just one pattern, you can also specify a list of patterns separated by a colon (:) as illustrated below.

Schematic syntax in TIMEGRP primitive

some_ffs=ffs(a*:b?:c*d)

UCF syntax

TIMEGRP some_ffs=ffs(a*:b?:c*d);

The group some_ffs contains flip-flops whose output net names adhere to one of the following rules.

• Start with the letter “a”
  
  
• Contain two characters; the first character is “b”
  
  
• Start with “c” and end with “d”