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.
The following sections discuss each method in detail.
You can refer to a group of flip-flops, input latches, pads, or RAMs by using the corresponding keywords.
| Keyword | Description |
|---|---|
| FFS | CLB or IOB flip-flops only; not flip-flops built from function generators (Shift Register LUTs in Virtex also) |
| LATCHES | CLB or IOB latches only; not latches built from function generators |
| PADS | Input/Output pads |
| RAMS | For architectures with RAMS (LUT RAMS and Block RAMS for Virtex) |
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 4.2 Using Qualifiers with Predefined Groups |  |
To create more specific groups see the following section.
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.
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.
| Reserved Words (Constraints) | ||
|---|---|---|
| ADD | FAST | NODELAY |
| ALU | FBKINV | OPT |
| ASSIGN | FILE | OSC |
| BEL | F_SET | RES |
| BLKNM | HBLKNM | RLOC |
| CAP | HU_SET | RLOC_ORIGIN |
| CLKDV_DIVIDE | H_SET | RLOC_RANGE |
| CLBNM | INIT | SCHNM |
| CMOS | INIT OX | SLOW |
| CYMODE | INTERNAL | STARTUP_WAIT |
| DECODE | IOB | SYSTEM |
| DEF | IOSTANDARD | TNM |
| DIVIDE1_BY | LIBVER | TRIM |
| DIVIDE2_BY | LOC | TS |
| DOUBLE | LOWPWR | TTL |
| DRIVE | MAP | TYPE |
| DUTY_CYCLE_ CORRECTION | MEDFAST | USE_RLOC |
| EQN | MEDSLOW | U_SET |
| FAST | MINIM | |
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.
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 4.3 TNM Placed on a Net | |
A defined net in a TNM statement can have a name qualifier (for example, TMM=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.
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.
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 4.4 TNM Placed on a Macro Pin | |
The syntax for the UCF file would be
PIN pin_name TNM=FFS FLOPS;
You can group individual logic primitives explicitly by flagging each symbol, as illustrated by the following figure.
Figure 4.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;
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 4.6 TNM on Macro Symbol | |
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 4.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 4.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). In previous XACTstep® software releases, they were traced through some pins on input latches and RAMs. If you rely on this behavior, move the TNM parameter so that it reaches the target flip-flop directly or place a TNM parameter on the target flip-flop symbol.
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.
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.
TMN_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.
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,
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 4.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.
The following subsections discuss each method in detail.
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.
WARNINGA 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;
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;
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.
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.
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;
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;
When creating groups, you can use wildcard characters to define groups of symbols whose associated net names match a specific pattern.
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.
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.
WARNINGWhen 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.”
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
